diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4abd55e3f45a..6fbb74dfba00 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -135,5 +135,8 @@ jobs:
       - name: Install .NET Workloads
         run: dotnet workload install maui-ios
 
+      - name: Select Xcode 16
+        run: sudo xcode-select -s /Applications/Xcode_16.app/Contents/Developer
+
       - name: Build
         run: dotnet build -c Debug osu.iOS
diff --git a/osu.Android.props b/osu.Android.props
index b5a355a77f01..6b42258b4989 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="2024.809.2" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2024.927.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.
diff --git a/osu.Android/OsuGameAndroid.cs b/osu.Android/OsuGameAndroid.cs
index a235913ef3aa..ffab7dd86da2 100644
--- a/osu.Android/OsuGameAndroid.cs
+++ b/osu.Android/OsuGameAndroid.cs
@@ -80,7 +80,7 @@ public override void SetHost(GameHost host)
             host.Window.CursorState |= CursorState.Hidden;
         }
 
-        protected override UpdateManager CreateUpdateManager() => new SimpleUpdateManager();
+        protected override UpdateManager CreateUpdateManager() => new MobileUpdateNotifier();
 
         protected override BatteryInfo CreateBatteryInfo() => new AndroidBatteryInfo();
 
diff --git a/osu.Desktop/OsuGameDesktop.cs b/osu.Desktop/OsuGameDesktop.cs
index 3e06dad4c54b..46bd894c07e2 100644
--- a/osu.Desktop/OsuGameDesktop.cs
+++ b/osu.Desktop/OsuGameDesktop.cs
@@ -2,10 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Diagnostics;
 using System.IO;
 using System.Reflection;
 using System.Runtime.Versioning;
+using System.Threading.Tasks;
 using Microsoft.Win32;
 using osu.Desktop.Performance;
 using osu.Desktop.Security;
@@ -95,42 +95,20 @@ public OsuGameDesktop(string[]? args = null)
                 return key?.OpenSubKey(WindowsAssociationManager.SHELL_OPEN_COMMAND)?.GetValue(string.Empty)?.ToString()?.Split('"')[1].Replace("osu!.exe", "");
         }
 
+        public static bool IsPackageManaged => !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("OSU_EXTERNAL_UPDATE_PROVIDER"));
+
         protected override UpdateManager CreateUpdateManager()
         {
-            string? packageManaged = Environment.GetEnvironmentVariable("OSU_EXTERNAL_UPDATE_PROVIDER");
-
-            if (!string.IsNullOrEmpty(packageManaged))
+            if (IsPackageManaged)
                 return new NoActionUpdateManager();
 
-            switch (RuntimeInfo.OS)
-            {
-                case RuntimeInfo.Platform.Windows:
-                    Debug.Assert(OperatingSystem.IsWindows());
-
-                    return new SquirrelUpdateManager();
-
-                default:
-                    return new SimpleUpdateManager();
-            }
+            return new VelopackUpdateManager();
         }
 
         public override bool RestartAppWhenExited()
         {
-            switch (RuntimeInfo.OS)
-            {
-                case RuntimeInfo.Platform.Windows:
-                    Debug.Assert(OperatingSystem.IsWindows());
-
-                    // Of note, this is an async method in squirrel that adds an arbitrary delay before returning
-                    // likely to ensure the external process is in a good state.
-                    //
-                    // We're not waiting on that here, but the outro playing before the actual exit should be enough
-                    // to cover this.
-                    Squirrel.UpdateManager.RestartAppWhenExited().FireAndForget();
-                    return true;
-            }
-
-            return base.RestartAppWhenExited();
+            Task.Run(() => Velopack.UpdateExe.Start()).FireAndForget();
+            return true;
         }
 
         protected override void LoadComplete()
diff --git a/osu.Desktop/Program.cs b/osu.Desktop/Program.cs
index 23e56cdce9c6..ebc7509af6ea 100644
--- a/osu.Desktop/Program.cs
+++ b/osu.Desktop/Program.cs
@@ -14,7 +14,7 @@
 using osu.Game.IPC;
 using osu.Game.Tournament;
 using SDL;
-using Squirrel;
+using Velopack;
 
 namespace osu.Desktop
 {
@@ -31,19 +31,11 @@ public static class Program
         [STAThread]
         public static void Main(string[] args)
         {
-            /*
-             * WARNING: DO NOT PLACE **ANY** CODE ABOVE THE FOLLOWING BLOCK!
-             *
-             * Logic handling Squirrel MUST run before EVERYTHING if you do not want to break it.
-             * To be more precise: Squirrel is internally using a rather... crude method to determine whether it is running under NUnit,
-             * namely by checking loaded assemblies:
-             * https://github.com/clowd/Clowd.Squirrel/blob/24427217482deeeb9f2cacac555525edfc7bd9ac/src/Squirrel/SimpleSplat/PlatformModeDetector.cs#L17-L32
-             *
-             * If it finds ANY assembly from the ones listed above - REGARDLESS of the reason why it is loaded -
-             * the app will then do completely broken things like:
-             * - not creating system shortcuts (as the logic is if'd out if "running tests")
-             * - not exiting after the install / first-update / uninstall hooks are ran (as the `Environment.Exit()` calls are if'd out if "running tests")
-             */
+            // IMPORTANT DON'T IGNORE: For general sanity, velopack's setup needs to run before anything else.
+            // This has bitten us in the rear before (bricked updater), and although the underlying issue from
+            // last time has been fixed, let's not tempt fate.
+            setupVelopack();
+
             if (OperatingSystem.IsWindows())
             {
                 var windowsVersion = Environment.OSVersion.Version;
@@ -66,8 +58,6 @@ public static void Main(string[] args)
                         return;
                     }
                 }
-
-                setupSquirrel();
             }
 
             // NVIDIA profiles are based on the executable name of a process.
@@ -177,32 +167,28 @@ private static bool trySendIPCMessage(IIpcHost host, string cwd, string[] args)
             return false;
         }
 
-        [SupportedOSPlatform("windows")]
-        private static void setupSquirrel()
+        private static void setupVelopack()
         {
-            SquirrelAwareApp.HandleEvents(onInitialInstall: (_, tools) =>
-            {
-                tools.CreateShortcutForThisExe();
-                tools.CreateUninstallerRegistryEntry();
-                WindowsAssociationManager.InstallAssociations();
-            }, onAppUpdate: (_, tools) =>
+            if (OsuGameDesktop.IsPackageManaged)
             {
-                tools.CreateUninstallerRegistryEntry();
-                WindowsAssociationManager.UpdateAssociations();
-            }, onAppUninstall: (_, tools) =>
-            {
-                tools.RemoveShortcutForThisExe();
-                tools.RemoveUninstallerRegistryEntry();
-                WindowsAssociationManager.UninstallAssociations();
-            }, onEveryRun: (_, _, _) =>
-            {
-                // While setting the `ProcessAppUserModelId` fixes duplicate icons/shortcuts on the taskbar, it currently
-                // causes the right-click context menu to function incorrectly.
-                //
-                // This may turn out to be non-required after an alternative solution is implemented.
-                // see https://github.com/clowd/Clowd.Squirrel/issues/24
-                // tools.SetProcessAppUserModelId();
-            });
+                Logger.Log("Updates are being managed by an external provider. Skipping Velopack setup.");
+                return;
+            }
+
+            var app = VelopackApp.Build();
+
+            if (OperatingSystem.IsWindows())
+                configureWindows(app);
+
+            app.Run();
+        }
+
+        [SupportedOSPlatform("windows")]
+        private static void configureWindows(VelopackApp app)
+        {
+            app.WithFirstRun(_ => WindowsAssociationManager.InstallAssociations());
+            app.WithAfterUpdateFastCallback(_ => WindowsAssociationManager.UpdateAssociations());
+            app.WithBeforeUninstallFastCallback(_ => WindowsAssociationManager.UninstallAssociations());
         }
     }
 }
diff --git a/osu.Desktop/Updater/SquirrelUpdateManager.cs b/osu.Desktop/Updater/SquirrelUpdateManager.cs
deleted file mode 100644
index dba157a6e951..000000000000
--- a/osu.Desktop/Updater/SquirrelUpdateManager.cs
+++ /dev/null
@@ -1,180 +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.Runtime.Versioning;
-using System.Threading.Tasks;
-using osu.Framework.Allocation;
-using osu.Framework.Logging;
-using osu.Game;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Notifications;
-using osu.Game.Screens.Play;
-using Squirrel.SimpleSplat;
-using Squirrel.Sources;
-using LogLevel = Squirrel.SimpleSplat.LogLevel;
-using UpdateManager = osu.Game.Updater.UpdateManager;
-
-namespace osu.Desktop.Updater
-{
-    [SupportedOSPlatform("windows")]
-    public partial class SquirrelUpdateManager : UpdateManager
-    {
-        private Squirrel.UpdateManager? updateManager;
-        private INotificationOverlay notificationOverlay = null!;
-
-        public Task PrepareUpdateAsync() => Squirrel.UpdateManager.RestartAppWhenExited();
-
-        private static readonly Logger logger = Logger.GetLogger("updater");
-
-        /// <summary>
-        /// Whether an update has been downloaded but not yet applied.
-        /// </summary>
-        private bool updatePending;
-
-        private readonly SquirrelLogger squirrelLogger = new SquirrelLogger();
-
-        [Resolved]
-        private OsuGameBase game { get; set; } = null!;
-
-        [Resolved]
-        private ILocalUserPlayInfo? localUserInfo { get; set; }
-
-        [BackgroundDependencyLoader]
-        private void load(INotificationOverlay notifications)
-        {
-            notificationOverlay = notifications;
-
-            SquirrelLocator.CurrentMutable.Register(() => squirrelLogger, typeof(ILogger));
-        }
-
-        protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync().ConfigureAwait(false);
-
-        private async Task<bool> checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification? notification = null)
-        {
-            // should we schedule a retry on completion of this check?
-            bool scheduleRecheck = true;
-
-            const string? github_token = null; // TODO: populate.
-
-            try
-            {
-                // Avoid any kind of update checking while gameplay is running.
-                if (localUserInfo?.IsPlaying.Value == true)
-                    return false;
-
-                updateManager ??= new Squirrel.UpdateManager(new GithubSource(@"https://github.com/ppy/osu", github_token, false), @"osulazer");
-
-                var info = await updateManager.CheckForUpdate(!useDeltaPatching).ConfigureAwait(false);
-
-                if (info.ReleasesToApply.Count == 0)
-                {
-                    if (updatePending)
-                    {
-                        // the user may have dismissed the completion notice, so show it again.
-                        notificationOverlay.Post(new UpdateApplicationCompleteNotification
-                        {
-                            Activated = () =>
-                            {
-                                restartToApplyUpdate();
-                                return true;
-                            },
-                        });
-                        return true;
-                    }
-
-                    // no updates available. bail and retry later.
-                    return false;
-                }
-
-                scheduleRecheck = false;
-
-                if (notification == null)
-                {
-                    notification = new UpdateProgressNotification
-                    {
-                        CompletionClickAction = restartToApplyUpdate,
-                    };
-
-                    Schedule(() => notificationOverlay.Post(notification));
-                }
-
-                notification.StartDownload();
-
-                try
-                {
-                    await updateManager.DownloadReleases(info.ReleasesToApply, p => notification.Progress = p / 100f).ConfigureAwait(false);
-
-                    notification.StartInstall();
-
-                    await updateManager.ApplyReleases(info, p => notification.Progress = p / 100f).ConfigureAwait(false);
-
-                    notification.State = ProgressNotificationState.Completed;
-                    updatePending = true;
-                }
-                catch (Exception e)
-                {
-                    if (useDeltaPatching)
-                    {
-                        logger.Add(@"delta patching failed; will attempt full download!");
-
-                        // could fail if deltas are unavailable for full update path (https://github.com/Squirrel/Squirrel.Windows/issues/959)
-                        // try again without deltas.
-                        await checkForUpdateAsync(false, notification).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        // In the case of an error, a separate notification will be displayed.
-                        notification.FailDownload();
-                        Logger.Error(e, @"update failed!");
-                    }
-                }
-            }
-            catch (Exception)
-            {
-                // we'll ignore this and retry later. can be triggered by no internet connection or thread abortion.
-                scheduleRecheck = true;
-            }
-            finally
-            {
-                if (scheduleRecheck)
-                {
-                    // check again in 30 minutes.
-                    Scheduler.AddDelayed(() => Task.Run(async () => await checkForUpdateAsync().ConfigureAwait(false)), 60000 * 30);
-                }
-            }
-
-            return true;
-        }
-
-        private bool restartToApplyUpdate()
-        {
-            PrepareUpdateAsync()
-                .ContinueWith(_ => Schedule(() => game.AttemptExit()));
-            return true;
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            updateManager?.Dispose();
-        }
-
-        private class SquirrelLogger : ILogger, IDisposable
-        {
-            public LogLevel Level { get; set; } = LogLevel.Info;
-
-            public void Write(string message, LogLevel logLevel)
-            {
-                if (logLevel < Level)
-                    return;
-
-                logger.Add(message);
-            }
-
-            public void Dispose()
-            {
-            }
-        }
-    }
-}
diff --git a/osu.Desktop/Updater/VelopackUpdateManager.cs b/osu.Desktop/Updater/VelopackUpdateManager.cs
new file mode 100644
index 000000000000..7a79284533cb
--- /dev/null
+++ b/osu.Desktop/Updater/VelopackUpdateManager.cs
@@ -0,0 +1,140 @@
+// 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.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Logging;
+using osu.Game;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
+using osu.Game.Screens.Play;
+using Velopack;
+using Velopack.Sources;
+
+namespace osu.Desktop.Updater
+{
+    public partial class VelopackUpdateManager : Game.Updater.UpdateManager
+    {
+        private readonly UpdateManager updateManager;
+        private INotificationOverlay notificationOverlay = null!;
+
+        [Resolved]
+        private OsuGameBase game { get; set; } = null!;
+
+        [Resolved]
+        private ILocalUserPlayInfo? localUserInfo { get; set; }
+
+        private UpdateInfo? pendingUpdate;
+
+        public VelopackUpdateManager()
+        {
+            updateManager = new UpdateManager(new GithubSource(@"https://github.com/ppy/osu", null, false), new UpdateOptions
+            {
+                AllowVersionDowngrade = true,
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(INotificationOverlay notifications)
+        {
+            notificationOverlay = notifications;
+        }
+
+        protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync().ConfigureAwait(false);
+
+        private async Task<bool> checkForUpdateAsync(UpdateProgressNotification? notification = null)
+        {
+            // whether to check again in 30 minutes. generally only if there's an error or no update was found (yet).
+            bool scheduleRecheck = false;
+
+            try
+            {
+                // Avoid any kind of update checking while gameplay is running.
+                if (localUserInfo?.IsPlaying.Value == true)
+                {
+                    scheduleRecheck = true;
+                    return false;
+                }
+
+                // 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;
+                }
+
+                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.
+                if (notification == null)
+                {
+                    notification = new UpdateProgressNotification
+                    {
+                        CompletionClickAction = () =>
+                        {
+                            Task.Run(restartToApplyUpdate);
+                            return true;
+                        },
+                    };
+
+                    Schedule(() => notificationOverlay.Post(notification));
+                }
+
+                notification.StartDownload();
+
+                try
+                {
+                    await updateManager.DownloadUpdatesAsync(pendingUpdate, p => notification.Progress = p / 100f).ConfigureAwait(false);
+
+                    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);
+                }
+            }
+
+            return true;
+        }
+
+        private async Task restartToApplyUpdate()
+        {
+            await updateManager.WaitExitThenApplyUpdatesAsync(pendingUpdate?.TargetFullRelease).ConfigureAwait(false);
+            Schedule(() => game.AttemptExit());
+        }
+    }
+}
diff --git a/osu.Desktop/Windows/Icons.cs b/osu.Desktop/Windows/Icons.cs
index 67915c101a05..9d37a21b49e8 100644
--- a/osu.Desktop/Windows/Icons.cs
+++ b/osu.Desktop/Windows/Icons.cs
@@ -13,5 +13,7 @@ public static class Icons
         private static readonly string icon_directory = Path.GetDirectoryName(typeof(Icons).Assembly.Location)!;
 
         public static string Lazer => Path.Join(icon_directory, "lazer.ico");
+
+        public static string Beatmap => Path.Join(icon_directory, "beatmap.ico");
     }
 }
diff --git a/osu.Desktop/Windows/WindowsAssociationManager.cs b/osu.Desktop/Windows/WindowsAssociationManager.cs
index b32c01433de9..c8066cabda99 100644
--- a/osu.Desktop/Windows/WindowsAssociationManager.cs
+++ b/osu.Desktop/Windows/WindowsAssociationManager.cs
@@ -40,10 +40,10 @@ public static class WindowsAssociationManager
 
         private static readonly FileAssociation[] file_associations =
         {
-            new FileAssociation(@".osz", WindowsAssociationManagerStrings.OsuBeatmap, Icons.Lazer),
-            new FileAssociation(@".olz", WindowsAssociationManagerStrings.OsuBeatmap, Icons.Lazer),
-            new FileAssociation(@".osr", WindowsAssociationManagerStrings.OsuReplay, Icons.Lazer),
-            new FileAssociation(@".osk", WindowsAssociationManagerStrings.OsuSkin, Icons.Lazer),
+            new FileAssociation(@".osz", WindowsAssociationManagerStrings.OsuBeatmap, Icons.Beatmap),
+            new FileAssociation(@".olz", WindowsAssociationManagerStrings.OsuBeatmap, Icons.Beatmap),
+            new FileAssociation(@".osr", WindowsAssociationManagerStrings.OsuReplay, Icons.Beatmap),
+            new FileAssociation(@".osk", WindowsAssociationManagerStrings.OsuSkin, Icons.Beatmap),
         };
 
         private static readonly UriAssociation[] uri_associations =
diff --git a/osu.Desktop/beatmap.ico b/osu.Desktop/beatmap.ico
new file mode 100644
index 000000000000..58ab198bc273
Binary files /dev/null and b/osu.Desktop/beatmap.ico differ
diff --git a/osu.Desktop/osu.Desktop.csproj b/osu.Desktop/osu.Desktop.csproj
index acb53835a31f..342b28f5efb9 100644
--- a/osu.Desktop/osu.Desktop.csproj
+++ b/osu.Desktop/osu.Desktop.csproj
@@ -5,6 +5,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Description>A free-to-win rhythm game. Rhythm is just a *click* away!</Description>
     <AssemblyName>osu!</AssemblyName>
+    <AssemblyTitle>osu!(lazer)</AssemblyTitle>
     <Title>osu!</Title>
     <Product>osu!(lazer)</Product>
     <ApplicationIcon>lazer.ico</ApplicationIcon>
@@ -23,9 +24,9 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Clowd.Squirrel" Version="2.11.1" />
     <PackageReference Include="System.IO.Packaging" Version="8.0.0" />
     <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
+    <PackageReference Include="Velopack" Version="0.0.630-g9c52e40" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />
diff --git a/osu.Game.Benchmarks/BenchmarkGeometryUtils.cs b/osu.Game.Benchmarks/BenchmarkGeometryUtils.cs
new file mode 100644
index 000000000000..2ab4d3369a3c
--- /dev/null
+++ b/osu.Game.Benchmarks/BenchmarkGeometryUtils.cs
@@ -0,0 +1,29 @@
+// 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 BenchmarkDotNet.Attributes;
+using osu.Framework.Utils;
+using osu.Game.Utils;
+using osuTK;
+
+namespace osu.Game.Benchmarks
+{
+    public class BenchmarkGeometryUtils : BenchmarkTest
+    {
+        [Params(100, 1000, 2000, 4000, 8000, 10000)]
+        public int N;
+
+        private Vector2[] points = null!;
+
+        public override void SetUp()
+        {
+            points = new Vector2[N];
+
+            for (int i = 0; i < points.Length; ++i)
+                points[i] = new Vector2(RNG.Next(512), RNG.Next(384));
+        }
+
+        [Benchmark]
+        public void MinimumEnclosingCircle() => GeometryUtils.MinimumEnclosingCircle(points);
+    }
+}
diff --git a/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs b/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
index aae759d934ec..0578010c256f 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
@@ -71,7 +71,7 @@ protected override void AddHitObject(DrawableHitObject hitObject)
             contentContainer.Playfield.HitObjectContainer.Add(hitObject);
         }
 
-        protected override SnapResult SnapForBlueprint(PlacementBlueprint blueprint)
+        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
         {
             var result = base.SnapForBlueprint(blueprint);
             result.Time = Math.Round(HitObjectContainer.TimeAtScreenSpacePosition(result.ScreenSpacePosition) / TIME_SNAP) * TIME_SNAP;
diff --git a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneBananaShowerPlacementBlueprint.cs b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneBananaShowerPlacementBlueprint.cs
index ed37ff4ef3bb..296d34d628e2 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneBananaShowerPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneBananaShowerPlacementBlueprint.cs
@@ -22,7 +22,7 @@ public partial class TestSceneBananaShowerPlacementBlueprint : CatchPlacementBlu
     {
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableBananaShower((BananaShower)hitObject);
 
-        protected override PlacementBlueprint CreateBlueprint() => new BananaShowerPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new BananaShowerPlacementBlueprint();
 
         protected override void AddHitObject(DrawableHitObject hitObject)
         {
diff --git a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneFruitPlacementBlueprint.cs b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneFruitPlacementBlueprint.cs
index 75d3c3753a93..80cd948e265a 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneFruitPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneFruitPlacementBlueprint.cs
@@ -19,7 +19,7 @@ public partial class TestSceneFruitPlacementBlueprint : CatchPlacementBlueprintT
     {
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableFruit((Fruit)hitObject);
 
-        protected override PlacementBlueprint CreateBlueprint() => new FruitPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new FruitPlacementBlueprint();
 
         [Test]
         public void TestFruitPlacementPosition()
diff --git a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
index d010bb02adcf..8bd60078c62f 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
@@ -114,7 +114,7 @@ public void TestMoveBeforeFirstVertex()
 
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableJuiceStream((JuiceStream)hitObject);
 
-        protected override PlacementBlueprint CreateBlueprint() => new JuiceStreamPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new JuiceStreamPlacementBlueprint();
 
         private void addMoveAndClickSteps(double time, float position, bool end = false)
         {
diff --git a/osu.Game.Rulesets.Catch.Tests/TestSceneCatchPlayerLegacySkin.cs b/osu.Game.Rulesets.Catch.Tests/TestSceneCatchPlayerLegacySkin.cs
index 7812e02a6363..792caf6de69e 100644
--- a/osu.Game.Rulesets.Catch.Tests/TestSceneCatchPlayerLegacySkin.cs
+++ b/osu.Game.Rulesets.Catch.Tests/TestSceneCatchPlayerLegacySkin.cs
@@ -23,7 +23,7 @@ public void TestLegacyHUDComboCounterNotExistent([Values] bool withModifiedSkin)
             if (withModifiedSkin)
             {
                 AddStep("change component scale", () => Player.ChildrenOfType<LegacyScoreCounter>().First().Scale = new Vector2(2f));
-                AddStep("update target", () => Player.ChildrenOfType<SkinComponentsContainer>().ForEach(LegacySkin.UpdateDrawableTarget));
+                AddStep("update target", () => Player.ChildrenOfType<SkinnableContainer>().ForEach(LegacySkin.UpdateDrawableTarget));
                 AddStep("exit player", () => Player.Exit());
                 CreateTest();
             }
diff --git a/osu.Game.Rulesets.Catch/CatchRuleset.cs b/osu.Game.Rulesets.Catch/CatchRuleset.cs
index 3edc23a8b750..7eaf4f2b1869 100644
--- a/osu.Game.Rulesets.Catch/CatchRuleset.cs
+++ b/osu.Game.Rulesets.Catch/CatchRuleset.cs
@@ -254,5 +254,7 @@ public override BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDiffi
 
             return adjustedDifficulty;
         }
+
+        public override bool EditorShowScrollSpeed => false;
     }
 }
diff --git a/osu.Game.Rulesets.Catch/CatchSkinComponentLookup.cs b/osu.Game.Rulesets.Catch/CatchSkinComponentLookup.cs
index 596b102ac575..7f91d2990b5c 100644
--- a/osu.Game.Rulesets.Catch/CatchSkinComponentLookup.cs
+++ b/osu.Game.Rulesets.Catch/CatchSkinComponentLookup.cs
@@ -5,7 +5,7 @@
 
 namespace osu.Game.Rulesets.Catch
 {
-    public class CatchSkinComponentLookup : GameplaySkinComponentLookup<CatchSkinComponents>
+    public class CatchSkinComponentLookup : SkinComponentLookup<CatchSkinComponents>
     {
         public CatchSkinComponentLookup(CatchSkinComponents component)
             : base(component)
diff --git a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
index f12c41a4152a..7d21409ee8c7 100644
--- a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
@@ -20,7 +19,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 {
     public class CatchDifficultyCalculator : DifficultyCalculator
     {
-        private const double star_scaling_factor = 0.153;
+        private const double difficulty_multiplier = 4.59;
 
         private float halfCatcherWidth;
 
@@ -41,10 +40,10 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
 
             CatchDifficultyAttributes attributes = new CatchDifficultyAttributes
             {
-                StarRating = Math.Sqrt(skills[0].DifficultyValue()) * star_scaling_factor,
+                StarRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier,
                 Mods = mods,
                 ApproachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0,
-                MaxCombo = beatmap.HitObjects.Count(h => h is Fruit) + beatmap.HitObjects.OfType<JuiceStream>().SelectMany(j => j.NestedHitObjects).Count(h => !(h is TinyDroplet)),
+                MaxCombo = beatmap.GetMaxCombo(),
             };
 
             return attributes;
diff --git a/osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs b/osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs
index cfb3fe40bee7..54b85f1745c3 100644
--- a/osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs
@@ -15,7 +15,7 @@ public class Movement : StrainDecaySkill
         private const float normalized_hitobject_radius = 41.0f;
         private const double direction_change_bonus = 21.0;
 
-        protected override double SkillMultiplier => 900;
+        protected override double SkillMultiplier => 1;
         protected override double StrainDecayBase => 0.2;
 
         protected override double DecayWeight => 0.94;
diff --git a/osu.Game.Rulesets.Catch/Edit/BananaShowerCompositionTool.cs b/osu.Game.Rulesets.Catch/Edit/BananaShowerCompositionTool.cs
index 31075db7d1d1..be93ba0242ed 100644
--- a/osu.Game.Rulesets.Catch/Edit/BananaShowerCompositionTool.cs
+++ b/osu.Game.Rulesets.Catch/Edit/BananaShowerCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public class BananaShowerCompositionTool : HitObjectCompositionTool
+    public class BananaShowerCompositionTool : CompositionTool
     {
         public BananaShowerCompositionTool()
             : base(nameof(BananaShower))
@@ -19,6 +19,6 @@ public BananaShowerCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new BananaShowerPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new BananaShowerPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs b/osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs
index 1a2990e4acff..aa862375c526 100644
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs
@@ -9,7 +9,7 @@
 
 namespace osu.Game.Rulesets.Catch.Edit.Blueprints
 {
-    public partial class CatchPlacementBlueprint<THitObject> : PlacementBlueprint
+    public partial class CatchPlacementBlueprint<THitObject> : HitObjectPlacementBlueprint
         where THitObject : CatchHitObject, new()
     {
         protected new THitObject HitObject => (THitObject)base.HitObject;
diff --git a/osu.Game.Rulesets.Catch/Edit/CatchDistanceSnapProvider.cs b/osu.Game.Rulesets.Catch/Edit/CatchDistanceSnapProvider.cs
index c3103bd2043c..6f5b32a41d51 100644
--- a/osu.Game.Rulesets.Catch/Edit/CatchDistanceSnapProvider.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchDistanceSnapProvider.cs
@@ -18,7 +18,9 @@ protected override double ReadCurrentDistanceSnap(HitObject before, HitObject af
             // The implementation below is probably correct but should be checked if/when exposed via controls.
 
             float expectedDistance = DurationToDistance(before, after.StartTime - before.GetEndTime());
-            float actualDistance = Math.Abs(((CatchHitObject)before).EffectiveX - ((CatchHitObject)after).EffectiveX);
+
+            float previousEndX = (before as JuiceStream)?.EndX ?? ((CatchHitObject)before).EffectiveX;
+            float actualDistance = Math.Abs(previousEndX - ((CatchHitObject)after).EffectiveX);
 
             return actualDistance / expectedDistance;
         }
diff --git a/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs b/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
index 83f48816f965..09d1ff663d51 100644
--- a/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
@@ -84,7 +84,7 @@ protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset
 
         protected override BeatSnapGrid CreateBeatSnapGrid() => new CatchBeatSnapGrid();
 
-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
+        protected override IReadOnlyList<CompositionTool> CompositionTools => new CompositionTool[]
         {
             new FruitCompositionTool(),
             new JuiceStreamCompositionTool(),
@@ -114,6 +114,26 @@ public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
         {
         }
 
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.Repeat)
+                return false;
+
+            handleToggleViaKey(e);
+            return base.OnKeyDown(e);
+        }
+
+        protected override void OnKeyUp(KeyUpEvent e)
+        {
+            handleToggleViaKey(e);
+            base.OnKeyUp(e);
+        }
+
+        private void handleToggleViaKey(KeyboardEvent key)
+        {
+            DistanceSnapProvider.HandleToggleViaKey(key);
+        }
+
         public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
         {
             var result = base.FindSnappedPositionAndTime(screenSpacePosition, snapType);
diff --git a/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs b/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs
index f776fe39c1c7..71c1e6690320 100644
--- a/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs
+++ b/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public class FruitCompositionTool : HitObjectCompositionTool
+    public class FruitCompositionTool : CompositionTool
     {
         public FruitCompositionTool()
             : base(nameof(Fruit))
@@ -19,6 +19,6 @@ public FruitCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new FruitPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new FruitPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Catch/Edit/JuiceStreamCompositionTool.cs b/osu.Game.Rulesets.Catch/Edit/JuiceStreamCompositionTool.cs
index cb66e2952e87..7a567820f370 100644
--- a/osu.Game.Rulesets.Catch/Edit/JuiceStreamCompositionTool.cs
+++ b/osu.Game.Rulesets.Catch/Edit/JuiceStreamCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public class JuiceStreamCompositionTool : HitObjectCompositionTool
+    public class JuiceStreamCompositionTool : CompositionTool
     {
         public JuiceStreamCompositionTool()
             : base(nameof(JuiceStream))
@@ -19,6 +19,6 @@ public JuiceStreamCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new JuiceStreamPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new JuiceStreamPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableBanana.cs b/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableBanana.cs
index 26e304cf3fd8..10e483b57749 100644
--- a/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableBanana.cs
+++ b/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableBanana.cs
@@ -1,10 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
+using osu.Framework.Utils;
 using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Skinning;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawables
 {
@@ -36,23 +38,43 @@ protected override void LoadComplete()
             StartTimeBindable.BindValueChanged(_ => UpdateComboColour());
         }
 
+        private float startScale;
+        private float endScale;
+
+        private float startAngle;
+        private float endAngle;
+
         protected override void UpdateInitialTransforms()
         {
             base.UpdateInitialTransforms();
 
+            // Important to have this in UpdateInitialTransforms() to it is re-triggered by RefreshStateTransforms().
             const float end_scale = 0.6f;
             const float random_scale_range = 1.6f;
 
-            ScalingContainer.ScaleTo(HitObject.Scale * (end_scale + random_scale_range * RandomSingle(3)))
-                            .Then().ScaleTo(HitObject.Scale * end_scale, HitObject.TimePreempt);
+            startScale = end_scale + random_scale_range * RandomSingle(3);
+            endScale = end_scale;
 
-            ScalingContainer.RotateTo(getRandomAngle(1))
-                            .Then()
-                            .RotateTo(getRandomAngle(2), HitObject.TimePreempt);
+            startAngle = getRandomAngle(1);
+            endAngle = getRandomAngle(2);
 
             float getRandomAngle(int series) => 180 * (RandomSingle(series) * 2 - 1);
         }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            double preemptProgress = (Time.Current - (HitObject.StartTime - InitialLifetimeOffset)) / HitObject.TimePreempt;
+
+            // Clamp scale and rotation at the point of bananas being caught, else let them freely extrapolate.
+            if (Result.IsHit)
+                preemptProgress = Math.Min(1, preemptProgress);
+
+            ScalingContainer.Scale = new Vector2(HitObject.Scale * (float)Interpolation.Lerp(startScale, endScale, preemptProgress));
+            ScalingContainer.Rotation = (float)Interpolation.Lerp(startAngle, endAngle, preemptProgress);
+        }
+
         public override void PlaySamples()
         {
             base.PlaySamples();
diff --git a/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableDroplet.cs b/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableDroplet.cs
index 8f32cdcc317c..fadd6301163c 100644
--- a/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableDroplet.cs
+++ b/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableDroplet.cs
@@ -2,7 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
+using osu.Framework.Utils;
 using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Skinning;
 
@@ -28,15 +28,24 @@ private void load()
                 _ => new DropletPiece());
         }
 
+        private float startRotation;
+
         protected override void UpdateInitialTransforms()
         {
             base.UpdateInitialTransforms();
 
-            // roughly matches osu-stable
-            float startRotation = RandomSingle(1) * 20;
-            double duration = HitObject.TimePreempt + 2000;
+            // Important to have this in UpdateInitialTransforms() to it is re-triggered by RefreshStateTransforms().
+            startRotation = RandomSingle(1) * 20;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
 
-            ScalingContainer.RotateTo(startRotation).RotateTo(startRotation + 720, duration);
+            // No clamping for droplets. They should be considered indefinitely spinning regardless of time.
+            // They also never end up on the plate, so they shouldn't stop spinning when caught.
+            double preemptProgress = (Time.Current - (HitObject.StartTime - InitialLifetimeOffset)) / (HitObject.TimePreempt + 2000);
+            ScalingContainer.Rotation = (float)Interpolation.Lerp(startRotation, startRotation + 720, preemptProgress);
         }
     }
 }
diff --git a/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableFruit.cs b/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableFruit.cs
index 52c53523e618..877fae9d670d 100644
--- a/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableFruit.cs
+++ b/osu.Game.Rulesets.Catch/Objects/Drawables/DrawableFruit.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Skinning.Default;
 using osu.Game.Skinning;
 
@@ -32,7 +31,8 @@ protected override void UpdateInitialTransforms()
         {
             base.UpdateInitialTransforms();
 
-            ScalingContainer.RotateTo((RandomSingle(1) - 0.5f) * 40);
+            // Important to have this in UpdateInitialTransforms() to it is re-triggered by RefreshStateTransforms().
+            ScalingContainer.Rotation = (RandomSingle(1) - 0.5f) * 40;
         }
     }
 }
diff --git a/osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs b/osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs
index 7c84cb24f39d..7c62f9692f99 100644
--- a/osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs
+++ b/osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs
@@ -16,9 +16,12 @@ internal class CatchAutoGenerator : AutoGenerator<CatchReplayFrame>
     {
         public new CatchBeatmap Beatmap => (CatchBeatmap)base.Beatmap;
 
+        private readonly float halfCatcherWidth;
+
         public CatchAutoGenerator(IBeatmap beatmap)
             : base(beatmap)
         {
+            halfCatcherWidth = Catcher.CalculateCatchWidth(beatmap.Difficulty) * 0.5f;
         }
 
         protected override void GenerateFrames()
@@ -47,10 +50,7 @@ void moveToNext(PalpableCatchHitObject h)
                 bool dashRequired = speedRequired > Catcher.BASE_WALK_SPEED;
                 bool impossibleJump = speedRequired > Catcher.BASE_DASH_SPEED;
 
-                // todo: get correct catcher size, based on difficulty CS.
-                const float catcher_width_half = Catcher.BASE_SIZE * 0.3f * 0.5f;
-
-                if (lastPosition - catcher_width_half < h.EffectiveX && lastPosition + catcher_width_half > h.EffectiveX)
+                if (lastPosition - halfCatcherWidth < h.EffectiveX && lastPosition + halfCatcherWidth > h.EffectiveX)
                 {
                     // we are already in the correct range.
                     lastTime = h.StartTime;
diff --git a/osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs b/osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs
index 81279456d57a..69efb7fbca84 100644
--- a/osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs
+++ b/osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs
@@ -30,23 +30,19 @@ public CatchLegacySkinTransformer(ISkin skin)
         {
             switch (lookup)
             {
-                case SkinComponentsContainerLookup containerLookup:
+                case GlobalSkinnableContainerLookup containerLookup:
                     // Only handle per ruleset defaults here.
                     if (containerLookup.Ruleset == null)
                         return base.GetDrawableComponent(lookup);
 
-                    // Skin has configuration.
-                    if (base.GetDrawableComponent(lookup) is UserConfiguredLayoutContainer d)
-                        return d;
-
                     // we don't have enough assets to display these components (this is especially the case on a "beatmap" skin).
                     if (!IsProvidingLegacyResources)
                         return null;
 
                     // Our own ruleset components default.
-                    switch (containerLookup.Target)
+                    switch (containerLookup.Lookup)
                     {
-                        case SkinComponentsContainerLookup.TargetArea.MainHUDComponents:
+                        case GlobalSkinnableContainers.MainHUDComponents:
                             // todo: remove CatchSkinComponents.CatchComboCounter and refactor LegacyCatchComboCounter to be added here instead.
                             return new DefaultSkinComponentsContainer(container =>
                             {
@@ -56,10 +52,8 @@ public CatchLegacySkinTransformer(ISkin skin)
                                 {
                                     // set the anchor to top right so that it won't squash to the return button to the top
                                     keyCounter.Anchor = Anchor.CentreRight;
-                                    keyCounter.Origin = Anchor.CentreRight;
-                                    keyCounter.X = 0;
-                                    // 340px is the default height inherit from stable
-                                    keyCounter.Y = container.ToLocalSpace(new Vector2(0, container.ScreenSpaceDrawQuad.Centre.Y - 340f)).Y;
+                                    keyCounter.Origin = Anchor.TopRight;
+                                    keyCounter.Position = new Vector2(0, -40) * 1.6f;
                                 }
                             })
                             {
diff --git a/osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchHitObjectPiece.cs b/osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchHitObjectPiece.cs
index 2184ecc3637d..15b168b8c2d2 100644
--- a/osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchHitObjectPiece.cs
+++ b/osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchHitObjectPiece.cs
@@ -85,9 +85,25 @@ protected override void LoadComplete()
 
         protected void SetTexture(Texture? texture, Texture? overlayTexture)
         {
-            colouredSprite.Texture = texture;
-            overlaySprite.Texture = overlayTexture;
-            hyperSprite.Texture = texture;
+            // Sizes are reset due to an arguable osu!framework bug where Sprite retains the size of the first set texture.
+
+            if (colouredSprite.Texture != texture)
+            {
+                colouredSprite.Size = Vector2.Zero;
+                colouredSprite.Texture = texture;
+            }
+
+            if (overlaySprite.Texture != overlayTexture)
+            {
+                overlaySprite.Size = Vector2.Zero;
+                overlaySprite.Texture = overlayTexture;
+            }
+
+            if (hyperSprite.Texture != texture)
+            {
+                hyperSprite.Size = Vector2.Zero;
+                hyperSprite.Texture = texture;
+            }
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs b/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
index d2a44122aa38..5e633c3161a6 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
@@ -47,7 +47,7 @@ protected ManiaPlacementBlueprintTestScene()
             });
         }
 
-        protected override SnapResult SnapForBlueprint(PlacementBlueprint blueprint)
+        protected override SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint)
         {
             double time = column.TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
             var pos = column.ScreenSpacePositionAtTime(time);
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNotePlacementBlueprint.cs b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNotePlacementBlueprint.cs
index b79bcb7682de..2006879ab386 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNotePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNotePlacementBlueprint.cs
@@ -13,6 +13,6 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
     public partial class TestSceneHoldNotePlacementBlueprint : ManiaPlacementBlueprintTestScene
     {
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableHoldNote((HoldNote)hitObject);
-        protected override PlacementBlueprint CreateBlueprint() => new HoldNotePlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new HoldNotePlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs
index b48f579ec0b6..4285ef202951 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs
@@ -6,6 +6,7 @@
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Visual;
@@ -92,5 +93,30 @@ public void TestVerticalFlip()
             AddAssert("second object flipped", () => second.StartTime, () => Is.EqualTo(250));
             AddAssert("third object flipped", () => third.StartTime, () => Is.EqualTo(1250));
         }
+
+        [Test]
+        public void TestOffScreenObjectsRemainSelectedOnColumnChange()
+        {
+            AddStep("create objects", () =>
+            {
+                for (int i = 0; i < 20; ++i)
+                    EditorBeatmap.Add(new Note { StartTime = 1000 * i, Column = 0 });
+            });
+
+            AddStep("select everything", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
+            AddStep("start drag", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<Column>().First());
+                InputManager.PressButton(MouseButton.Left);
+            });
+            AddStep("end drag", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<Column>().Last());
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("all objects in last column", () => EditorBeatmap.HitObjects.All(ho => ((ManiaHitObject)ho).Column == 3));
+            AddAssert("all objects remain selected", () => EditorBeatmap.SelectedHitObjects.SequenceEqual(EditorBeatmap.HitObjects));
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs
index a446f13cbf79..0cb9639cd177 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs
@@ -64,6 +64,6 @@ public void TestPlaceAfterCurrentTimeDownwards()
         private Note getNote() => this.ChildrenOfType<DrawableNote>().FirstOrDefault()?.HitObject;
 
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableNote((Note)hitObject);
-        protected override PlacementBlueprint CreateBlueprint() => new NotePlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new NotePlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Mania.Tests/Skinning/ManiaSkinnableTestScene.cs b/osu.Game.Rulesets.Mania.Tests/Skinning/ManiaSkinnableTestScene.cs
index abf01aa4a4ee..b2e8ebd5812d 100644
--- a/osu.Game.Rulesets.Mania.Tests/Skinning/ManiaSkinnableTestScene.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Skinning/ManiaSkinnableTestScene.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
     public abstract partial class ManiaSkinnableTestScene : SkinnableTestScene
     {
         [Cached(Type = typeof(IScrollingInfo))]
-        private readonly TestScrollingInfo scrollingInfo = new TestScrollingInfo();
+        protected readonly TestScrollingInfo ScrollingInfo = new TestScrollingInfo();
 
         [Cached]
         private readonly StageDefinition stage = new StageDefinition(4);
@@ -30,7 +30,7 @@ public abstract partial class ManiaSkinnableTestScene : SkinnableTestScene
 
         protected ManiaSkinnableTestScene()
         {
-            scrollingInfo.Direction.Value = ScrollingDirection.Down;
+            ScrollingInfo.Direction.Value = ScrollingDirection.Down;
 
             Add(new Box
             {
@@ -43,16 +43,16 @@ protected ManiaSkinnableTestScene()
         [Test]
         public void TestScrollingDown()
         {
-            AddStep("change direction to down", () => scrollingInfo.Direction.Value = ScrollingDirection.Down);
+            AddStep("change direction to down", () => ScrollingInfo.Direction.Value = ScrollingDirection.Down);
         }
 
         [Test]
         public void TestScrollingUp()
         {
-            AddStep("change direction to up", () => scrollingInfo.Direction.Value = ScrollingDirection.Up);
+            AddStep("change direction to up", () => ScrollingInfo.Direction.Value = ScrollingDirection.Up);
         }
 
-        private class TestScrollingInfo : IScrollingInfo
+        protected class TestScrollingInfo : IScrollingInfo
         {
             public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
diff --git a/osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneComboCounter.cs b/osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneComboCounter.cs
index c1e1cfd7aff7..ccdebb502c5d 100644
--- a/osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneComboCounter.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneComboCounter.cs
@@ -1,13 +1,17 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Skinning.Argon;
 using osu.Game.Rulesets.Mania.Skinning.Legacy;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Mania.Tests.Skinning
@@ -17,22 +21,75 @@ public partial class TestSceneComboCounter : ManiaSkinnableTestScene
         [Cached]
         private ScoreProcessor scoreProcessor = new ScoreProcessor(new ManiaRuleset());
 
-        [SetUpSteps]
-        public void SetUpSteps()
+        [Test]
+        public void TestDisplay()
         {
-            AddStep("setup", () => SetContents(s =>
+            setup(Anchor.Centre);
+            AddRepeatStep("perform hit", () => scoreProcessor.ApplyResult(new JudgementResult(new HitObject(), new Judgement()) { Type = HitResult.Great }), 20);
+            AddStep("perform miss", () => scoreProcessor.ApplyResult(new JudgementResult(new HitObject(), new Judgement()) { Type = HitResult.Miss }));
+        }
+
+        [Test]
+        public void TestAnchorOrigin()
+        {
+            AddStep("set direction down", () => ScrollingInfo.Direction.Value = ScrollingDirection.Down);
+            setup(Anchor.TopCentre, 20);
+            AddStep("set direction up", () => ScrollingInfo.Direction.Value = ScrollingDirection.Up);
+            check(Anchor.BottomCentre, -20);
+
+            AddStep("set direction up", () => ScrollingInfo.Direction.Value = ScrollingDirection.Up);
+            setup(Anchor.BottomCentre, -20);
+            AddStep("set direction down", () => ScrollingInfo.Direction.Value = ScrollingDirection.Down);
+            check(Anchor.TopCentre, 20);
+
+            AddStep("set direction down", () => ScrollingInfo.Direction.Value = ScrollingDirection.Down);
+            setup(Anchor.Centre, 20);
+            AddStep("set direction up", () => ScrollingInfo.Direction.Value = ScrollingDirection.Up);
+            check(Anchor.Centre, 20);
+
+            AddStep("set direction up", () => ScrollingInfo.Direction.Value = ScrollingDirection.Up);
+            setup(Anchor.Centre, -20);
+            AddStep("set direction down", () => ScrollingInfo.Direction.Value = ScrollingDirection.Down);
+            check(Anchor.Centre, -20);
+        }
+
+        private void setup(Anchor anchor, float y = 0)
+        {
+            AddStep($"setup {anchor} {y}", () => SetContents(s =>
             {
+                var container = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                };
+
                 if (s is ArgonSkin)
-                    return new ArgonManiaComboCounter();
+                    container.Add(new ArgonManiaComboCounter());
+                else if (s is LegacySkin)
+                    container.Add(new LegacyManiaComboCounter());
+                else
+                    container.Add(new LegacyManiaComboCounter());
 
-                if (s is LegacySkin)
-                    return new LegacyManiaComboCounter();
+                container.Child.Anchor = anchor;
+                container.Child.Origin = Anchor.Centre;
+                container.Child.Y = y;
 
-                return new LegacyManiaComboCounter();
+                return container;
             }));
+        }
 
-            AddRepeatStep("perform hit", () => scoreProcessor.ApplyResult(new JudgementResult(new HitObject(), new Judgement()) { Type = HitResult.Great }), 20);
-            AddStep("perform miss", () => scoreProcessor.ApplyResult(new JudgementResult(new HitObject(), new Judgement()) { Type = HitResult.Miss }));
+        private void check(Anchor anchor, float y)
+        {
+            AddAssert($"check {anchor} {y}", () =>
+            {
+                foreach (var combo in this.ChildrenOfType<ISerialisableDrawable>())
+                {
+                    var drawableCombo = (Drawable)combo;
+                    if (drawableCombo.Anchor != anchor || drawableCombo.Y != y)
+                        return false;
+                }
+
+                return true;
+            });
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
index 39ee3d209bd1..970d68759f33 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
@@ -6,7 +6,6 @@
 using System.Linq;
 using System.Collections.Generic;
 using System.Threading;
-using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -271,7 +270,7 @@ private Pattern generate()
                         Duration = endTimeData.Duration,
                         Column = column,
                         Samples = HitObject.Samples,
-                        NodeSamples = (HitObject as IHasRepeats)?.NodeSamples ?? defaultNodeSamples
+                        NodeSamples = (HitObject as IHasRepeats)?.NodeSamples ?? HoldNote.CreateDefaultNodeSamples(HitObject)
                     });
                 }
                 else if (HitObject is IHasXPosition)
@@ -286,16 +285,6 @@ private Pattern generate()
 
                 return pattern;
             }
-
-            /// <remarks>
-            /// osu!mania-specific beatmaps in stable only play samples at the start of the hold note.
-            /// </remarks>
-            private List<IList<HitSampleInfo>> defaultNodeSamples
-                => new List<IList<HitSampleInfo>>
-                {
-                    HitObject.Samples,
-                    new List<HitSampleInfo>()
-                };
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs b/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
index 4190e74e5174..efe27e8d6bda 100644
--- a/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 {
     public class ManiaDifficultyCalculator : DifficultyCalculator
     {
-        private const double star_scaling_factor = 0.018;
+        private const double difficulty_multiplier = 0.018;
 
         private readonly bool isForCurrentRuleset;
         private readonly double originalOverallDifficulty;
@@ -48,7 +48,7 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
 
             ManiaDifficultyAttributes attributes = new ManiaDifficultyAttributes
             {
-                StarRating = skills[0].DifficultyValue() * star_scaling_factor,
+                StarRating = skills[0].DifficultyValue() * difficulty_multiplier,
                 Mods = mods,
                 // In osu-stable mania, rate-adjustment mods don't affect the hit window.
                 // This is done the way it is to introduce fractional differences in order to match osu-stable for the time being.
diff --git a/osu.Game.Rulesets.Mania/Difficulty/ManiaPerformanceCalculator.cs b/osu.Game.Rulesets.Mania/Difficulty/ManiaPerformanceCalculator.cs
index d9f947924702..778d569cf259 100644
--- a/osu.Game.Rulesets.Mania/Difficulty/ManiaPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Mania/Difficulty/ManiaPerformanceCalculator.cs
@@ -38,9 +38,7 @@ protected override PerformanceAttributes CreatePerformanceAttributes(ScoreInfo s
             countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
             scoreAccuracy = calculateCustomAccuracy();
 
-            // Arbitrary initial value for scaling pp in order to standardize distributions across game modes.
-            // The specific number has no intrinsic meaning and can be adjusted as needed.
-            double multiplier = 8.0;
+            double multiplier = 1.0;
 
             if (score.Mods.Any(m => m is ModNoFail))
                 multiplier *= 0.75;
@@ -59,9 +57,9 @@ protected override PerformanceAttributes CreatePerformanceAttributes(ScoreInfo s
 
         private double computeDifficultyValue(ManiaDifficultyAttributes attributes)
         {
-            double difficultyValue = Math.Pow(Math.Max(attributes.StarRating - 0.15, 0.05), 2.2) // Star rating to pp curve
-                                     * Math.Max(0, 5 * scoreAccuracy - 4) // From 80% accuracy, 1/20th of total pp is awarded per additional 1% accuracy
-                                     * (1 + 0.1 * Math.Min(1, totalHits / 1500)); // Length bonus, capped at 1500 notes
+            double difficultyValue = 8.0 * Math.Pow(Math.Max(attributes.StarRating - 0.15, 0.05), 2.2) // Star rating to pp curve
+                                         * Math.Max(0, 5 * scoreAccuracy - 4) // From 80% accuracy, 1/20th of total pp is awarded per additional 1% accuracy
+                                         * (1 + 0.1 * Math.Min(1, totalHits / 1500)); // Length bonus, capped at 1500 notes
 
             return difficultyValue;
         }
diff --git a/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs b/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs
index 5e0512b5dcb8..a68bd5d6d68a 100644
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs
@@ -15,7 +15,7 @@
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
-    public abstract partial class ManiaPlacementBlueprint<T> : PlacementBlueprint
+    public abstract partial class ManiaPlacementBlueprint<T> : HitObjectPlacementBlueprint
         where T : ManiaHitObject
     {
         protected new T HitObject => (T)base.HitObject;
diff --git a/osu.Game.Rulesets.Mania/Edit/HoldNoteCompositionTool.cs b/osu.Game.Rulesets.Mania/Edit/HoldNoteCompositionTool.cs
index 99e1ce04b129..592f8d9af7c9 100644
--- a/osu.Game.Rulesets.Mania/Edit/HoldNoteCompositionTool.cs
+++ b/osu.Game.Rulesets.Mania/Edit/HoldNoteCompositionTool.cs
@@ -9,7 +9,7 @@
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public class HoldNoteCompositionTool : HitObjectCompositionTool
+    public class HoldNoteCompositionTool : CompositionTool
     {
         public HoldNoteCompositionTool()
             : base("Hold")
@@ -18,6 +18,6 @@ public HoldNoteCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new HoldNotePlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new HoldNotePlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs b/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
index 02a4f3a022f0..e3b4fa2fb7b3 100644
--- a/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
@@ -46,7 +46,7 @@ protected override ComposeBlueprintContainer CreateBlueprintContainer()
 
         protected override BeatSnapGrid CreateBeatSnapGrid() => new ManiaBeatSnapGrid();
 
-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
+        protected override IReadOnlyList<CompositionTool> CompositionTools => new CompositionTool[]
         {
             new NoteCompositionTool(),
             new HoldNoteCompositionTool()
diff --git a/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs b/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
index 9ae2112b304e..7e0991a4d4cb 100644
--- a/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
@@ -104,8 +104,10 @@ private void performColumnMovement(int lastColumn, MoveSelectionEvent<HitObject>
             int minColumn = int.MaxValue;
             int maxColumn = int.MinValue;
 
+            var selectedObjects = EditorBeatmap.SelectedHitObjects.OfType<ManiaHitObject>().ToArray();
+
             // find min/max in an initial pass before actually performing the movement.
-            foreach (var obj in EditorBeatmap.SelectedHitObjects.OfType<ManiaHitObject>())
+            foreach (var obj in selectedObjects)
             {
                 if (obj.Column < minColumn)
                     minColumn = obj.Column;
@@ -121,6 +123,13 @@ private void performColumnMovement(int lastColumn, MoveSelectionEvent<HitObject>
                 ((ManiaHitObject)h).Column += columnDelta;
                 maniaPlayfield.Add(h);
             });
+
+            // `HitObjectUsageEventBuffer`'s usage transferal flows and the playfield's `SetKeepAlive()` functionality do not combine well with this operation's usage pattern,
+            // leading to selections being sometimes partially dropped if some of the objects being moved are off screen
+            // (check blame for detailed explanation).
+            // thus, ensure that selection is preserved manually.
+            EditorBeatmap.SelectedHitObjects.Clear();
+            EditorBeatmap.SelectedHitObjects.AddRange(selectedObjects);
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Edit/NoteCompositionTool.cs b/osu.Game.Rulesets.Mania/Edit/NoteCompositionTool.cs
index 08ee05ad3f70..2e54d635251c 100644
--- a/osu.Game.Rulesets.Mania/Edit/NoteCompositionTool.cs
+++ b/osu.Game.Rulesets.Mania/Edit/NoteCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public class NoteCompositionTool : HitObjectCompositionTool
+    public class NoteCompositionTool : CompositionTool
     {
         public NoteCompositionTool()
             : base(nameof(Note))
@@ -19,6 +19,6 @@ public NoteCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new NotePlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new NotePlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/ManiaSkinComponentLookup.cs b/osu.Game.Rulesets.Mania/ManiaSkinComponentLookup.cs
index 046d1c5b3490..f3613eff992f 100644
--- a/osu.Game.Rulesets.Mania/ManiaSkinComponentLookup.cs
+++ b/osu.Game.Rulesets.Mania/ManiaSkinComponentLookup.cs
@@ -5,7 +5,7 @@
 
 namespace osu.Game.Rulesets.Mania
 {
-    public class ManiaSkinComponentLookup : GameplaySkinComponentLookup<ManiaSkinComponents>
+    public class ManiaSkinComponentLookup : SkinComponentLookup<ManiaSkinComponents>
     {
         /// <summary>
         /// Creates a new <see cref="ManiaSkinComponentLookup"/>.
diff --git a/osu.Game.Rulesets.Mania/Objects/HoldNote.cs b/osu.Game.Rulesets.Mania/Objects/HoldNote.cs
index 6be0ee2d6be3..98060dd226c0 100644
--- a/osu.Game.Rulesets.Mania/Objects/HoldNote.cs
+++ b/osu.Game.Rulesets.Mania/Objects/HoldNote.cs
@@ -7,6 +7,7 @@
 using System.Threading;
 using osu.Game.Audio;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 
@@ -91,6 +92,10 @@ protected override void CreateNestedHitObjects(CancellationToken cancellationTok
         {
             base.CreateNestedHitObjects(cancellationToken);
 
+            // Generally node samples will be populated by ManiaBeatmapConverter, but in a case like the editor they may not be.
+            // Ensure they are set to a sane default here.
+            NodeSamples ??= CreateDefaultNodeSamples(this);
+
             AddNested(Head = new HeadNote
             {
                 StartTime = StartTime,
@@ -102,7 +107,7 @@ protected override void CreateNestedHitObjects(CancellationToken cancellationTok
             {
                 StartTime = EndTime,
                 Column = Column,
-                Samples = GetNodeSamples((NodeSamples?.Count - 1) ?? 1),
+                Samples = GetNodeSamples(NodeSamples.Count - 1),
             });
 
             AddNested(Body = new HoldNoteBody
@@ -116,7 +121,20 @@ protected override void CreateNestedHitObjects(CancellationToken cancellationTok
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
 
-        public IList<HitSampleInfo> GetNodeSamples(int nodeIndex) =>
-            nodeIndex < NodeSamples?.Count ? NodeSamples[nodeIndex] : Samples;
+        public IList<HitSampleInfo> GetNodeSamples(int nodeIndex) => nodeIndex < NodeSamples?.Count ? NodeSamples[nodeIndex] : Samples;
+
+        /// <summary>
+        /// Create the default note samples for a hold note, based off their main sample.
+        /// </summary>
+        /// <remarks>
+        /// By default, osu!mania beatmaps in only play samples at the start of the hold note.
+        /// </remarks>
+        /// <param name="obj">The object to use as a basis for the head sample.</param>
+        /// <returns>Defaults for assigning to <see cref="HoldNote.NodeSamples"/>.</returns>
+        public static List<IList<HitSampleInfo>> CreateDefaultNodeSamples(HitObject obj) => new List<IList<HitSampleInfo>>
+        {
+            obj.Samples,
+            new List<HitSampleInfo>(),
+        };
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Skinning/Argon/ArgonManiaComboCounter.cs b/osu.Game.Rulesets.Mania/Skinning/Argon/ArgonManiaComboCounter.cs
index 5b23cea49623..6626e5f1c768 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Argon/ArgonManiaComboCounter.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Argon/ArgonManiaComboCounter.cs
@@ -38,11 +38,11 @@ protected override void LoadComplete()
         private void updateAnchor()
         {
             // if the anchor isn't a vertical center, set top or bottom anchor based on scroll direction
-            if (!Anchor.HasFlag(Anchor.y1))
-            {
-                Anchor &= ~(Anchor.y0 | Anchor.y2);
-                Anchor |= direction.Value == ScrollingDirection.Up ? Anchor.y2 : Anchor.y0;
-            }
+            if (Anchor.HasFlag(Anchor.y1))
+                return;
+
+            Anchor &= ~(Anchor.y0 | Anchor.y2);
+            Anchor |= direction.Value == ScrollingDirection.Up ? Anchor.y2 : Anchor.y0;
 
             // change the sign of the Y coordinate in line with the scrolling direction.
             // i.e. if the user changes direction from down to up, the anchor is changed from top to bottom, and the Y is flipped from positive to negative here.
diff --git a/osu.Game.Rulesets.Mania/Skinning/Argon/ManiaArgonSkinTransformer.cs b/osu.Game.Rulesets.Mania/Skinning/Argon/ManiaArgonSkinTransformer.cs
index dbd690f89096..afccb2e56829 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Argon/ManiaArgonSkinTransformer.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Argon/ManiaArgonSkinTransformer.cs
@@ -28,18 +28,14 @@ public ManiaArgonSkinTransformer(ISkin skin, IBeatmap beatmap)
         {
             switch (lookup)
             {
-                case SkinComponentsContainerLookup containerLookup:
+                case GlobalSkinnableContainerLookup containerLookup:
                     // Only handle per ruleset defaults here.
                     if (containerLookup.Ruleset == null)
                         return base.GetDrawableComponent(lookup);
 
-                    // Skin has configuration.
-                    if (base.GetDrawableComponent(lookup) is UserConfiguredLayoutContainer d)
-                        return d;
-
-                    switch (containerLookup.Target)
+                    switch (containerLookup.Lookup)
                     {
-                        case SkinComponentsContainerLookup.TargetArea.MainHUDComponents:
+                        case GlobalSkinnableContainers.MainHUDComponents:
                             return new DefaultSkinComponentsContainer(container =>
                             {
                                 var combo = container.ChildrenOfType<ArgonManiaComboCounter>().FirstOrDefault();
@@ -59,7 +55,7 @@ public ManiaArgonSkinTransformer(ISkin skin, IBeatmap beatmap)
 
                     return null;
 
-                case GameplaySkinComponentLookup<HitResult> resultComponent:
+                case SkinComponentLookup<HitResult> resultComponent:
                     // This should eventually be moved to a skin setting, when supported.
                     if (Skin is ArgonProSkin && resultComponent.Component >= HitResult.Great)
                         return Drawable.Empty();
diff --git a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyManiaComboCounter.cs b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyManiaComboCounter.cs
index 5832210836df..889e6326f7e4 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyManiaComboCounter.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyManiaComboCounter.cs
@@ -1,9 +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.Globalization;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
@@ -11,17 +15,76 @@
 
 namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
-    public partial class LegacyManiaComboCounter : LegacyComboCounter
+    public partial class LegacyManiaComboCounter : CompositeDrawable, ISerialisableDrawable
     {
+        public bool UsesFixedAnchor { get; set; }
+
+        public Bindable<int> Current { get; } = new BindableInt { MinValue = 0 };
+
+        /// <summary>
+        /// Value shown at the current moment.
+        /// </summary>
+        public virtual int DisplayedCount
+        {
+            get => displayedCount;
+            private set
+            {
+                if (displayedCount.Equals(value))
+                    return;
+
+                displayedCountText.FadeTo(value == 0 ? 0 : 1);
+                displayedCountText.Text = value.ToString(CultureInfo.InvariantCulture);
+                counterContainer.Size = displayedCountText.Size;
+
+                displayedCount = value;
+            }
+        }
+
+        private int displayedCount;
+
+        private int previousValue;
+
+        private const double fade_out_duration = 100;
+        private const double rolling_duration = 20;
+
+        private Container counterContainer = null!;
+        private LegacySpriteText popOutCountText = null!;
+        private LegacySpriteText displayedCountText = null!;
+
         [BackgroundDependencyLoader]
-        private void load(ISkinSource skin)
+        private void load(ISkinSource skin, ScoreProcessor scoreProcessor)
         {
-            DisplayedCountText.Anchor = Anchor.Centre;
-            DisplayedCountText.Origin = Anchor.Centre;
+            AutoSizeAxes = Axes.Both;
 
-            PopOutCountText.Anchor = Anchor.Centre;
-            PopOutCountText.Origin = Anchor.Centre;
-            PopOutCountText.Colour = skin.GetManiaSkinConfig<Color4>(LegacyManiaSkinConfigurationLookups.ComboBreakColour)?.Value ?? Color4.Red;
+            InternalChildren = new[]
+            {
+                counterContainer = new Container
+                {
+                    AlwaysPresent = true,
+                    Children = new[]
+                    {
+                        popOutCountText = new LegacySpriteText(LegacyFont.Combo)
+                        {
+                            Alpha = 0,
+                            Blending = BlendingParameters.Additive,
+                            BypassAutoSizeAxes = Axes.Both,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Colour = skin.GetManiaSkinConfig<Color4>(LegacyManiaSkinConfigurationLookups.ComboBreakColour)?.Value ?? Color4.Red,
+                        },
+                        displayedCountText = new LegacySpriteText(LegacyFont.Combo)
+                        {
+                            Alpha = 0,
+                            AlwaysPresent = true,
+                            BypassAutoSizeAxes = Axes.Both,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                    }
+                }
+            };
+
+            Current.BindTo(scoreProcessor.Combo);
         }
 
         [Resolved]
@@ -33,6 +96,12 @@ protected override void LoadComplete()
         {
             base.LoadComplete();
 
+            displayedCountText.Text = popOutCountText.Text = Current.Value.ToString(CultureInfo.InvariantCulture);
+
+            Current.BindValueChanged(combo => updateCount(combo.NewValue == 0), true);
+
+            counterContainer.Size = displayedCountText.Size;
+
             direction = scrollingInfo.Direction.GetBoundCopy();
             direction.BindValueChanged(_ => updateAnchor());
 
@@ -44,48 +113,82 @@ protected override void LoadComplete()
         private void updateAnchor()
         {
             // if the anchor isn't a vertical center, set top or bottom anchor based on scroll direction
-            if (!Anchor.HasFlag(Anchor.y1))
+            if (Anchor.HasFlag(Anchor.y1))
+                return;
+
+            Anchor &= ~(Anchor.y0 | Anchor.y2);
+            Anchor |= direction.Value == ScrollingDirection.Up ? Anchor.y2 : Anchor.y0;
+
+            // change the sign of the Y coordinate in line with the scrolling direction.
+            // i.e. if the user changes direction from down to up, the anchor is changed from top to bottom, and the Y is flipped from positive to negative here.
+            Y = Math.Abs(Y) * (direction.Value == ScrollingDirection.Up ? -1 : 1);
+        }
+
+        private void updateCount(bool rolling)
+        {
+            int prev = previousValue;
+            previousValue = Current.Value;
+
+            if (!IsLoaded)
+                return;
+
+            if (!rolling)
             {
-                Anchor &= ~(Anchor.y0 | Anchor.y2);
-                Anchor |= direction.Value == ScrollingDirection.Up ? Anchor.y2 : Anchor.y0;
-            }
+                FinishTransforms(false, nameof(DisplayedCount));
 
-            // since we flip the vertical anchor when changing scroll direction,
-            // we can use the sign of the Y value as an indicator to make the combo counter displayed correctly.
-            if ((Y < 0 && direction.Value == ScrollingDirection.Down) || (Y > 0 && direction.Value == ScrollingDirection.Up))
-                Y = -Y;
+                if (prev + 1 == Current.Value)
+                    onCountIncrement();
+                else
+                    onCountChange();
+            }
+            else
+                onCountRolling();
         }
 
-        protected override void OnCountIncrement()
+        private void onCountIncrement()
         {
-            base.OnCountIncrement();
+            popOutCountText.Hide();
 
-            PopOutCountText.Hide();
-            DisplayedCountText.ScaleTo(new Vector2(1f, 1.4f))
+            DisplayedCount = Current.Value;
+            displayedCountText.ScaleTo(new Vector2(1f, 1.4f))
                               .ScaleTo(new Vector2(1f), 300, Easing.Out)
                               .FadeIn(120);
         }
 
-        protected override void OnCountChange()
+        private void onCountChange()
         {
-            base.OnCountChange();
+            popOutCountText.Hide();
+
+            if (Current.Value == 0)
+                displayedCountText.FadeOut();
+
+            DisplayedCount = Current.Value;
 
-            PopOutCountText.Hide();
-            DisplayedCountText.ScaleTo(1f);
+            displayedCountText.ScaleTo(1f);
         }
 
-        protected override void OnCountRolling()
+        private void onCountRolling()
         {
             if (DisplayedCount > 0)
             {
-                PopOutCountText.Text = FormatCount(DisplayedCount);
-                PopOutCountText.FadeTo(0.8f).FadeOut(200)
+                popOutCountText.Text = DisplayedCount.ToString(CultureInfo.InvariantCulture);
+                popOutCountText.FadeTo(0.8f).FadeOut(200)
                                .ScaleTo(1f).ScaleTo(4f, 200);
 
-                DisplayedCountText.FadeTo(0.5f, 300);
+                displayedCountText.FadeTo(0.5f, 300);
             }
 
-            base.OnCountRolling();
+            // Hides displayed count if was increasing from 0 to 1 but didn't finish
+            if (DisplayedCount == 0 && Current.Value == 0)
+                displayedCountText.FadeOut(fade_out_duration);
+
+            this.TransformTo(nameof(DisplayedCount), Current.Value, getProportionalDuration(DisplayedCount, Current.Value));
+        }
+
+        private double getProportionalDuration(int currentValue, int newValue)
+        {
+            double difference = currentValue > newValue ? currentValue - newValue : newValue - currentValue;
+            return difference * rolling_duration;
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs b/osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs
index c25b77610aba..cb42b2b62aba 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs
@@ -80,22 +80,18 @@ public override Drawable GetDrawableComponent(ISkinComponentLookup lookup)
         {
             switch (lookup)
             {
-                case SkinComponentsContainerLookup containerLookup:
+                case GlobalSkinnableContainerLookup containerLookup:
                     // Modifications for global components.
                     if (containerLookup.Ruleset == null)
                         return base.GetDrawableComponent(lookup);
 
-                    // Skin has configuration.
-                    if (base.GetDrawableComponent(lookup) is UserConfiguredLayoutContainer d)
-                        return d;
-
                     // we don't have enough assets to display these components (this is especially the case on a "beatmap" skin).
                     if (!IsProvidingLegacyResources)
                         return null;
 
-                    switch (containerLookup.Target)
+                    switch (containerLookup.Lookup)
                     {
-                        case SkinComponentsContainerLookup.TargetArea.MainHUDComponents:
+                        case GlobalSkinnableContainers.MainHUDComponents:
                             return new DefaultSkinComponentsContainer(container =>
                             {
                                 var combo = container.ChildrenOfType<LegacyManiaComboCounter>().FirstOrDefault();
@@ -114,7 +110,7 @@ public override Drawable GetDrawableComponent(ISkinComponentLookup lookup)
 
                     return null;
 
-                case GameplaySkinComponentLookup<HitResult> resultComponent:
+                case SkinComponentLookup<HitResult> resultComponent:
                     return getResult(resultComponent.Component);
 
                 case ManiaSkinComponentLookup maniaComponent:
diff --git a/osu.Game.Rulesets.Mania/UI/ManiaTouchInputArea.cs b/osu.Game.Rulesets.Mania/UI/ManiaTouchInputArea.cs
index 453b75ac84fd..8c4a71cf2407 100644
--- a/osu.Game.Rulesets.Mania/UI/ManiaTouchInputArea.cs
+++ b/osu.Game.Rulesets.Mania/UI/ManiaTouchInputArea.cs
@@ -99,12 +99,6 @@ protected override bool OnKeyDown(KeyDownEvent e)
             return false;
         }
 
-        protected override bool OnMouseDown(MouseDownEvent e)
-        {
-            Show();
-            return true;
-        }
-
         protected override bool OnTouchDown(TouchDownEvent e)
         {
             Show();
@@ -172,17 +166,6 @@ protected override void OnTouchUp(TouchUpEvent e)
                 updateButton(false);
             }
 
-            protected override bool OnMouseDown(MouseDownEvent e)
-            {
-                updateButton(true);
-                return false; // handled by parent container to show overlay.
-            }
-
-            protected override void OnMouseUp(MouseUpEvent e)
-            {
-                updateButton(false);
-            }
-
             private void updateButton(bool press)
             {
                 if (press == isPressed)
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs
index a49afd82f3e2..a105d860bf17 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs
@@ -14,6 +14,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
     public partial class TestSceneHitCirclePlacementBlueprint : PlacementBlueprintTestScene
     {
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableHitCircle((HitCircle)hitObject);
-        protected override PlacementBlueprint CreateBlueprint() => new HitCirclePlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new HitCirclePlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
index b17f4e74877c..b70ecfbba8e1 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
@@ -24,24 +24,24 @@ public partial class TestSceneOsuEditorGrids : EditorTestScene
         [Test]
         public void TestGridToggles()
         {
-            AddStep("enable distance snap grid", () => InputManager.Key(Key.T));
+            AddStep("enable distance snap grid", () => InputManager.Key(Key.Y));
             AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
 
             AddUntilStep("distance snap grid visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
             gridActive<RectangularPositionSnapGrid>(false);
 
-            AddStep("enable rectangular grid", () => InputManager.Key(Key.Y));
+            AddStep("enable rectangular grid", () => InputManager.Key(Key.T));
 
             AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
             AddUntilStep("distance snap grid still visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
             gridActive<RectangularPositionSnapGrid>(true);
 
-            AddStep("disable distance snap grid", () => InputManager.Key(Key.T));
+            AddStep("disable distance snap grid", () => InputManager.Key(Key.Y));
             AddUntilStep("distance snap grid hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
             AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
             gridActive<RectangularPositionSnapGrid>(true);
 
-            AddStep("disable rectangular grid", () => InputManager.Key(Key.Y));
+            AddStep("disable rectangular grid", () => InputManager.Key(Key.T));
             AddUntilStep("distance snap grid still hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
             gridActive<RectangularPositionSnapGrid>(false);
         }
@@ -57,7 +57,7 @@ public void TestDistanceSnapMomentaryToggle()
             AddStep("release alt", () => InputManager.ReleaseKey(Key.AltLeft));
             AddUntilStep("distance snap grid hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
 
-            AddStep("enable distance snap grid", () => InputManager.Key(Key.T));
+            AddStep("enable distance snap grid", () => InputManager.Key(Key.Y));
             AddUntilStep("distance snap grid visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
             AddStep("hold alt", () => InputManager.PressKey(Key.AltLeft));
             AddUntilStep("distance snap grid hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
@@ -70,7 +70,7 @@ public void TestDistanceSnapAdjustDoesNotHideTheGridIfStartingEnabled()
         {
             double distanceSnap = double.PositiveInfinity;
 
-            AddStep("enable distance snap grid", () => InputManager.Key(Key.T));
+            AddStep("enable distance snap grid", () => InputManager.Key(Key.Y));
 
             AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
             AddUntilStep("distance snap grid visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
@@ -170,7 +170,7 @@ private Vector2 uniqueSnappingPosition(PositionSnapGrid grid)
         [Test]
         public void TestGridSizeToggling()
         {
-            AddStep("enable rectangular grid", () => InputManager.Key(Key.Y));
+            AddStep("enable rectangular grid", () => InputManager.Key(Key.T));
             AddUntilStep("rectangular grid visible", () => this.ChildrenOfType<RectangularPositionSnapGrid>().Any());
             gridSizeIs(4);
 
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
index 30e0dbbf2e6f..d14bd1fc87c8 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
@@ -116,7 +116,7 @@ public void TestRotateCorrectness()
                 () => EditorBeatmap.HitObjects.OfType<HitCircle>().ElementAt(1).Position,
                 () => Is.EqualTo(OsuPlayfield.BASE_SIZE - new Vector2(200)));
 
-            AddStep("change rotation origin", () => getPopover().ChildrenOfType<EditorRadioButton>().ElementAt(1).TriggerClick());
+            AddStep("change rotation origin", () => getPopover().ChildrenOfType<EditorRadioButton>().ElementAt(2).TriggerClick());
             AddAssert("first object rotated 90deg around selection centre",
                 () => EditorBeatmap.HitObjects.OfType<HitCircle>().ElementAt(0).Position, () => Is.EqualTo(new Vector2(200, 200)));
             AddAssert("second object rotated 90deg around selection centre",
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderChangeStates.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderChangeStates.cs
new file mode 100644
index 000000000000..0b8f2f741760
--- /dev/null
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderChangeStates.cs
@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    public partial class TestSceneSliderChangeStates : TestSceneOsuEditor
+    {
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        [TestCase(SplineType.Catmull)]
+        [TestCase(SplineType.BSpline)]
+        [TestCase(SplineType.Linear)]
+        [TestCase(SplineType.PerfectCurve)]
+        public void TestSliderRetainsCurveTypes(SplineType splineType)
+        {
+            Slider? slider = null;
+            PathType pathType = new PathType(splineType);
+
+            AddStep("add slider", () => EditorBeatmap.Add(slider = new Slider
+            {
+                StartTime = 500,
+                Path = new SliderPath(new[]
+                {
+                    new PathControlPoint(Vector2.Zero, pathType),
+                    new PathControlPoint(new Vector2(200, 0), pathType),
+                })
+            }));
+            AddAssert("slider has correct spline type", () => ((Slider)EditorBeatmap.HitObjects[0]).Path.ControlPoints.All(p => p.Type == pathType));
+            AddStep("remove object", () => EditorBeatmap.Remove(slider));
+            AddAssert("slider removed", () => EditorBeatmap.HitObjects.Count == 0);
+            addUndoSteps();
+            AddAssert("slider not removed", () => EditorBeatmap.HitObjects.Count == 1);
+            AddAssert("slider has correct spline type", () => ((Slider)EditorBeatmap.HitObjects[0]).Path.ControlPoints.All(p => p.Type == pathType));
+        }
+
+        private void addUndoSteps() => AddStep("undo", () => Editor.Undo());
+    }
+}
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
index aa6a6f08d878..019565ae2920 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
@@ -514,6 +514,6 @@ private void assertControlPointPosition(int index, Vector2 position) =>
         private Slider? getSlider() => HitObjectContainer.Count > 0 ? ((DrawableSlider)HitObjectContainer[0]).HitObject : null;
 
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSlider((Slider)hitObject);
-        protected override PlacementBlueprint CreateBlueprint() => new SliderPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new SliderPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs
index d4d99e101948..f0f969b15b9c 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using NUnit.Framework;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@@ -22,9 +20,9 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public partial class TestSceneSliderSelectionBlueprint : SelectionBlueprintTestScene
     {
-        private Slider slider;
-        private DrawableSlider drawableObject;
-        private TestSliderBlueprint blueprint;
+        private Slider slider = null!;
+        private DrawableSlider drawableObject = null!;
+        private TestSliderBlueprint blueprint = null!;
 
         [SetUp]
         public void Setup() => Schedule(() =>
@@ -163,6 +161,44 @@ public void TestMultipleControlPointDeselectionViaClickOutside()
             checkControlPointSelected(1, false);
         }
 
+        [Test]
+        public void TestAdjustLength()
+        {
+            AddStep("move mouse to drag marker", () =>
+            {
+                Vector2 position = slider.Position + slider.Path.PositionAt(1) + new Vector2(60, 0);
+                InputManager.MoveMouseTo(drawableObject.Parent!.ToScreenSpace(position));
+            });
+            AddStep("start drag", () => InputManager.PressButton(MouseButton.Left));
+            AddStep("move mouse to control point 1", () =>
+            {
+                Vector2 position = slider.Position + slider.Path.ControlPoints[1].Position + new Vector2(60, 0);
+                InputManager.MoveMouseTo(drawableObject.Parent!.ToScreenSpace(position));
+            });
+            AddStep("end adjust length", () => InputManager.ReleaseButton(MouseButton.Left));
+            AddAssert("expected distance halved",
+                () => Precision.AlmostEquals(slider.Path.Distance, 172.2, 0.1));
+
+            AddStep("move mouse to drag marker", () =>
+            {
+                Vector2 position = slider.Position + slider.Path.PositionAt(1) + new Vector2(60, 0);
+                InputManager.MoveMouseTo(drawableObject.Parent!.ToScreenSpace(position));
+            });
+            AddStep("start drag", () => InputManager.PressButton(MouseButton.Left));
+            AddStep("move mouse beyond last control point", () =>
+            {
+                Vector2 position = slider.Position + slider.Path.ControlPoints[2].Position + new Vector2(100, 0);
+                InputManager.MoveMouseTo(drawableObject.Parent!.ToScreenSpace(position));
+            });
+            AddStep("end adjust length", () => InputManager.ReleaseButton(MouseButton.Left));
+            AddAssert("expected distance is calculated distance",
+                () => Precision.AlmostEquals(slider.Path.Distance, slider.Path.CalculatedDistance, 0.1));
+
+            moveMouseToControlPoint(1);
+            AddAssert("expected distance is unchanged",
+                () => Precision.AlmostEquals(slider.Path.Distance, slider.Path.CalculatedDistance, 0.1));
+        }
+
         private void moveHitObject()
         {
             AddStep("move hitobject", () =>
@@ -180,6 +216,9 @@ private void checkPositions()
 
             AddAssert("tail positioned correctly",
                 () => Precision.AlmostEquals(blueprint.TailOverlay.CirclePiece.ScreenSpaceDrawQuad.Centre, drawableObject.TailCircle.ScreenSpaceDrawQuad.Centre));
+
+            AddAssert("end drag marker positioned correctly",
+                () => Precision.AlmostEquals(blueprint.TailOverlay.EndDragMarker!.ToScreenSpace(blueprint.TailOverlay.EndDragMarker.OriginPosition), drawableObject.TailCircle.ScreenSpaceDrawQuad.Centre, 2));
         }
 
         private void moveMouseToControlPoint(int index)
@@ -192,14 +231,14 @@ private void moveMouseToControlPoint(int index)
         }
 
         private void checkControlPointSelected(int index, bool selected)
-            => AddAssert($"control point {index} {(selected ? "selected" : "not selected")}", () => blueprint.ControlPointVisualiser.Pieces[index].IsSelected.Value == selected);
+            => AddAssert($"control point {index} {(selected ? "selected" : "not selected")}", () => blueprint.ControlPointVisualiser!.Pieces[index].IsSelected.Value == selected);
 
         private partial class TestSliderBlueprint : SliderSelectionBlueprint
         {
             public new SliderBodyPiece BodyPiece => base.BodyPiece;
             public new TestSliderCircleOverlay HeadOverlay => (TestSliderCircleOverlay)base.HeadOverlay;
             public new TestSliderCircleOverlay TailOverlay => (TestSliderCircleOverlay)base.TailOverlay;
-            public new PathControlPointVisualiser<Slider> ControlPointVisualiser => base.ControlPointVisualiser;
+            public new PathControlPointVisualiser<Slider>? ControlPointVisualiser => base.ControlPointVisualiser;
 
             public TestSliderBlueprint(Slider slider)
                 : base(slider)
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
index 0e8673319ea8..d7b5cc73bec2 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
@@ -15,6 +15,6 @@ public partial class TestSceneSpinnerPlacementBlueprint : PlacementBlueprintTest
     {
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSpinner((Spinner)hitObject);
 
-        protected override PlacementBlueprint CreateBlueprint() => new SpinnerPlacementBlueprint();
+        protected override HitObjectPlacementBlueprint CreateBlueprint() => new SpinnerPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneCursorTrail.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneCursorTrail.cs
index 4db66fde4b31..17f365f820c4 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneCursorTrail.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneCursorTrail.cs
@@ -88,6 +88,21 @@ public void TestLegacyDisjointCursorTrailViaNoCursor()
             AddAssert("trail is disjoint", () => this.ChildrenOfType<LegacyCursorTrail>().Single().DisjointTrail, () => Is.True);
         }
 
+        [Test]
+        public void TestClickExpand()
+        {
+            createTest(() => new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Scale = new Vector2(10),
+                Child = new CursorTrail(),
+            });
+
+            AddStep("expand", () => this.ChildrenOfType<CursorTrail>().Single().NewPartScale = new Vector2(3));
+            AddWaitStep("let the cursor trail draw a bit", 5);
+            AddStep("contract", () => this.ChildrenOfType<CursorTrail>().Single().NewPartScale = Vector2.One);
+        }
+
         private void createTest(Func<Drawable> createContent) => AddStep("create trail", () =>
         {
             Clear();
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneOsuAnalysisContainer.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneOsuAnalysisContainer.cs
new file mode 100644
index 000000000000..184938ceda8b
--- /dev/null
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneOsuAnalysisContainer.cs
@@ -0,0 +1,133 @@
+// 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.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Osu.Configuration;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public partial class TestSceneOsuAnalysisContainer : OsuTestScene
+    {
+        private TestReplayAnalysisOverlay analysisContainer = null!;
+        private ReplayAnalysisSettings settings = null!;
+
+        [Cached]
+        private OsuRulesetConfigManager config = new OsuRulesetConfigManager(null, new OsuRuleset().RulesetInfo);
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create analysis container", () =>
+            {
+                Children = new Drawable[]
+                {
+                    new OsuPlayfieldAdjustmentContainer
+                    {
+                        Child = analysisContainer = new TestReplayAnalysisOverlay(fabricateReplay()),
+                    },
+                    settings = new ReplayAnalysisSettings(config),
+                };
+
+                settings.ShowClickMarkers.Value = false;
+                settings.ShowAimMarkers.Value = false;
+                settings.ShowCursorPath.Value = false;
+            });
+        }
+
+        [Test]
+        public void TestEverythingOn()
+        {
+            AddStep("enable everything", () =>
+            {
+                settings.ShowClickMarkers.Value = true;
+                settings.ShowAimMarkers.Value = true;
+                settings.ShowCursorPath.Value = true;
+            });
+        }
+
+        [Test]
+        public void TestHitMarkers()
+        {
+            AddStep("enable hit markers", () => settings.ShowClickMarkers.Value = true);
+            AddUntilStep("hit markers visible", () => analysisContainer.HitMarkersVisible);
+            AddStep("disable hit markers", () => settings.ShowClickMarkers.Value = false);
+            AddUntilStep("hit markers not visible", () => !analysisContainer.HitMarkersVisible);
+        }
+
+        [Test]
+        public void TestAimMarker()
+        {
+            AddStep("enable aim markers", () => settings.ShowAimMarkers.Value = true);
+            AddUntilStep("aim markers visible", () => analysisContainer.AimMarkersVisible);
+            AddStep("disable aim markers", () => settings.ShowAimMarkers.Value = false);
+            AddUntilStep("aim markers not visible", () => !analysisContainer.AimMarkersVisible);
+        }
+
+        [Test]
+        public void TestAimLines()
+        {
+            AddStep("enable aim lines", () => settings.ShowCursorPath.Value = true);
+            AddUntilStep("aim lines visible", () => analysisContainer.AimLinesVisible);
+            AddStep("disable aim lines", () => settings.ShowCursorPath.Value = false);
+            AddUntilStep("aim lines not visible", () => !analysisContainer.AimLinesVisible);
+        }
+
+        private Replay fabricateReplay()
+        {
+            var frames = new List<ReplayFrame>();
+            var random = new Random();
+            int posX = 250;
+            int posY = 250;
+
+            var actions = new HashSet<OsuAction>();
+
+            for (int i = 0; i < 1000; i++)
+            {
+                posX = Math.Clamp(posX + random.Next(-20, 21), -100, 600);
+                posY = Math.Clamp(posY + random.Next(-20, 21), -100, 600);
+
+                if (random.NextDouble() > (actions.Count == 0 ? 0.9 : 0.95))
+                {
+                    actions.Add(random.NextDouble() > 0.5 ? OsuAction.LeftButton : OsuAction.RightButton);
+                }
+                else if (random.NextDouble() > 0.7)
+                {
+                    actions.Remove(random.NextDouble() > 0.5 ? OsuAction.LeftButton : OsuAction.RightButton);
+                }
+
+                frames.Add(new OsuReplayFrame
+                {
+                    Time = Time.Current + i * 15,
+                    Position = new Vector2(posX, posY),
+                    Actions = actions.ToList(),
+                });
+            }
+
+            return new Replay { Frames = frames };
+        }
+
+        private partial class TestReplayAnalysisOverlay : ReplayAnalysisOverlay
+        {
+            public TestReplayAnalysisOverlay(Replay replay)
+                : base(replay)
+            {
+            }
+
+            public bool HitMarkersVisible => ClickMarkers?.Alpha > 0 && ClickMarkers.Entries.Any();
+            public bool AimMarkersVisible => FrameMarkers?.Alpha > 0 && FrameMarkers.Entries.Any();
+            public bool AimLinesVisible => CursorPath?.Alpha > 0 && CursorPath.Vertices.Count > 1;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Configuration/OsuRulesetConfigManager.cs b/osu.Game.Rulesets.Osu/Configuration/OsuRulesetConfigManager.cs
index 2056a50edab2..580c7e6bd88f 100644
--- a/osu.Game.Rulesets.Osu/Configuration/OsuRulesetConfigManager.cs
+++ b/osu.Game.Rulesets.Osu/Configuration/OsuRulesetConfigManager.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.UI;
@@ -11,7 +9,7 @@ namespace osu.Game.Rulesets.Osu.Configuration
 {
     public class OsuRulesetConfigManager : RulesetConfigManager<OsuRulesetSetting>
     {
-        public OsuRulesetConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
+        public OsuRulesetConfigManager(SettingsStore? settings, RulesetInfo ruleset, int? variant = null)
             : base(settings, ruleset, variant)
         {
         }
@@ -24,6 +22,12 @@ protected override void InitialiseDefaults()
             SetDefault(OsuRulesetSetting.ShowCursorTrail, true);
             SetDefault(OsuRulesetSetting.ShowCursorRipples, false);
             SetDefault(OsuRulesetSetting.PlayfieldBorderStyle, PlayfieldBorderStyle.None);
+
+            SetDefault(OsuRulesetSetting.ReplayClickMarkersEnabled, false);
+            SetDefault(OsuRulesetSetting.ReplayFrameMarkersEnabled, false);
+            SetDefault(OsuRulesetSetting.ReplayCursorPathEnabled, false);
+            SetDefault(OsuRulesetSetting.ReplayCursorHideEnabled, false);
+            SetDefault(OsuRulesetSetting.ReplayAnalysisDisplayLength, 800);
         }
     }
 
@@ -34,5 +38,12 @@ public enum OsuRulesetSetting
         ShowCursorTrail,
         ShowCursorRipples,
         PlayfieldBorderStyle,
+
+        // Replay
+        ReplayClickMarkersEnabled,
+        ReplayFrameMarkersEnabled,
+        ReplayCursorPathEnabled,
+        ReplayCursorHideEnabled,
+        ReplayAnalysisDisplayLength,
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs
index 2df383aaa891..37fd11391c19 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs
@@ -10,7 +10,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
 {
     public static class SpeedEvaluator
     {
-        private const double single_spacing_threshold = 125;
+        private const double single_spacing_threshold = 125; // 1.25 circles distance between centers
         private const double min_speed_bonus = 75; // ~200BPM
         private const double speed_balancing_factor = 40;
 
@@ -50,16 +50,27 @@ public static double EvaluateDifficultyOf(DifficultyHitObject current)
             // 0.93 is derived from making sure 260bpm OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
             strainTime /= Math.Clamp((strainTime / osuCurrObj.HitWindowGreat) / 0.93, 0.92, 1);
 
-            // derive speedBonus for calculation
+            // speedBonus will be 1.0 for BPM < 200
             double speedBonus = 1.0;
 
+            // Add additional scaling bonus for streams/bursts higher than 200bpm
             if (strainTime < min_speed_bonus)
                 speedBonus = 1 + 0.75 * Math.Pow((min_speed_bonus - strainTime) / speed_balancing_factor, 2);
 
             double travelDistance = osuPrevObj?.TravelDistance ?? 0;
-            double distance = Math.Min(single_spacing_threshold, travelDistance + osuCurrObj.MinimumJumpDistance);
+            double distance = travelDistance + osuCurrObj.MinimumJumpDistance;
 
-            return (speedBonus + speedBonus * Math.Pow(distance / single_spacing_threshold, 3.5)) * doubletapness / strainTime;
+            // Cap distance at single_spacing_threshold
+            distance = Math.Min(distance, single_spacing_threshold);
+
+            // Max distance bonus is 2 at single_spacing_threshold
+            double distanceBonus = 1 + Math.Pow(distance / single_spacing_threshold, 3.5);
+
+            // Base difficulty with all bonuses
+            double difficulty = speedBonus * distanceBonus * 1000 / strainTime;
+
+            // Apply penalty if there's doubletappable doubles
+            return difficulty * doubletapness;
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index e93475ecff04..c4fcd1f760fe 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -81,7 +81,6 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
 
             double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
             double drainRate = beatmap.Difficulty.DrainRate;
-            int maxCombo = beatmap.GetMaxCombo();
 
             int hitCirclesCount = beatmap.HitObjects.Count(h => h is HitCircle);
             int sliderCount = beatmap.HitObjects.Count(h => h is Slider);
@@ -104,7 +103,7 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
                 ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
                 OverallDifficulty = (80 - hitWindowGreat) / 6,
                 DrainRate = drainRate,
-                MaxCombo = maxCombo,
+                MaxCombo = beatmap.GetMaxCombo(),
                 HitCircleCount = hitCirclesCount,
                 SliderCount = sliderCount,
                 SpinnerCount = spinnerCount,
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
index 3f6b22bbb199..1fbe03395c90 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
@@ -23,7 +23,7 @@ public Aim(Mod[] mods, bool withSliders)
 
         private double currentStrain;
 
-        private double skillMultiplier => 23.55;
+        private double skillMultiplier => 24.963;
         private double strainDecayBase => 0.15;
 
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs
index 939641cae966..6c839eac3fef 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs
@@ -24,7 +24,7 @@ public Flashlight(Mod[] mods)
             hasHiddenMod = mods.Any(m => m is OsuModHidden);
         }
 
-        private double skillMultiplier => 0.052;
+        private double skillMultiplier => 0.05512;
         private double strainDecayBase => 0.15;
 
         private double currentStrain;
@@ -41,7 +41,7 @@ protected override double StrainValueAt(DifficultyHitObject current)
             return currentStrain;
         }
 
-        public override double DifficultyValue() => GetCurrentStrainPeaks().Sum() * OsuStrainSkill.DEFAULT_DIFFICULTY_MULTIPLIER;
+        public override double DifficultyValue() => GetCurrentStrainPeaks().Sum();
 
         public static double DifficultyToPerformance(double difficulty) => 25 * Math.Pow(difficulty, 2);
     }
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index c4068ef0d72f..6823512cef12 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -12,12 +12,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 {
     public abstract class OsuStrainSkill : StrainSkill
     {
-        /// <summary>
-        /// The default multiplier applied by <see cref="OsuStrainSkill"/> to the final difficulty value after all other calculations.
-        /// May be overridden via <see cref="DifficultyMultiplier"/>.
-        /// </summary>
-        public const double DEFAULT_DIFFICULTY_MULTIPLIER = 1.06;
-
         /// <summary>
         /// The number of sections with the highest strains, which the peak strain reductions will apply to.
         /// This is done in order to decrease their impact on the overall difficulty of the map for this skill.
@@ -29,11 +23,6 @@ public abstract class OsuStrainSkill : StrainSkill
         /// </summary>
         protected virtual double ReducedStrainBaseline => 0.75;
 
-        /// <summary>
-        /// The final multiplier to be applied to <see cref="DifficultyValue"/> after all other calculations.
-        /// </summary>
-        protected virtual double DifficultyMultiplier => DEFAULT_DIFFICULTY_MULTIPLIER;
-
         protected OsuStrainSkill(Mod[] mods)
             : base(mods)
         {
@@ -65,7 +54,7 @@ public override double DifficultyValue()
                 weight *= DecayWeight;
             }
 
-            return difficulty * DifficultyMultiplier;
+            return difficulty;
         }
 
         public static double DifficultyToPerformance(double difficulty) => Math.Pow(5.0 * Math.Max(1.0, difficulty / 0.0675) - 4.0, 3.0) / 100000.0;
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
index 40aac013ab8a..70367bb180b4 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
@@ -16,14 +16,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// </summary>
     public class Speed : OsuStrainSkill
     {
-        private double skillMultiplier => 1375;
+        private double skillMultiplier => 1.430;
         private double strainDecayBase => 0.3;
 
         private double currentStrain;
         private double currentRhythm;
 
         protected override int ReducedSectionCount => 5;
-        protected override double DifficultyMultiplier => 1.04;
 
         private readonly List<double> objectStrains = new List<double>();
 
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs
index 20ad99baa24f..78a0e36dc2eb 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs
@@ -9,7 +9,7 @@
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
 {
-    public partial class HitCirclePlacementBlueprint : PlacementBlueprint
+    public partial class HitCirclePlacementBlueprint : HitObjectPlacementBlueprint
     {
         public new HitCircle HitObject => (HitCircle)base.HitObject;
 
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs
index 9d819f6cc088..3337e9921579 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs
@@ -40,7 +40,7 @@ public partial class PathControlPointPiece<T> : BlueprintPiece<T>, IHasTooltip
         public readonly PathControlPoint ControlPoint;
 
         private readonly T hitObject;
-        private readonly Circle circle;
+        private readonly FastCircle circle;
         private readonly Drawable markerRing;
 
         [Resolved]
@@ -62,7 +62,7 @@ public PathControlPointPiece(T hitObject, PathControlPoint controlPoint)
 
             InternalChildren = new[]
             {
-                circle = new Circle
+                circle = new FastCircle
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
index df369dcef5ee..d90aab57884e 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
@@ -353,6 +353,8 @@ private void updatePathTypeOfSelectedPieces(PathType? type)
         {
             changeHandler?.BeginChange();
 
+            double originalDistance = hitObject.Path.Distance;
+
             foreach (var p in Pieces.Where(p => p.IsSelected.Value))
             {
                 var pointsInSegment = hitObject.Path.PointsInSegment(p.ControlPoint);
@@ -375,6 +377,11 @@ private void updatePathTypeOfSelectedPieces(PathType? type)
 
             EnsureValidPathTypes();
 
+            if (hitObject.Path.Distance < originalDistance)
+                hitObject.SnapTo(distanceSnapProvider);
+            else
+                hitObject.Path.ExpectedDistance.Value = originalDistance;
+
             changeHandler?.EndChange();
         }
 
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleOverlay.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleOverlay.cs
index bd3b4bbc5459..9c2998466a81 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleOverlay.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleOverlay.cs
@@ -1,7 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 
@@ -9,11 +12,28 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
     public partial class SliderCircleOverlay : CompositeDrawable
     {
+        public SliderEndDragMarker? EndDragMarker { get; }
+
+        public RectangleF VisibleQuad
+        {
+            get
+            {
+                var result = CirclePiece.ScreenSpaceDrawQuad.AABBFloat;
+
+                if (endDragMarkerContainer == null) return result;
+
+                var size = result.Size * 1.4f;
+                var location = result.TopLeft - result.Size * 0.2f;
+                return new RectangleF(location, size);
+            }
+        }
+
         protected readonly HitCirclePiece CirclePiece;
 
         private readonly Slider slider;
         private readonly SliderPosition position;
         private readonly HitCircleOverlapMarker? marker;
+        private readonly Container? endDragMarkerContainer;
 
         public SliderCircleOverlay(Slider slider, SliderPosition position)
         {
@@ -24,26 +44,49 @@ public SliderCircleOverlay(Slider slider, SliderPosition position)
                 AddInternal(marker = new HitCircleOverlapMarker());
 
             AddInternal(CirclePiece = new HitCirclePiece());
+
+            if (position == SliderPosition.End)
+            {
+                AddInternal(endDragMarkerContainer = new Container
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Padding = new MarginPadding(-2.5f),
+                    Child = EndDragMarker = new SliderEndDragMarker()
+                });
+            }
         }
 
         protected override void Update()
         {
             base.Update();
 
-            var circle = position == SliderPosition.Start ? (HitCircle)slider.HeadCircle : slider.TailCircle;
+            var circle = position == SliderPosition.Start ? (HitCircle)slider.HeadCircle :
+                slider.RepeatCount % 2 == 0 ? slider.TailCircle : slider.LastRepeat!;
 
             CirclePiece.UpdateFrom(circle);
             marker?.UpdateFrom(circle);
+
+            if (endDragMarkerContainer != null)
+            {
+                endDragMarkerContainer.Position = circle.Position + slider.StackOffset;
+                endDragMarkerContainer.Scale = CirclePiece.Scale * 1.2f;
+                var diff = slider.Path.PositionAt(1) - slider.Path.PositionAt(0.99f);
+                endDragMarkerContainer.Rotation = float.RadiansToDegrees(MathF.Atan2(diff.Y, diff.X));
+            }
         }
 
         public override void Hide()
         {
             CirclePiece.Hide();
+            endDragMarkerContainer?.Hide();
         }
 
         public override void Show()
         {
             CirclePiece.Show();
+            endDragMarkerContainer?.Show();
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderEndDragMarker.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderEndDragMarker.cs
new file mode 100644
index 000000000000..37383544dc59
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderEndDragMarker.cs
@@ -0,0 +1,84 @@
+// 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.Lines;
+using osu.Framework.Input.Events;
+using osu.Framework.Utils;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
+{
+    public partial class SliderEndDragMarker : SmoothPath
+    {
+        public Action<DragStartEvent>? StartDrag { get; set; }
+        public Action<DragEvent>? Drag { get; set; }
+        public Action? EndDrag { get; set; }
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var path = PathApproximator.CircularArcToPiecewiseLinear([
+                new Vector2(0, OsuHitObject.OBJECT_RADIUS),
+                new Vector2(OsuHitObject.OBJECT_RADIUS, 0),
+                new Vector2(0, -OsuHitObject.OBJECT_RADIUS)
+            ]);
+
+            Anchor = Anchor.CentreLeft;
+            Origin = Anchor.CentreLeft;
+            PathRadius = 5;
+            Vertices = path;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            updateState();
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateState();
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            updateState();
+            base.OnHoverLost(e);
+        }
+
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            updateState();
+            StartDrag?.Invoke(e);
+            return true;
+        }
+
+        protected override void OnDrag(DragEvent e)
+        {
+            updateState();
+            base.OnDrag(e);
+            Drag?.Invoke(e);
+        }
+
+        protected override void OnDragEnd(DragEndEvent e)
+        {
+            updateState();
+            EndDrag?.Invoke();
+            base.OnDragEnd(e);
+        }
+
+        private void updateState()
+        {
+            Colour = IsHovered || IsDragged ? colours.Red : colours.Yellow;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
index 013f790f65dc..cb57c8e6e0c9 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
@@ -1,13 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
-using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
@@ -25,34 +21,33 @@
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
-    public partial class SliderPlacementBlueprint : PlacementBlueprint
+    public partial class SliderPlacementBlueprint : HitObjectPlacementBlueprint
     {
         public new Slider HitObject => (Slider)base.HitObject;
 
-        private SliderBodyPiece bodyPiece;
-        private HitCirclePiece headCirclePiece;
-        private HitCirclePiece tailCirclePiece;
-        private PathControlPointVisualiser<Slider> controlPointVisualiser;
+        private SliderBodyPiece bodyPiece = null!;
+        private HitCirclePiece headCirclePiece = null!;
+        private HitCirclePiece tailCirclePiece = null!;
+        private PathControlPointVisualiser<Slider> controlPointVisualiser = null!;
+
+        private InputManager inputManager = null!;
 
-        private InputManager inputManager;
+        private PathControlPoint? cursor;
 
         private SliderPlacementState state;
         private PathControlPoint segmentStart;
-        private PathControlPoint cursor;
+
         private int currentSegmentLength;
         private bool usingCustomSegmentType;
 
-        [Resolved(CanBeNull = true)]
-        [CanBeNull]
-        private IPositionSnapProvider positionSnapProvider { get; set; }
+        [Resolved]
+        private IPositionSnapProvider? positionSnapProvider { get; set; }
 
-        [Resolved(CanBeNull = true)]
-        [CanBeNull]
-        private IDistanceSnapProvider distanceSnapProvider { get; set; }
+        [Resolved]
+        private IDistanceSnapProvider? distanceSnapProvider { get; set; }
 
-        [Resolved(CanBeNull = true)]
-        [CanBeNull]
-        private FreehandSliderToolboxGroup freehandToolboxGroup { get; set; }
+        [Resolved]
+        private FreehandSliderToolboxGroup? freehandToolboxGroup { get; set; }
 
         private readonly IncrementalBSplineBuilder bSplineBuilder = new IncrementalBSplineBuilder { Degree = 4 };
 
@@ -84,7 +79,8 @@ private void load()
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            inputManager = GetContainingInputManager();
+
+            inputManager = GetContainingInputManager()!;
 
             if (freehandToolboxGroup != null)
             {
@@ -108,7 +104,7 @@ protected override void LoadComplete()
         }
 
         [Resolved]
-        private EditorBeatmap editorBeatmap { get; set; }
+        private EditorBeatmap editorBeatmap { get; set; } = null!;
 
         public override void UpdateTimeAndPosition(SnapResult result)
         {
@@ -151,7 +147,7 @@ protected override bool OnMouseDown(MouseDownEvent e)
                 case SliderPlacementState.ControlPoints:
                     if (canPlaceNewControlPoint(out var lastPoint))
                         placeNewControlPoint();
-                    else
+                    else if (lastPoint != null)
                         beginNewSegment(lastPoint);
 
                     break;
@@ -162,9 +158,6 @@ protected override bool OnMouseDown(MouseDownEvent e)
 
         private void beginNewSegment(PathControlPoint lastPoint)
         {
-            // Transform the last point into a new segment.
-            Debug.Assert(lastPoint != null);
-
             segmentStart = lastPoint;
             segmentStart.Type = PathType.LINEAR;
 
@@ -384,7 +377,7 @@ private Vector2 getCursorPosition()
         /// </summary>
         /// <param name="lastPoint">The last-placed control point. May be null, but is not null if <c>false</c> is returned.</param>
         /// <returns>Whether a new control point can be placed at the current position.</returns>
-        private bool canPlaceNewControlPoint([CanBeNull] out PathControlPoint lastPoint)
+        private bool canPlaceNewControlPoint(out PathControlPoint? lastPoint)
         {
             // We cannot rely on the ordering of drawable pieces, so find the respective drawable piece by searching for the last non-cursor control point.
             var last = HitObject.Path.ControlPoints.LastOrDefault(p => p != cursor);
@@ -408,7 +401,7 @@ private void updateSlider()
             if (state == SliderPlacementState.Drawing)
                 HitObject.Path.ExpectedDistance.Value = (float)HitObject.Path.CalculatedDistance;
             else
-                HitObject.Path.ExpectedDistance.Value = distanceSnapProvider?.FindSnappedDistance(HitObject, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;
+                HitObject.Path.ExpectedDistance.Value = distanceSnapProvider?.FindSnappedDistance(HitObject, (float)HitObject.Path.CalculatedDistance, DistanceSnapTarget.Start) ?? (float)HitObject.Path.CalculatedDistance;
 
             bodyPiece.UpdateFrom(HitObject);
             headCirclePiece.UpdateFrom(HitObject.HeadCircle);
@@ -436,7 +429,7 @@ private void updateSliderPathFromBSplineBuilder()
                 // Replace this segment with a circular arc if it is a reasonable substitute.
                 var circleArcSegment = tryCircleArc(segment);
 
-                if (circleArcSegment is not null)
+                if (circleArcSegment != null)
                 {
                     HitObject.Path.ControlPoints.Add(new PathControlPoint(circleArcSegment[0], PathType.PERFECT_CURVE));
                     HitObject.Path.ControlPoints.Add(new PathControlPoint(circleArcSegment[1]));
@@ -453,7 +446,7 @@ private void updateSliderPathFromBSplineBuilder()
             }
         }
 
-        private Vector2[] tryCircleArc(List<Vector2> segment)
+        private Vector2[]? tryCircleArc(List<Vector2> segment)
         {
             if (segment.Count < 3 || freehandToolboxGroup?.CircleThreshold.Value == 0) return null;
 
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
index 2c675db2635e..cd66f8d796e5 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
@@ -1,13 +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.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
-using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Caching;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.UserInterface;
@@ -33,27 +33,28 @@ public partial class SliderSelectionBlueprint : OsuSelectionBlueprint<Slider>
     {
         protected new DrawableSlider DrawableObject => (DrawableSlider)base.DrawableObject;
 
-        protected SliderBodyPiece BodyPiece { get; private set; }
-        protected SliderCircleOverlay HeadOverlay { get; private set; }
-        protected SliderCircleOverlay TailOverlay { get; private set; }
+        protected SliderBodyPiece BodyPiece { get; private set; } = null!;
+        protected SliderCircleOverlay HeadOverlay { get; private set; } = null!;
+        protected SliderCircleOverlay TailOverlay { get; private set; } = null!;
+
+        protected PathControlPointVisualiser<Slider>? ControlPointVisualiser { get; private set; }
 
-        [CanBeNull]
-        protected PathControlPointVisualiser<Slider> ControlPointVisualiser { get; private set; }
+        [Resolved]
+        private IDistanceSnapProvider? distanceSnapProvider { get; set; }
 
-        [Resolved(CanBeNull = true)]
-        private IDistanceSnapProvider distanceSnapProvider { get; set; }
+        [Resolved]
+        private IPlacementHandler? placementHandler { get; set; }
 
-        [Resolved(CanBeNull = true)]
-        private IPlacementHandler placementHandler { get; set; }
+        [Resolved]
+        private EditorBeatmap? editorBeatmap { get; set; }
 
-        [Resolved(CanBeNull = true)]
-        private EditorBeatmap editorBeatmap { get; set; }
+        [Resolved]
+        private IEditorChangeHandler? changeHandler { get; set; }
 
-        [Resolved(CanBeNull = true)]
-        private IEditorChangeHandler changeHandler { get; set; }
+        [Resolved]
+        private BindableBeatDivisor? beatDivisor { get; set; }
 
-        [Resolved(CanBeNull = true)]
-        private BindableBeatDivisor beatDivisor { get; set; }
+        private PathControlPoint? placementControlPoint;
 
         public override Quad SelectionQuad
         {
@@ -61,6 +62,9 @@ public override Quad SelectionQuad
             {
                 var result = BodyPiece.ScreenSpaceDrawQuad.AABBFloat;
 
+                result = RectangleF.Union(result, HeadOverlay.VisibleQuad);
+                result = RectangleF.Union(result, TailOverlay.VisibleQuad);
+
                 if (ControlPointVisualiser != null)
                 {
                     foreach (var piece in ControlPointVisualiser.Pieces)
@@ -76,6 +80,11 @@ public override Quad SelectionQuad
         private readonly BindableList<HitObject> selectedObjects = new BindableList<HitObject>();
         private readonly Bindable<bool> showHitMarkers = new Bindable<bool>();
 
+        // Cached slider path which ignored the expected distance value.
+        private readonly Cached<SliderPath> fullPathCache = new Cached<SliderPath>();
+
+        private Vector2 lastRightClickPosition;
+
         public SliderSelectionBlueprint(Slider slider)
             : base(slider)
         {
@@ -91,6 +100,13 @@ private void load(OsuConfigManager config)
                 TailOverlay = CreateCircleOverlay(HitObject, SliderPosition.End),
             };
 
+            // tail will always have a non-null end drag marker.
+            Debug.Assert(TailOverlay.EndDragMarker != null);
+
+            TailOverlay.EndDragMarker.StartDrag += startAdjustingLength;
+            TailOverlay.EndDragMarker.Drag += adjustLength;
+            TailOverlay.EndDragMarker.EndDrag += endAdjustLength;
+
             config.BindWith(OsuSetting.EditorShowHitMarkers, showHitMarkers);
         }
 
@@ -99,6 +115,7 @@ protected override void LoadComplete()
             base.LoadComplete();
 
             controlPoints.BindTo(HitObject.Path.ControlPoints);
+            controlPoints.CollectionChanged += (_, _) => fullPathCache.Invalidate();
 
             pathVersion.BindTo(HitObject.Path.Version);
             pathVersion.BindValueChanged(_ => editorBeatmap?.Update(HitObject));
@@ -123,7 +140,7 @@ public override bool HandleQuickDeletion()
                 return false;
 
             hoveredControlPoint.IsSelected.Value = true;
-            ControlPointVisualiser.DeleteSelected();
+            ControlPointVisualiser?.DeleteSelected();
             return true;
         }
 
@@ -141,7 +158,6 @@ protected override void Update()
         protected override bool OnHover(HoverEvent e)
         {
             updateVisualDefinition();
-
             return base.OnHover(e);
         }
 
@@ -186,17 +202,16 @@ private void updateVisualDefinition()
             }
         }
 
-        private Vector2 rightClickPosition;
-
         protected override bool OnMouseDown(MouseDownEvent e)
         {
             switch (e.Button)
             {
                 case MouseButton.Right:
-                    rightClickPosition = e.MouseDownPosition;
+                    lastRightClickPosition = e.MouseDownPosition;
                     return false; // Allow right click to be handled by context menu
 
                 case MouseButton.Left:
+
                     // If there's more than two objects selected, ctrl+click should deselect
                     if (e.ControlPressed && IsSelected && selectedObjects.Count < 2)
                     {
@@ -212,8 +227,134 @@ protected override bool OnMouseDown(MouseDownEvent e)
             return false;
         }
 
-        [CanBeNull]
-        private PathControlPoint placementControlPoint;
+        #region Length Adjustment (independent of path nodes)
+
+        private Vector2 lengthAdjustMouseOffset;
+        private double oldDuration;
+        private double oldVelocityMultiplier;
+        private double desiredDistance;
+        private bool isAdjustingLength;
+        private bool adjustVelocityMomentary;
+
+        private void startAdjustingLength(DragStartEvent e)
+        {
+            isAdjustingLength = true;
+            adjustVelocityMomentary = e.ShiftPressed;
+            lengthAdjustMouseOffset = ToLocalSpace(e.ScreenSpaceMouseDownPosition) - HitObject.Position - HitObject.Path.PositionAt(1);
+            oldDuration = HitObject.Path.Distance / HitObject.SliderVelocityMultiplier;
+            oldVelocityMultiplier = HitObject.SliderVelocityMultiplier;
+            changeHandler?.BeginChange();
+        }
+
+        private void endAdjustLength()
+        {
+            trimExcessControlPoints(HitObject.Path);
+            changeHandler?.EndChange();
+            isAdjustingLength = false;
+        }
+
+        private void adjustLength(MouseEvent e) => adjustLength(findClosestPathDistance(e), e.ShiftPressed);
+
+        private void adjustLength(double proposedDistance, bool adjustVelocity)
+        {
+            desiredDistance = proposedDistance;
+            double proposedVelocity = oldVelocityMultiplier;
+
+            if (adjustVelocity)
+            {
+                proposedVelocity = proposedDistance / oldDuration;
+                proposedDistance = MathHelper.Clamp(proposedDistance, 0.1 * oldDuration, 10 * oldDuration);
+            }
+            else
+            {
+                double minDistance = distanceSnapProvider?.GetBeatSnapDistanceAt(HitObject, false) * oldVelocityMultiplier ?? 1;
+                // Add a small amount to the proposed distance to make it easier to snap to the full length of the slider.
+                proposedDistance = distanceSnapProvider?.FindSnappedDistance(HitObject, (float)proposedDistance + 1, DistanceSnapTarget.Start) ?? proposedDistance;
+                proposedDistance = MathHelper.Clamp(proposedDistance, minDistance, HitObject.Path.CalculatedDistance);
+            }
+
+            if (Precision.AlmostEquals(proposedDistance, HitObject.Path.Distance) && Precision.AlmostEquals(proposedVelocity, HitObject.SliderVelocityMultiplier))
+                return;
+
+            HitObject.SliderVelocityMultiplier = proposedVelocity;
+            HitObject.Path.ExpectedDistance.Value = proposedDistance;
+            editorBeatmap?.Update(HitObject);
+        }
+
+        /// <summary>
+        /// Trims control points from the end of the slider path which are not required to reach the expected end of the slider.
+        /// </summary>
+        /// <param name="sliderPath">The slider path to trim control points of.</param>
+        private void trimExcessControlPoints(SliderPath sliderPath)
+        {
+            if (!sliderPath.ExpectedDistance.Value.HasValue)
+                return;
+
+            double[] segmentEnds = sliderPath.GetSegmentEnds().ToArray();
+            int segmentIndex = 0;
+
+            for (int i = 1; i < sliderPath.ControlPoints.Count - 1; i++)
+            {
+                if (!sliderPath.ControlPoints[i].Type.HasValue) continue;
+
+                if (Precision.AlmostBigger(segmentEnds[segmentIndex], 1, 1E-3))
+                {
+                    sliderPath.ControlPoints.RemoveRange(i + 1, sliderPath.ControlPoints.Count - i - 1);
+                    sliderPath.ControlPoints[^1].Type = null;
+                    break;
+                }
+
+                segmentIndex++;
+            }
+        }
+
+        /// <summary>
+        /// Finds the expected distance value for which the slider end is closest to the mouse position.
+        /// </summary>
+        private double findClosestPathDistance(MouseEvent e)
+        {
+            const double step1 = 10;
+            const double step2 = 0.1;
+            const double longer_distance_bias = 0.01;
+
+            var desiredPosition = ToLocalSpace(e.ScreenSpaceMousePosition) - HitObject.Position - lengthAdjustMouseOffset;
+
+            if (!fullPathCache.IsValid)
+                fullPathCache.Value = new SliderPath(HitObject.Path.ControlPoints.ToArray());
+
+            // Do a linear search to find the closest point on the path to the mouse position.
+            double bestValue = 0;
+            double minDistance = double.MaxValue;
+
+            for (double d = 0; d <= fullPathCache.Value.CalculatedDistance; d += step1)
+            {
+                double t = d / fullPathCache.Value.CalculatedDistance;
+                double dist = Vector2.Distance(fullPathCache.Value.PositionAt(t), desiredPosition) - d * longer_distance_bias;
+
+                if (dist >= minDistance) continue;
+
+                minDistance = dist;
+                bestValue = d;
+            }
+
+            // Do another linear search to fine-tune the result.
+            double maxValue = Math.Min(bestValue + step1, fullPathCache.Value.CalculatedDistance);
+
+            for (double d = bestValue - step1; d <= maxValue; d += step2)
+            {
+                double t = d / fullPathCache.Value.CalculatedDistance;
+                double dist = Vector2.Distance(fullPathCache.Value.PositionAt(t), desiredPosition) - d * longer_distance_bias;
+
+                if (dist >= minDistance) continue;
+
+                minDistance = dist;
+                bestValue = d;
+            }
+
+            return bestValue;
+        }
+
+        #endregion
 
         protected override bool OnDragStart(DragStartEvent e)
         {
@@ -255,9 +396,24 @@ protected override bool OnKeyDown(KeyDownEvent e)
                 return true;
             }
 
+            if (isAdjustingLength && e.ShiftPressed != adjustVelocityMomentary)
+            {
+                adjustVelocityMomentary = e.ShiftPressed;
+                adjustLength(desiredDistance, adjustVelocityMomentary);
+                return true;
+            }
+
             return false;
         }
 
+        protected override void OnKeyUp(KeyUpEvent e)
+        {
+            if (!IsSelected || !isAdjustingLength || e.ShiftPressed == adjustVelocityMomentary) return;
+
+            adjustVelocityMomentary = e.ShiftPressed;
+            adjustLength(desiredDistance, adjustVelocityMomentary);
+        }
+
         private PathControlPoint addControlPoint(Vector2 position)
         {
             position -= HitObject.Position;
@@ -326,6 +482,9 @@ private void removeControlPoints(List<PathControlPoint> toRemove)
 
         private void splitControlPoints(List<PathControlPoint> controlPointsToSplitAt)
         {
+            if (editorBeatmap == null)
+                return;
+
             // Arbitrary gap in milliseconds to put between split slider pieces
             const double split_gap = 100;
 
@@ -432,7 +591,7 @@ private void convertToStream()
             new OsuMenuItem("Add control point", MenuItemType.Standard, () =>
             {
                 changeHandler?.BeginChange();
-                addControlPoint(rightClickPosition);
+                addControlPoint(lastRightClickPosition);
                 changeHandler?.EndChange();
             }),
             new OsuMenuItem("Convert to stream", MenuItemType.Destructive, convertToStream),
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs
index f59be0e0e984..17d2dcd75cbb 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs
@@ -13,7 +13,7 @@
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 {
-    public partial class SpinnerPlacementBlueprint : PlacementBlueprint
+    public partial class SpinnerPlacementBlueprint : HitObjectPlacementBlueprint
     {
         public new Spinner HitObject => (Spinner)base.HitObject;
 
diff --git a/osu.Game.Rulesets.Osu/Edit/HitCircleCompositionTool.cs b/osu.Game.Rulesets.Osu/Edit/HitCircleCompositionTool.cs
index c41ae10b2e10..d3116ede30b3 100644
--- a/osu.Game.Rulesets.Osu/Edit/HitCircleCompositionTool.cs
+++ b/osu.Game.Rulesets.Osu/Edit/HitCircleCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
-    public class HitCircleCompositionTool : HitObjectCompositionTool
+    public class HitCircleCompositionTool : CompositionTool
     {
         public HitCircleCompositionTool()
             : base(nameof(HitCircle))
@@ -19,6 +19,6 @@ public HitCircleCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new HitCirclePlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new HitCirclePlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
index bbcf4fa2d4f1..2b5de8a5d813 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
@@ -41,7 +41,7 @@ public OsuHitObjectComposer(Ruleset ruleset)
         protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
             => new DrawableOsuEditorRuleset(ruleset, beatmap, mods);
 
-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
+        protected override IReadOnlyList<CompositionTool> CompositionTools => new CompositionTool[]
         {
             new HitCircleCompositionTool(),
             new SliderCompositionTool(),
@@ -54,11 +54,8 @@ protected override DrawableRuleset<OsuHitObject> CreateDrawableRuleset(Ruleset r
 
         protected override IEnumerable<TernaryButton> CreateTernaryButtons()
             => base.CreateTernaryButtons()
-                   .Concat(DistanceSnapProvider.CreateTernaryButtons())
-                   .Concat(new[]
-                   {
-                       new TernaryButton(rectangularGridSnapToggle, "Grid Snap", () => new SpriteIcon { Icon = OsuIcon.EditorGridSnap })
-                   });
+                   .Append(new TernaryButton(rectangularGridSnapToggle, "Grid Snap", () => new SpriteIcon { Icon = OsuIcon.EditorGridSnap }))
+                   .Concat(DistanceSnapProvider.CreateTernaryButtons());
 
         private BindableList<HitObject> selectedHitObjects;
 
@@ -109,6 +106,7 @@ private void load()
                     {
                         RotationHandler = BlueprintContainer.SelectionHandler.RotationHandler,
                         ScaleHandler = (OsuSelectionScaleHandler)BlueprintContainer.SelectionHandler.ScaleHandler,
+                        GridToolbox = OsuGridToolboxGroup,
                     },
                     new GenerateToolboxGroup(),
                     FreehandSliderToolboxGroup
@@ -371,6 +369,8 @@ private void handleToggleViaKey(KeyboardEvent key)
                 gridSnapMomentary = shiftPressed;
                 rectangularGridSnapToggle.Value = rectangularGridSnapToggle.Value == TernaryState.False ? TernaryState.True : TernaryState.False;
             }
+
+            DistanceSnapProvider.HandleToggleViaKey(key);
         }
 
         private DistanceSnapGrid createDistanceSnapGrid(IEnumerable<HitObject> selectedHitObjects)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index 2ca7664d5d59..bac0a5e2734b 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.UserInterface;
@@ -25,6 +26,9 @@ namespace osu.Game.Rulesets.Osu.Edit
 {
     public partial class OsuSelectionHandler : EditorSelectionHandler
     {
+        [Resolved]
+        private OsuGridToolboxGroup gridToolbox { get; set; } = null!;
+
         protected override void OnSelectionChanged()
         {
             base.OnSelectionChanged();
@@ -123,13 +127,43 @@ public override bool HandleFlip(Direction direction, bool flipOverOrigin)
         {
             var hitObjects = selectedMovableObjects;
 
-            var flipQuad = flipOverOrigin ? new Quad(0, 0, OsuPlayfield.BASE_SIZE.X, OsuPlayfield.BASE_SIZE.Y) : GeometryUtils.GetSurroundingQuad(hitObjects);
+            // If we're flipping over the origin, we take the grid origin position from the grid toolbox.
+            var flipQuad = flipOverOrigin ? new Quad(gridToolbox.StartPositionX.Value, gridToolbox.StartPositionY.Value, 0, 0) : GeometryUtils.GetSurroundingQuad(hitObjects);
+            Vector2 flipAxis = direction == Direction.Vertical ? Vector2.UnitY : Vector2.UnitX;
+
+            if (flipOverOrigin)
+            {
+                // If we're flipping over the origin, we take one of the axes of the grid.
+                // Take the axis closest to the direction we want to flip over.
+                switch (gridToolbox.GridType.Value)
+                {
+                    case PositionSnapGridType.Square:
+                        flipAxis = GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 360 + 45) % 90 - 45));
+                        flipAxis = direction == Direction.Vertical ? flipAxis.PerpendicularLeft : flipAxis;
+                        break;
+
+                    case PositionSnapGridType.Triangle:
+                        // Hex grid has 3 axes, so you can not directly flip over one of the axes,
+                        // however it's still possible to achieve that flip by combining multiple flips over the other axes.
+                        // Angle degree range for vertical = (-120, -60]
+                        // Angle degree range for horizontal = [-30, 30)
+                        flipAxis = direction == Direction.Vertical
+                            ? GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 360 + 30) % 60 + 60))
+                            : GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 360) % 60 - 30));
+                        break;
+                }
+            }
+
+            var controlPointFlipQuad = new Quad();
 
             bool didFlip = false;
 
             foreach (var h in hitObjects)
             {
-                var flippedPosition = GeometryUtils.GetFlippedPosition(direction, flipQuad, h.Position);
+                var flippedPosition = GeometryUtils.GetFlippedPosition(flipAxis, flipQuad, h.Position);
+
+                // Clamp the flipped position inside the playfield bounds, because the flipped position might be outside the playfield bounds if the origin is not centered.
+                flippedPosition = Vector2.Clamp(flippedPosition, Vector2.Zero, OsuPlayfield.BASE_SIZE);
 
                 if (!Precision.AlmostEquals(flippedPosition, h.Position))
                 {
@@ -142,12 +176,7 @@ public override bool HandleFlip(Direction direction, bool flipOverOrigin)
                     didFlip = true;
 
                     foreach (var cp in slider.Path.ControlPoints)
-                    {
-                        cp.Position = new Vector2(
-                            (direction == Direction.Horizontal ? -1 : 1) * cp.Position.X,
-                            (direction == Direction.Vertical ? -1 : 1) * cp.Position.Y
-                        );
-                    }
+                        cp.Position = GeometryUtils.GetFlippedPosition(flipAxis, controlPointFlipQuad, cp.Position);
                 }
             }
 
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs
index 62a39d3702c1..44d1543ae461 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs
@@ -47,7 +47,6 @@ private void updateState()
 
         private OsuHitObject[]? objectsInRotation;
 
-        private Vector2? defaultOrigin;
         private Dictionary<OsuHitObject, Vector2>? originalPositions;
         private Dictionary<IHasPath, Vector2[]>? originalPathControlPointPositions;
 
@@ -61,7 +60,7 @@ public override void Begin()
             changeHandler?.BeginChange();
 
             objectsInRotation = selectedMovableObjects.ToArray();
-            defaultOrigin = GeometryUtils.GetSurroundingQuad(objectsInRotation).Centre;
+            DefaultOrigin = GeometryUtils.MinimumEnclosingCircle(objectsInRotation).Item1;
             originalPositions = objectsInRotation.ToDictionary(obj => obj, obj => obj.Position);
             originalPathControlPointPositions = objectsInRotation.OfType<IHasPath>().ToDictionary(
                 obj => obj,
@@ -73,9 +72,9 @@ public override void Update(float rotation, Vector2? origin = null)
             if (!OperationInProgress.Value)
                 throw new InvalidOperationException($"Cannot {nameof(Update)} a rotate operation without calling {nameof(Begin)} first!");
 
-            Debug.Assert(objectsInRotation != null && originalPositions != null && originalPathControlPointPositions != null && defaultOrigin != null);
+            Debug.Assert(objectsInRotation != null && originalPositions != null && originalPathControlPointPositions != null && DefaultOrigin != null);
 
-            Vector2 actualOrigin = origin ?? defaultOrigin.Value;
+            Vector2 actualOrigin = origin ?? DefaultOrigin.Value;
 
             foreach (var ho in objectsInRotation)
             {
@@ -103,7 +102,7 @@ public override void Commit()
             objectsInRotation = null;
             originalPositions = null;
             originalPathControlPointPositions = null;
-            defaultOrigin = null;
+            DefaultOrigin = null;
         }
 
         private IEnumerable<OsuHitObject> selectedMovableObjects => selectedItems.Cast<OsuHitObject>()
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index f4fd48f1837d..fc85865dd29d 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -69,6 +69,7 @@ private void updateState()
 
         private Dictionary<OsuHitObject, OriginalHitObjectState>? objectsInScale;
         private Vector2? defaultOrigin;
+        private List<Vector2>? originalConvexHull;
 
         public override void Begin()
         {
@@ -83,10 +84,13 @@ public override void Begin()
             OriginalSurroundingQuad = objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider
                 ? GeometryUtils.GetSurroundingQuad(slider.Path.ControlPoints.Select(p => slider.Position + p.Position))
                 : GeometryUtils.GetSurroundingQuad(objectsInScale.Keys);
-            defaultOrigin = OriginalSurroundingQuad.Value.Centre;
+            originalConvexHull = objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider2
+                ? GeometryUtils.GetConvexHull(slider2.Path.ControlPoints.Select(p => slider2.Position + p.Position))
+                : GeometryUtils.GetConvexHull(objectsInScale.Keys);
+            defaultOrigin = GeometryUtils.MinimumEnclosingCircle(originalConvexHull).Item1;
         }
 
-        public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+        public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
         {
             if (!OperationInProgress.Value)
                 throw new InvalidOperationException($"Cannot {nameof(Update)} a scale operation without calling {nameof(Begin)} first!");
@@ -94,23 +98,22 @@ public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAx
             Debug.Assert(objectsInScale != null && defaultOrigin != null && OriginalSurroundingQuad != null);
 
             Vector2 actualOrigin = origin ?? defaultOrigin.Value;
+            scale = clampScaleToAdjustAxis(scale, adjustAxis);
 
             // for the time being, allow resizing of slider paths only if the slider is
             // the only hit object selected. with a group selection, it's likely the user
             // is not looking to change the duration of the slider but expand the whole pattern.
             if (objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider)
             {
-                var originalInfo = objectsInScale[slider];
-                Debug.Assert(originalInfo.PathControlPointPositions != null && originalInfo.PathControlPointTypes != null);
-                scaleSlider(slider, scale, originalInfo.PathControlPointPositions, originalInfo.PathControlPointTypes);
+                scaleSlider(slider, scale, actualOrigin, objectsInScale[slider], axisRotation);
             }
             else
             {
-                scale = ClampScaleToPlayfieldBounds(scale, actualOrigin);
+                scale = ClampScaleToPlayfieldBounds(scale, actualOrigin, adjustAxis, axisRotation);
 
                 foreach (var (ho, originalState) in objectsInScale)
                 {
-                    ho.Position = GeometryUtils.GetScaledPosition(scale, actualOrigin, originalState.Position);
+                    ho.Position = GeometryUtils.GetScaledPosition(scale, actualOrigin, originalState.Position, axisRotation);
                 }
             }
 
@@ -134,21 +137,45 @@ public override void Commit()
         private IEnumerable<OsuHitObject> selectedMovableObjects => selectedItems.Cast<OsuHitObject>()
                                                                                  .Where(h => h is not Spinner);
 
-        private void scaleSlider(Slider slider, Vector2 scale, Vector2[] originalPathPositions, PathType?[] originalPathTypes)
+        private Vector2 clampScaleToAdjustAxis(Vector2 scale, Axes adjustAxis)
         {
+            switch (adjustAxis)
+            {
+                case Axes.Y:
+                    scale.X = 1;
+                    break;
+
+                case Axes.X:
+                    scale.Y = 1;
+                    break;
+
+                case Axes.None:
+                    scale = Vector2.One;
+                    break;
+            }
+
+            return scale;
+        }
+
+        private void scaleSlider(Slider slider, Vector2 scale, Vector2 origin, OriginalHitObjectState originalInfo, float axisRotation = 0)
+        {
+            Debug.Assert(originalInfo.PathControlPointPositions != null && originalInfo.PathControlPointTypes != null);
+
             scale = Vector2.ComponentMax(scale, new Vector2(Precision.FLOAT_EPSILON));
 
             // Maintain the path types in case they were defaulted to bezier at some point during scaling
             for (int i = 0; i < slider.Path.ControlPoints.Count; i++)
             {
-                slider.Path.ControlPoints[i].Position = originalPathPositions[i] * scale;
-                slider.Path.ControlPoints[i].Type = originalPathTypes[i];
+                slider.Path.ControlPoints[i].Position = GeometryUtils.GetScaledPosition(scale, Vector2.Zero, originalInfo.PathControlPointPositions[i], axisRotation);
+                slider.Path.ControlPoints[i].Type = originalInfo.PathControlPointTypes[i];
             }
 
             // Snap the slider's length to the current beat divisor
             // to calculate the final resulting duration / bounding box before the final checks.
             slider.SnapTo(snapProvider);
 
+            slider.Position = GeometryUtils.GetScaledPosition(scale, origin, originalInfo.Position, axisRotation);
+
             //if sliderhead or sliderend end up outside playfield, revert scaling.
             Quad scaledQuad = GeometryUtils.GetSurroundingQuad(new OsuHitObject[] { slider });
             (bool xInBounds, bool yInBounds) = isQuadInBounds(scaledQuad);
@@ -157,7 +184,9 @@ private void scaleSlider(Slider slider, Vector2 scale, Vector2[] originalPathPos
                 return;
 
             for (int i = 0; i < slider.Path.ControlPoints.Count; i++)
-                slider.Path.ControlPoints[i].Position = originalPathPositions[i];
+                slider.Path.ControlPoints[i].Position = originalInfo.PathControlPointPositions[i];
+
+            slider.Position = originalInfo.Position;
 
             // Snap the slider's length again to undo the potentially-invalid length applied by the previous snap.
             slider.SnapTo(snapProvider);
@@ -176,11 +205,13 @@ private void scaleSlider(Slider slider, Vector2 scale, Vector2[] originalPathPos
         /// </summary>
         /// <param name="origin">The origin from which the scale operation is performed</param>
         /// <param name="scale">The scale to be clamped</param>
+        /// <param name="adjustAxis">The axes to adjust the scale in.</param>
+        /// <param name="axisRotation">The rotation of the axes in degrees</param>
         /// <returns>The clamped scale vector</returns>
-        public Vector2 ClampScaleToPlayfieldBounds(Vector2 scale, Vector2? origin = null)
+        public Vector2 ClampScaleToPlayfieldBounds(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
         {
             //todo: this is not always correct for selections involving sliders. This approximation assumes each point is scaled independently, but sliderends move with the sliderhead.
-            if (objectsInScale == null)
+            if (objectsInScale == null || adjustAxis == Axes.None)
                 return scale;
 
             Debug.Assert(defaultOrigin != null && OriginalSurroundingQuad != null);
@@ -188,24 +219,60 @@ public Vector2 ClampScaleToPlayfieldBounds(Vector2 scale, Vector2? origin = null
             if (objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider)
                 origin = slider.Position;
 
+            float cos = MathF.Cos(float.DegreesToRadians(-axisRotation));
+            float sin = MathF.Sin(float.DegreesToRadians(-axisRotation));
+            scale = clampScaleToAdjustAxis(scale, adjustAxis);
             Vector2 actualOrigin = origin ?? defaultOrigin.Value;
-            var selectionQuad = OriginalSurroundingQuad.Value;
-
-            var tl1 = Vector2.Divide(-actualOrigin, selectionQuad.TopLeft - actualOrigin);
-            var tl2 = Vector2.Divide(OsuPlayfield.BASE_SIZE - actualOrigin, selectionQuad.TopLeft - actualOrigin);
-            var br1 = Vector2.Divide(-actualOrigin, selectionQuad.BottomRight - actualOrigin);
-            var br2 = Vector2.Divide(OsuPlayfield.BASE_SIZE - actualOrigin, selectionQuad.BottomRight - actualOrigin);
-
-            if (!Precision.AlmostEquals(selectionQuad.TopLeft.X - actualOrigin.X, 0))
-                scale.X = selectionQuad.TopLeft.X - actualOrigin.X < 0 ? MathHelper.Clamp(scale.X, tl2.X, tl1.X) : MathHelper.Clamp(scale.X, tl1.X, tl2.X);
-            if (!Precision.AlmostEquals(selectionQuad.TopLeft.Y - actualOrigin.Y, 0))
-                scale.Y = selectionQuad.TopLeft.Y - actualOrigin.Y < 0 ? MathHelper.Clamp(scale.Y, tl2.Y, tl1.Y) : MathHelper.Clamp(scale.Y, tl1.Y, tl2.Y);
-            if (!Precision.AlmostEquals(selectionQuad.BottomRight.X - actualOrigin.X, 0))
-                scale.X = selectionQuad.BottomRight.X - actualOrigin.X < 0 ? MathHelper.Clamp(scale.X, br2.X, br1.X) : MathHelper.Clamp(scale.X, br1.X, br2.X);
-            if (!Precision.AlmostEquals(selectionQuad.BottomRight.Y - actualOrigin.Y, 0))
-                scale.Y = selectionQuad.BottomRight.Y - actualOrigin.Y < 0 ? MathHelper.Clamp(scale.Y, br2.Y, br1.Y) : MathHelper.Clamp(scale.Y, br1.Y, br2.Y);
+            IEnumerable<Vector2> points;
+
+            if (axisRotation == 0)
+            {
+                var selectionQuad = OriginalSurroundingQuad.Value;
+                points = new[]
+                {
+                    selectionQuad.TopLeft,
+                    selectionQuad.TopRight,
+                    selectionQuad.BottomLeft,
+                    selectionQuad.BottomRight
+                };
+            }
+            else
+                points = originalConvexHull!;
+
+            foreach (var point in points)
+            {
+                scale = clampToBound(scale, point, Vector2.Zero);
+                scale = clampToBound(scale, point, OsuPlayfield.BASE_SIZE);
+            }
 
             return Vector2.ComponentMax(scale, new Vector2(Precision.FLOAT_EPSILON));
+
+            float minPositiveComponent(Vector2 v) => MathF.Min(v.X < 0 ? float.PositiveInfinity : v.X, v.Y < 0 ? float.PositiveInfinity : v.Y);
+
+            Vector2 clampToBound(Vector2 s, Vector2 p, Vector2 bound)
+            {
+                p -= actualOrigin;
+                bound -= actualOrigin;
+                var a = new Vector2(cos * cos * p.X - sin * cos * p.Y, -sin * cos * p.X + sin * sin * p.Y);
+                var b = new Vector2(sin * sin * p.X + sin * cos * p.Y, sin * cos * p.X + cos * cos * p.Y);
+
+                switch (adjustAxis)
+                {
+                    case Axes.X:
+                        s.X = MathF.Min(scale.X, minPositiveComponent(Vector2.Divide(bound - b, a)));
+                        break;
+
+                    case Axes.Y:
+                        s.Y = MathF.Min(scale.Y, minPositiveComponent(Vector2.Divide(bound - a, b)));
+                        break;
+
+                    case Axes.Both:
+                        s = Vector2.ComponentMin(s, s * minPositiveComponent(Vector2.Divide(bound, a * s.X + b * s.Y)));
+                        break;
+                }
+
+                return s;
+            }
         }
 
         private void moveSelectionInBounds()
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
index 3a0d3c476316..352debf5004e 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.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.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -19,16 +20,19 @@ public partial class PreciseRotationPopover : OsuPopover
     {
         private readonly SelectionRotationHandler rotationHandler;
 
-        private readonly Bindable<PreciseRotationInfo> rotationInfo = new Bindable<PreciseRotationInfo>(new PreciseRotationInfo(0, RotationOrigin.PlayfieldCentre));
+        private readonly OsuGridToolboxGroup gridToolbox;
+
+        private readonly Bindable<PreciseRotationInfo> rotationInfo = new Bindable<PreciseRotationInfo>(new PreciseRotationInfo(0, RotationOrigin.GridCentre));
 
         private SliderWithTextBoxInput<float> angleInput = null!;
         private EditorRadioButtonCollection rotationOrigin = null!;
 
         private RadioButton selectionCentreButton = null!;
 
-        public PreciseRotationPopover(SelectionRotationHandler rotationHandler)
+        public PreciseRotationPopover(SelectionRotationHandler rotationHandler, OsuGridToolboxGroup gridToolbox)
         {
             this.rotationHandler = rotationHandler;
+            this.gridToolbox = gridToolbox;
 
             AllowableAnchors = new[] { Anchor.CentreLeft, Anchor.CentreRight };
         }
@@ -58,6 +62,9 @@ private void load()
                         RelativeSizeAxes = Axes.X,
                         Items = new[]
                         {
+                            new RadioButton("Grid centre",
+                                () => rotationInfo.Value = rotationInfo.Value with { Origin = RotationOrigin.GridCentre },
+                                () => new SpriteIcon { Icon = FontAwesome.Regular.PlusSquare }),
                             new RadioButton("Playfield centre",
                                 () => rotationInfo.Value = rotationInfo.Value with { Origin = RotationOrigin.PlayfieldCentre },
                                 () => new SpriteIcon { Icon = FontAwesome.Regular.Square }),
@@ -93,10 +100,19 @@ protected override void LoadComplete()
 
             rotationInfo.BindValueChanged(rotation =>
             {
-                rotationHandler.Update(rotation.NewValue.Degrees, rotation.NewValue.Origin == RotationOrigin.PlayfieldCentre ? OsuPlayfield.BASE_SIZE / 2 : null);
+                rotationHandler.Update(rotation.NewValue.Degrees, getOriginPosition(rotation.NewValue));
             });
         }
 
+        private Vector2? getOriginPosition(PreciseRotationInfo rotation) =>
+            rotation.Origin switch
+            {
+                RotationOrigin.GridCentre => gridToolbox.StartPosition.Value,
+                RotationOrigin.PlayfieldCentre => OsuPlayfield.BASE_SIZE / 2,
+                RotationOrigin.SelectionCentre => null,
+                _ => throw new ArgumentOutOfRangeException(nameof(rotation))
+            };
+
         protected override void PopIn()
         {
             base.PopIn();
@@ -114,6 +130,7 @@ protected override void PopOut()
 
     public enum RotationOrigin
     {
+        GridCentre,
         PlayfieldCentre,
         SelectionCentre
     }
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
index a299eebbce30..33b0c1418507 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
@@ -10,7 +10,10 @@
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Components.RadioButtons;
 using osuTK;
 
@@ -20,28 +23,36 @@ public partial class PreciseScalePopover : OsuPopover
     {
         private readonly OsuSelectionScaleHandler scaleHandler;
 
-        private readonly Bindable<PreciseScaleInfo> scaleInfo = new Bindable<PreciseScaleInfo>(new PreciseScaleInfo(1, ScaleOrigin.PlayfieldCentre, true, true));
+        private readonly OsuGridToolboxGroup gridToolbox;
+
+        private readonly Bindable<PreciseScaleInfo> scaleInfo = new Bindable<PreciseScaleInfo>(new PreciseScaleInfo(1, ScaleOrigin.GridCentre, true, true));
 
         private SliderWithTextBoxInput<float> scaleInput = null!;
         private BindableNumber<float> scaleInputBindable = null!;
         private EditorRadioButtonCollection scaleOrigin = null!;
 
+        private RadioButton gridCentreButton = null!;
         private RadioButton playfieldCentreButton = null!;
         private RadioButton selectionCentreButton = null!;
 
         private OsuCheckbox xCheckBox = null!;
         private OsuCheckbox yCheckBox = null!;
 
-        public PreciseScalePopover(OsuSelectionScaleHandler scaleHandler)
+        private BindableList<HitObject> selectedItems { get; } = new BindableList<HitObject>();
+
+        public PreciseScalePopover(OsuSelectionScaleHandler scaleHandler, OsuGridToolboxGroup gridToolbox)
         {
             this.scaleHandler = scaleHandler;
+            this.gridToolbox = gridToolbox;
 
             AllowableAnchors = new[] { Anchor.CentreLeft, Anchor.CentreRight };
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(EditorBeatmap editorBeatmap)
         {
+            selectedItems.BindTo(editorBeatmap.SelectedHitObjects);
+
             Child = new FillFlowContainer
             {
                 Width = 220,
@@ -66,6 +77,9 @@ private void load()
                         RelativeSizeAxes = Axes.X,
                         Items = new[]
                         {
+                            gridCentreButton = new RadioButton("Grid centre",
+                                () => setOrigin(ScaleOrigin.GridCentre),
+                                () => new SpriteIcon { Icon = FontAwesome.Regular.PlusSquare }),
                             playfieldCentreButton = new RadioButton("Playfield centre",
                                 () => setOrigin(ScaleOrigin.PlayfieldCentre),
                                 () => new SpriteIcon { Icon = FontAwesome.Regular.Square }),
@@ -97,6 +111,10 @@ private void load()
                     },
                 }
             };
+            gridCentreButton.Selected.DisabledChanged += isDisabled =>
+            {
+                gridCentreButton.TooltipText = isDisabled ? "The current selection cannot be scaled relative to grid centre." : string.Empty;
+            };
             playfieldCentreButton.Selected.DisabledChanged += isDisabled =>
             {
                 playfieldCentreButton.TooltipText = isDisabled ? "The current selection cannot be scaled relative to playfield centre." : string.Empty;
@@ -123,19 +141,20 @@ protected override void LoadComplete()
 
             selectionCentreButton.Selected.Disabled = !(scaleHandler.CanScaleX.Value || scaleHandler.CanScaleY.Value);
             playfieldCentreButton.Selected.Disabled = scaleHandler.IsScalingSlider.Value && !selectionCentreButton.Selected.Disabled;
+            gridCentreButton.Selected.Disabled = playfieldCentreButton.Selected.Disabled;
 
             scaleOrigin.Items.First(b => !b.Selected.Disabled).Select();
 
             scaleInfo.BindValueChanged(scale =>
             {
-                var newScale = new Vector2(scale.NewValue.XAxis ? scale.NewValue.Scale : 1, scale.NewValue.YAxis ? scale.NewValue.Scale : 1);
-                scaleHandler.Update(newScale, getOriginPosition(scale.NewValue));
+                var newScale = new Vector2(scale.NewValue.Scale, scale.NewValue.Scale);
+                scaleHandler.Update(newScale, getOriginPosition(scale.NewValue), getAdjustAxis(scale.NewValue), getRotation(scale.NewValue));
             });
         }
 
         private void updateAxisCheckBoxesEnabled()
         {
-            if (scaleInfo.Value.Origin == ScaleOrigin.PlayfieldCentre)
+            if (scaleInfo.Value.Origin != ScaleOrigin.SelectionCentre)
             {
                 toggleAxisAvailable(xCheckBox.Current, true);
                 toggleAxisAvailable(yCheckBox.Current, true);
@@ -162,7 +181,7 @@ private void updateMaxScale()
                 return;
 
             const float max_scale = 10;
-            var scale = scaleHandler.ClampScaleToPlayfieldBounds(new Vector2(max_scale), getOriginPosition(scaleInfo.Value));
+            var scale = scaleHandler.ClampScaleToPlayfieldBounds(new Vector2(max_scale), getOriginPosition(scaleInfo.Value), getAdjustAxis(scaleInfo.Value), getRotation(scaleInfo.Value));
 
             if (!scaleInfo.Value.XAxis)
                 scale.X = max_scale;
@@ -179,7 +198,30 @@ private void setOrigin(ScaleOrigin origin)
             updateAxisCheckBoxesEnabled();
         }
 
-        private Vector2? getOriginPosition(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.PlayfieldCentre ? OsuPlayfield.BASE_SIZE / 2 : null;
+        private Vector2? getOriginPosition(PreciseScaleInfo scale)
+        {
+            switch (scale.Origin)
+            {
+                case ScaleOrigin.GridCentre:
+                    return gridToolbox.StartPosition.Value;
+
+                case ScaleOrigin.PlayfieldCentre:
+                    return OsuPlayfield.BASE_SIZE / 2;
+
+                case ScaleOrigin.SelectionCentre:
+                    if (selectedItems.Count == 1 && selectedItems.First() is Slider slider)
+                        return slider.Position;
+
+                    return null;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(scale));
+            }
+        }
+
+        private Axes getAdjustAxis(PreciseScaleInfo scale) => scale.XAxis ? scale.YAxis ? Axes.Both : Axes.X : Axes.Y;
+
+        private float getRotation(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.GridCentre ? gridToolbox.GridLinesRotation.Value : 0;
 
         private void setAxis(bool x, bool y)
         {
@@ -204,6 +246,7 @@ protected override void PopOut()
 
     public enum ScaleOrigin
     {
+        GridCentre,
         PlayfieldCentre,
         SelectionCentre
     }
diff --git a/osu.Game.Rulesets.Osu/Edit/SliderCompositionTool.cs b/osu.Game.Rulesets.Osu/Edit/SliderCompositionTool.cs
index 617cc1c19b3d..d697a2ebe6c5 100644
--- a/osu.Game.Rulesets.Osu/Edit/SliderCompositionTool.cs
+++ b/osu.Game.Rulesets.Osu/Edit/SliderCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
-    public class SliderCompositionTool : HitObjectCompositionTool
+    public class SliderCompositionTool : CompositionTool
     {
         public SliderCompositionTool()
             : base(nameof(Slider))
@@ -26,6 +26,6 @@ Right click to finish.
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new SliderPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new SliderPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Edit/SpinnerCompositionTool.cs b/osu.Game.Rulesets.Osu/Edit/SpinnerCompositionTool.cs
index c8160617c924..de1506e4a948 100644
--- a/osu.Game.Rulesets.Osu/Edit/SpinnerCompositionTool.cs
+++ b/osu.Game.Rulesets.Osu/Edit/SpinnerCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
-    public class SpinnerCompositionTool : HitObjectCompositionTool
+    public class SpinnerCompositionTool : CompositionTool
     {
         public SpinnerCompositionTool()
             : base(nameof(Spinner))
@@ -19,6 +19,6 @@ public SpinnerCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new SpinnerPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new SpinnerPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
index a3547d45e5cf..a41412cbe32e 100644
--- a/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
@@ -27,6 +27,8 @@ public partial class TransformToolboxGroup : EditorToolboxGroup, IKeyBindingHand
         public SelectionRotationHandler RotationHandler { get; init; } = null!;
         public OsuSelectionScaleHandler ScaleHandler { get; init; } = null!;
 
+        public OsuGridToolboxGroup GridToolbox { get; init; } = null!;
+
         public TransformToolboxGroup()
             : base("transform")
         {
@@ -44,10 +46,10 @@ private void load()
                 {
                     rotateButton = new EditorToolButton("Rotate",
                         () => new SpriteIcon { Icon = FontAwesome.Solid.Undo },
-                        () => new PreciseRotationPopover(RotationHandler)),
+                        () => new PreciseRotationPopover(RotationHandler, GridToolbox)),
                     scaleButton = new EditorToolButton("Scale",
                         () => new SpriteIcon { Icon = FontAwesome.Solid.ArrowsAlt },
-                        () => new PreciseScalePopover(ScaleHandler))
+                        () => new PreciseScalePopover(ScaleHandler, GridToolbox))
                 }
             };
         }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
index 5f5deca1ba83..b3a68ec92d49 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
@@ -91,20 +91,35 @@ protected override void UpdateInitialTransforms()
                     drawableObjectPiece.ApplyCustomUpdateState -= applyDimToDrawableHitObject;
                     drawableObjectPiece.ApplyCustomUpdateState += applyDimToDrawableHitObject;
                 }
-                else
-                    applyDim(piece);
-            }
 
-            void applyDim(Drawable piece)
-            {
-                piece.FadeColour(new Color4(195, 195, 195, 255));
-                using (piece.BeginDelayedSequence(InitialLifetimeOffset - OsuHitWindows.MISS_WINDOW))
-                    piece.FadeColour(Color4.White, 100);
+                // but at the end apply the transforms now regardless of whether this is a DHO or not.
+                // the above is just to ensure they don't get overwritten later.
+                applyDim(piece);
             }
+        }
+
+        protected override void ClearNestedHitObjects()
+        {
+            base.ClearNestedHitObjects();
+
+            // any dimmable pieces that are DHOs will be pooled separately.
+            // `applyDimToDrawableHitObject` is a closure that implicitly captures `this`,
+            // and because of separate pooling of parent and child objects, there is no guarantee that the pieces will be associated with `this` again on re-use.
+            // therefore, clean up the subscription here to avoid crosstalk.
+            // not doing so can result in the callback attempting to read things from `this` when it is in a completely bogus state (not in use or similar).
+            foreach (var piece in DimmablePieces.OfType<DrawableHitObject>())
+                piece.ApplyCustomUpdateState -= applyDimToDrawableHitObject;
+        }
 
-            void applyDimToDrawableHitObject(DrawableHitObject dho, ArmedState _) => applyDim(dho);
+        private void applyDim(Drawable piece)
+        {
+            piece.FadeColour(new Color4(195, 195, 195, 255));
+            using (piece.BeginDelayedSequence(InitialLifetimeOffset - OsuHitWindows.MISS_WINDOW))
+                piece.FadeColour(Color4.White, 100);
         }
 
+        private void applyDimToDrawableHitObject(DrawableHitObject dho, ArmedState _) => applyDim(dho);
+
         protected sealed override double InitialLifetimeOffset => HitObject.TimePreempt;
 
         private OsuInputManager osuActionInputManager;
diff --git a/osu.Game.Rulesets.Osu/Objects/Slider.cs b/osu.Game.Rulesets.Osu/Objects/Slider.cs
index f542b7b5af46..2b3bb18844f3 100644
--- a/osu.Game.Rulesets.Osu/Objects/Slider.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Slider.cs
@@ -9,6 +9,7 @@
 using osu.Game.Rulesets.Objects;
 using System.Linq;
 using System.Threading;
+using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Framework.Bindables;
 using osu.Framework.Caching;
@@ -162,6 +163,10 @@ public double SliderVelocityMultiplier
         [JsonIgnore]
         public SliderTailCircle TailCircle { get; protected set; }
 
+        [JsonIgnore]
+        [CanBeNull]
+        public SliderRepeat LastRepeat { get; protected set; }
+
         public Slider()
         {
             SamplesBindable.CollectionChanged += (_, _) => UpdateNestedSamples();
@@ -225,7 +230,7 @@ protected override void CreateNestedHitObjects(CancellationToken cancellationTok
                         break;
 
                     case SliderEventType.Repeat:
-                        AddNested(new SliderRepeat(this)
+                        AddNested(LastRepeat = new SliderRepeat(this)
                         {
                             RepeatIndex = e.SpanIndex,
                             StartTime = StartTime + (e.SpanIndex + 1) * SpanDuration,
@@ -248,6 +253,9 @@ private void updateNestedPositions()
 
             if (TailCircle != null)
                 TailCircle.Position = EndPosition;
+
+            if (LastRepeat != null)
+                LastRepeat.Position = RepeatCount % 2 == 0 ? Position : Position + Path.PositionAt(1);
         }
 
         protected void UpdateNestedSamples()
diff --git a/osu.Game.Rulesets.Osu/OsuRuleset.cs b/osu.Game.Rulesets.Osu/OsuRuleset.cs
index 7042ad0cd440..be48ef9acc47 100644
--- a/osu.Game.Rulesets.Osu/OsuRuleset.cs
+++ b/osu.Game.Rulesets.Osu/OsuRuleset.cs
@@ -359,5 +359,7 @@ public override BeatmapDifficulty GetRateAdjustedDisplayDifficulty(IBeatmapDiffi
 
             return adjustedDifficulty;
         }
+
+        public override bool EditorShowScrollSpeed => false;
     }
 }
diff --git a/osu.Game.Rulesets.Osu/OsuSkinComponentLookup.cs b/osu.Game.Rulesets.Osu/OsuSkinComponentLookup.cs
index 3b3653e1ba1c..86a68c799f51 100644
--- a/osu.Game.Rulesets.Osu/OsuSkinComponentLookup.cs
+++ b/osu.Game.Rulesets.Osu/OsuSkinComponentLookup.cs
@@ -5,7 +5,7 @@
 
 namespace osu.Game.Rulesets.Osu
 {
-    public class OsuSkinComponentLookup : GameplaySkinComponentLookup<OsuSkinComponents>
+    public class OsuSkinComponentLookup : SkinComponentLookup<OsuSkinComponents>
     {
         public OsuSkinComponentLookup(OsuSkinComponents component)
             : base(component)
diff --git a/osu.Game.Rulesets.Osu/Skinning/Argon/OsuArgonSkinTransformer.cs b/osu.Game.Rulesets.Osu/Skinning/Argon/OsuArgonSkinTransformer.cs
index ec63e1194d3b..9f6f65c2068d 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Argon/OsuArgonSkinTransformer.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Argon/OsuArgonSkinTransformer.cs
@@ -18,7 +18,7 @@ public OsuArgonSkinTransformer(ISkin skin)
         {
             switch (lookup)
             {
-                case GameplaySkinComponentLookup<HitResult> resultComponent:
+                case SkinComponentLookup<HitResult> resultComponent:
                     HitResult result = resultComponent.Component;
 
                     // This should eventually be moved to a skin setting, when supported.
diff --git a/osu.Game.Rulesets.Osu/Skinning/Default/OsuTrianglesSkinTransformer.cs b/osu.Game.Rulesets.Osu/Skinning/Default/OsuTrianglesSkinTransformer.cs
index 7a4c768aa25f..ef8cb12286e9 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Default/OsuTrianglesSkinTransformer.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Default/OsuTrianglesSkinTransformer.cs
@@ -18,7 +18,7 @@ public OsuTrianglesSkinTransformer(ISkin skin)
         {
             switch (lookup)
             {
-                case GameplaySkinComponentLookup<HitResult> resultComponent:
+                case SkinComponentLookup<HitResult> resultComponent:
                     HitResult result = resultComponent.Component;
 
                     switch (result)
diff --git a/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs b/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs
index 491eb02e2619..636a9ecb21b1 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs
@@ -44,23 +44,19 @@ public OsuLegacySkinTransformer(ISkin skin)
         {
             switch (lookup)
             {
-                case SkinComponentsContainerLookup containerLookup:
+                case GlobalSkinnableContainerLookup containerLookup:
                     // Only handle per ruleset defaults here.
                     if (containerLookup.Ruleset == null)
                         return base.GetDrawableComponent(lookup);
 
-                    // Skin has configuration.
-                    if (base.GetDrawableComponent(lookup) is UserConfiguredLayoutContainer d)
-                        return d;
-
                     // we don't have enough assets to display these components (this is especially the case on a "beatmap" skin).
                     if (!IsProvidingLegacyResources)
                         return null;
 
                     // Our own ruleset components default.
-                    switch (containerLookup.Target)
+                    switch (containerLookup.Lookup)
                     {
-                        case SkinComponentsContainerLookup.TargetArea.MainHUDComponents:
+                        case GlobalSkinnableContainers.MainHUDComponents:
                             return new DefaultSkinComponentsContainer(container =>
                             {
                                 var keyCounter = container.OfType<LegacyKeyCounterDisplay>().FirstOrDefault();
@@ -69,10 +65,8 @@ public OsuLegacySkinTransformer(ISkin skin)
                                 {
                                     // set the anchor to top right so that it won't squash to the return button to the top
                                     keyCounter.Anchor = Anchor.CentreRight;
-                                    keyCounter.Origin = Anchor.CentreRight;
-                                    keyCounter.X = 0;
-                                    // 340px is the default height inherit from stable
-                                    keyCounter.Y = container.ToLocalSpace(new Vector2(0, container.ScreenSpaceDrawQuad.Centre.Y - 340f)).Y;
+                                    keyCounter.Origin = Anchor.TopRight;
+                                    keyCounter.Position = new Vector2(0, -40) * 1.6f;
                                 }
 
                                 var combo = container.OfType<LegacyDefaultComboCounter>().FirstOrDefault();
diff --git a/osu.Game.Rulesets.Osu/UI/Cursor/CursorTrail.cs b/osu.Game.Rulesets.Osu/UI/Cursor/CursorTrail.cs
index 6452444fedf1..a4bccb0affc4 100644
--- a/osu.Game.Rulesets.Osu/UI/Cursor/CursorTrail.cs
+++ b/osu.Game.Rulesets.Osu/UI/Cursor/CursorTrail.cs
@@ -38,6 +38,11 @@ public partial class CursorTrail : Drawable, IRequireHighFrequencyMousePosition
         private double timeOffset;
         private float time;
 
+        /// <summary>
+        /// The scale used on creation of a new trail part.
+        /// </summary>
+        public Vector2 NewPartScale = Vector2.One;
+
         private Anchor trailOrigin = Anchor.Centre;
 
         protected Anchor TrailOrigin
@@ -188,6 +193,7 @@ private void addPart(Vector2 localSpacePosition)
         {
             parts[currentIndex].Position = localSpacePosition;
             parts[currentIndex].Time = time + 1;
+            parts[currentIndex].Scale = NewPartScale;
             ++parts[currentIndex].InvalidationID;
 
             currentIndex = (currentIndex + 1) % max_sprites;
@@ -199,6 +205,7 @@ private struct TrailPart
         {
             public Vector2 Position;
             public float Time;
+            public Vector2 Scale;
             public long InvalidationID;
         }
 
@@ -280,7 +287,7 @@ protected override void Draw(IRenderer renderer)
 
                     vertexBatch.Add(new TexturedTrailVertex
                     {
-                        Position = new Vector2(part.Position.X - texture.DisplayWidth * originPosition.X, part.Position.Y + texture.DisplayHeight * (1 - originPosition.Y)),
+                        Position = new Vector2(part.Position.X - texture.DisplayWidth * originPosition.X * part.Scale.X, part.Position.Y + texture.DisplayHeight * (1 - originPosition.Y) * part.Scale.Y),
                         TexturePosition = textureRect.BottomLeft,
                         TextureRect = new Vector4(0, 0, 1, 1),
                         Colour = DrawColourInfo.Colour.BottomLeft.Linear,
@@ -289,7 +296,7 @@ protected override void Draw(IRenderer renderer)
 
                     vertexBatch.Add(new TexturedTrailVertex
                     {
-                        Position = new Vector2(part.Position.X + texture.DisplayWidth * (1 - originPosition.X), part.Position.Y + texture.DisplayHeight * (1 - originPosition.Y)),
+                        Position = new Vector2(part.Position.X + texture.DisplayWidth * (1 - originPosition.X) * part.Scale.X, part.Position.Y + texture.DisplayHeight * (1 - originPosition.Y) * part.Scale.Y),
                         TexturePosition = textureRect.BottomRight,
                         TextureRect = new Vector4(0, 0, 1, 1),
                         Colour = DrawColourInfo.Colour.BottomRight.Linear,
@@ -298,7 +305,7 @@ protected override void Draw(IRenderer renderer)
 
                     vertexBatch.Add(new TexturedTrailVertex
                     {
-                        Position = new Vector2(part.Position.X + texture.DisplayWidth * (1 - originPosition.X), part.Position.Y - texture.DisplayHeight * originPosition.Y),
+                        Position = new Vector2(part.Position.X + texture.DisplayWidth * (1 - originPosition.X) * part.Scale.X, part.Position.Y - texture.DisplayHeight * originPosition.Y * part.Scale.Y),
                         TexturePosition = textureRect.TopRight,
                         TextureRect = new Vector4(0, 0, 1, 1),
                         Colour = DrawColourInfo.Colour.TopRight.Linear,
@@ -307,7 +314,7 @@ protected override void Draw(IRenderer renderer)
 
                     vertexBatch.Add(new TexturedTrailVertex
                     {
-                        Position = new Vector2(part.Position.X - texture.DisplayWidth * originPosition.X, part.Position.Y - texture.DisplayHeight * originPosition.Y),
+                        Position = new Vector2(part.Position.X - texture.DisplayWidth * originPosition.X * part.Scale.X, part.Position.Y - texture.DisplayHeight * originPosition.Y * part.Scale.Y),
                         TexturePosition = textureRect.TopLeft,
                         TextureRect = new Vector4(0, 0, 1, 1),
                         Colour = DrawColourInfo.Colour.TopLeft.Linear,
diff --git a/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursor.cs b/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursor.cs
index d8f50c1f5db6..0bb316e0aa50 100644
--- a/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursor.cs
+++ b/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursor.cs
@@ -31,6 +31,11 @@ public partial class OsuCursor : SkinReloadableDrawable
 
         private SkinnableCursor skinnableCursor => (SkinnableCursor)cursorSprite.Drawable;
 
+        /// <summary>
+        /// The current expanded scale of the cursor.
+        /// </summary>
+        public Vector2 CurrentExpandedScale => skinnableCursor.ExpandTarget?.Scale ?? Vector2.One;
+
         public IBindable<float> CursorScale => cursorScale;
 
         private readonly Bindable<float> cursorScale = new BindableFloat(1);
diff --git a/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs b/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs
index ba8a634ff742..8c0871d54fff 100644
--- a/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs
+++ b/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs
@@ -23,14 +23,13 @@ public partial class OsuCursorContainer : GameplayCursorContainer, IKeyBindingHa
         public new OsuCursor ActiveCursor => (OsuCursor)base.ActiveCursor;
 
         protected override Drawable CreateCursor() => new OsuCursor();
-
         protected override Container<Drawable> Content => fadeContainer;
 
         private readonly Container<Drawable> fadeContainer;
 
         private readonly Bindable<bool> showTrail = new Bindable<bool>(true);
 
-        private readonly Drawable cursorTrail;
+        private readonly SkinnableDrawable cursorTrail;
 
         private readonly CursorRippleVisualiser rippleVisualiser;
 
@@ -39,7 +38,7 @@ public OsuCursorContainer()
             InternalChild = fadeContainer = new Container
             {
                 RelativeSizeAxes = Axes.Both,
-                Children = new[]
+                Children = new CompositeDrawable[]
                 {
                     cursorTrail = new SkinnableDrawable(new OsuSkinComponentLookup(OsuSkinComponents.CursorTrail), _ => new DefaultCursorTrail(), confineMode: ConfineMode.NoScaling),
                     rippleVisualiser = new CursorRippleVisualiser(),
@@ -79,6 +78,14 @@ private void updateExpandedState()
                 ActiveCursor.Contract();
         }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            if (cursorTrail.Drawable is CursorTrail trail)
+                trail.NewPartScale = ActiveCursor.CurrentExpandedScale;
+        }
+
         public bool OnPressed(KeyBindingPressEvent<OsuAction> e)
         {
             switch (e.Action)
diff --git a/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs b/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
index f0390ad716d5..ab69b67051f3 100644
--- a/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
+++ b/osu.Game.Rulesets.Osu/UI/DrawableOsuRuleset.cs
@@ -1,11 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Input.Handlers;
@@ -25,18 +26,38 @@ namespace osu.Game.Rulesets.Osu.UI
 {
     public partial class DrawableOsuRuleset : DrawableRuleset<OsuHitObject>
     {
-        protected new OsuRulesetConfigManager Config => (OsuRulesetConfigManager)base.Config;
+        private Bindable<bool>? cursorHideEnabled;
 
         public new OsuInputManager KeyBindingInputManager => (OsuInputManager)base.KeyBindingInputManager;
 
         public new OsuPlayfield Playfield => (OsuPlayfield)base.Playfield;
 
-        public DrawableOsuRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
+        protected new OsuRulesetConfigManager Config => (OsuRulesetConfigManager)base.Config;
+
+        public DrawableOsuRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods = null)
             : base(ruleset, beatmap, mods)
         {
         }
 
-        public override DrawableHitObject<OsuHitObject> CreateDrawableRepresentation(OsuHitObject h) => null;
+        [BackgroundDependencyLoader]
+        private void load(ReplayPlayer? replayPlayer)
+        {
+            if (replayPlayer != null)
+            {
+                ReplayAnalysisOverlay analysisOverlay;
+                PlayfieldAdjustmentContainer.Add(analysisOverlay = new ReplayAnalysisOverlay(replayPlayer.Score.Replay));
+                Overlays.Add(analysisOverlay.CreateProxy().With(p => p.Depth = float.NegativeInfinity));
+                replayPlayer.AddSettings(new ReplayAnalysisSettings(Config));
+
+                cursorHideEnabled = Config.GetBindable<bool>(OsuRulesetSetting.ReplayCursorHideEnabled);
+
+                // I have little faith in this working (other things touch cursor visibility) but haven't broken it yet.
+                // Let's wait for someone to report an issue before spending too much time on it.
+                cursorHideEnabled.BindValueChanged(enabled => Playfield.Cursor.FadeTo(enabled.NewValue ? 0 : 1), true);
+            }
+        }
+
+        public override DrawableHitObject<OsuHitObject>? CreateDrawableRepresentation(OsuHitObject h) => null;
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true; // always show the gameplay cursor
 
diff --git a/osu.Game.Rulesets.Osu/UI/OsuResumeOverlay.cs b/osu.Game.Rulesets.Osu/UI/OsuResumeOverlay.cs
index d90d3d26eb3e..b045b829607a 100644
--- a/osu.Game.Rulesets.Osu/UI/OsuResumeOverlay.cs
+++ b/osu.Game.Rulesets.Osu/UI/OsuResumeOverlay.cs
@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
@@ -35,9 +36,11 @@ private void load()
         {
             OsuResumeOverlayInputBlocker? inputBlocker = null;
 
-            if (drawableRuleset != null)
+            var drawableOsuRuleset = (DrawableOsuRuleset?)drawableRuleset;
+
+            if (drawableOsuRuleset != null)
             {
-                var osuPlayfield = (OsuPlayfield)drawableRuleset.Playfield;
+                var osuPlayfield = drawableOsuRuleset.Playfield;
                 osuPlayfield.AttachResumeOverlayInputBlocker(inputBlocker = new OsuResumeOverlayInputBlocker());
             }
 
@@ -45,13 +48,14 @@ private void load()
             {
                 Child = clickToResumeCursor = new OsuClickToResumeCursor
                 {
-                    ResumeRequested = () =>
+                    ResumeRequested = action =>
                     {
                         // since the user had to press a button to tap the resume cursor,
                         // block that press event from potentially reaching a hit circle that's behind the cursor.
                         // we cannot do this from OsuClickToResumeCursor directly since we're in a different input manager tree than the gameplay one,
                         // so we rely on a dedicated input blocking component that's implanted in there to do that for us.
-                        if (inputBlocker != null)
+                        // note this only matters when the user didn't pause while they were holding the same key that they are resuming with.
+                        if (inputBlocker != null && !drawableOsuRuleset.AsNonNull().KeyBindingInputManager.PressedActions.Contains(action))
                             inputBlocker.BlockNextPress = true;
 
                         Resume();
@@ -94,7 +98,7 @@ public partial class OsuClickToResumeCursor : OsuCursor, IKeyBindingHandler<OsuA
         {
             public override bool HandlePositionalInput => true;
 
-            public Action? ResumeRequested;
+            public Action<OsuAction>? ResumeRequested;
             private Container scaleTransitionContainer = null!;
 
             public OsuClickToResumeCursor()
@@ -136,7 +140,7 @@ public bool OnPressed(KeyBindingPressEvent<OsuAction> e)
                             return false;
 
                         scaleTransitionContainer.ScaleTo(2, TRANSITION_TIME, Easing.OutQuint);
-                        ResumeRequested?.Invoke();
+                        ResumeRequested?.Invoke(e.Action);
                         return true;
                 }
 
diff --git a/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/AnalysisFrameEntry.cs b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/AnalysisFrameEntry.cs
new file mode 100644
index 000000000000..116bccc74705
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/AnalysisFrameEntry.cs
@@ -0,0 +1,23 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics.Performance;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.UI.ReplayAnalysis
+{
+    public partial class AnalysisFrameEntry : LifetimeEntry
+    {
+        public OsuAction[] Action { get; }
+
+        public Vector2 Position { get; }
+
+        public AnalysisFrameEntry(double time, double displayLength, Vector2 position, params OsuAction[] action)
+        {
+            LifetimeStart = time;
+            LifetimeEnd = time + displayLength;
+            Position = position;
+            Action = action;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/AnalysisMarker.cs b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/AnalysisMarker.cs
new file mode 100644
index 000000000000..187876d69163
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/AnalysisMarker.cs
@@ -0,0 +1,28 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Pooling;
+
+namespace osu.Game.Rulesets.Osu.UI.ReplayAnalysis
+{
+    public abstract partial class AnalysisMarker : PoolableDrawableWithLifetime<AnalysisFrameEntry>
+    {
+        [Resolved]
+        protected OsuColour Colours { get; private set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Origin = Anchor.Centre;
+        }
+
+        protected override void OnApply(AnalysisFrameEntry entry)
+        {
+            Position = entry.Position;
+            Depth = -(float)entry.LifetimeEnd;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/ClickMarker.cs b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/ClickMarker.cs
new file mode 100644
index 000000000000..9788ea1aa9bc
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/ClickMarker.cs
@@ -0,0 +1,88 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.UI.ReplayAnalysis
+{
+    /// <summary>
+    /// A marker which shows one click, with visuals focusing on the button which was clicked and the precise location of the click.
+    /// </summary>
+    public partial class ClickMarker : AnalysisMarker
+    {
+        private CircularProgress leftClickDisplay = null!;
+        private CircularProgress rightClickDisplay = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
+            {
+                new Circle
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(0.125f),
+                    RelativeSizeAxes = Axes.Both,
+                    Blending = BlendingParameters.Additive,
+                    Colour = Colours.Gray5,
+                },
+                new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Colours.Gray5,
+                    Masking = true,
+                    BorderThickness = 2.2f,
+                    BorderColour = Color4.White,
+                    Child = new Box
+                    {
+                        Colour = Color4.Black,
+                        RelativeSizeAxes = Axes.Both,
+                        AlwaysPresent = true,
+                        Alpha = 0,
+                    },
+                },
+                leftClickDisplay = new CircularProgress
+                {
+                    Colour = Colours.Yellow,
+                    Size = new Vector2(0.95f),
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreRight,
+                    Rotation = 180,
+                    Progress = 0.5f,
+                    InnerRadius = 0.18f,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                rightClickDisplay = new CircularProgress
+                {
+                    Colour = Colours.Yellow,
+                    Size = new Vector2(0.95f),
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    Progress = 0.5f,
+                    InnerRadius = 0.18f,
+                    RelativeSizeAxes = Axes.Both,
+                },
+            };
+
+            Size = new Vector2(16);
+        }
+
+        protected override void OnApply(AnalysisFrameEntry entry)
+        {
+            base.OnApply(entry);
+
+            leftClickDisplay.Alpha = entry.Action.Contains(OsuAction.LeftButton) ? 1 : 0;
+            rightClickDisplay.Alpha = entry.Action.Contains(OsuAction.RightButton) ? 1 : 0;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/ClickMarkerContainer.cs b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/ClickMarkerContainer.cs
new file mode 100644
index 000000000000..ff9444952131
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/ClickMarkerContainer.cs
@@ -0,0 +1,20 @@
+// 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.Pooling;
+using osu.Game.Rulesets.Objects.Pooling;
+
+namespace osu.Game.Rulesets.Osu.UI.ReplayAnalysis
+{
+    public partial class ClickMarkerContainer : PooledDrawableWithLifetimeContainer<AnalysisFrameEntry, AnalysisMarker>
+    {
+        private readonly DrawablePool<ClickMarker> clickMarkerPool;
+
+        public ClickMarkerContainer()
+        {
+            AddInternal(clickMarkerPool = new DrawablePool<ClickMarker>(30));
+        }
+
+        protected override AnalysisMarker GetDrawable(AnalysisFrameEntry entry) => clickMarkerPool.Get(d => d.Apply(entry));
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/CursorPathContainer.cs b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/CursorPathContainer.cs
new file mode 100644
index 000000000000..1951d467e230
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/CursorPathContainer.cs
@@ -0,0 +1,86 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics.Lines;
+using osu.Framework.Graphics.Performance;
+using osu.Game.Graphics;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.UI.ReplayAnalysis
+{
+    public partial class CursorPathContainer : Path
+    {
+        private readonly LifetimeEntryManager lifetimeManager = new LifetimeEntryManager();
+        private readonly SortedSet<AnalysisFrameEntry> aliveEntries = new SortedSet<AnalysisFrameEntry>(new AimLinePointComparator());
+
+        public CursorPathContainer()
+        {
+            lifetimeManager.EntryBecameAlive += entryBecameAlive;
+            lifetimeManager.EntryBecameDead += entryBecameDead;
+
+            PathRadius = 0.5f;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.Pink2;
+            BackgroundColour = colours.Pink2.Opacity(0);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            lifetimeManager.Update(Time.Current);
+        }
+
+        public void Add(AnalysisFrameEntry entry) => lifetimeManager.AddEntry(entry);
+
+        private void entryBecameAlive(LifetimeEntry entry)
+        {
+            aliveEntries.Add((AnalysisFrameEntry)entry);
+            updateVertices();
+        }
+
+        private void entryBecameDead(LifetimeEntry entry)
+        {
+            aliveEntries.Remove((AnalysisFrameEntry)entry);
+            updateVertices();
+        }
+
+        private void updateVertices()
+        {
+            ClearVertices();
+
+            Vector2 min = Vector2.Zero;
+
+            foreach (var entry in aliveEntries)
+            {
+                AddVertex(entry.Position);
+                if (entry.Position.X < min.X)
+                    min.X = entry.Position.X;
+
+                if (entry.Position.Y < min.Y)
+                    min.Y = entry.Position.Y;
+            }
+
+            Position = min;
+        }
+
+        private sealed class AimLinePointComparator : IComparer<AnalysisFrameEntry>
+        {
+            public int Compare(AnalysisFrameEntry? x, AnalysisFrameEntry? y)
+            {
+                ArgumentNullException.ThrowIfNull(x);
+                ArgumentNullException.ThrowIfNull(y);
+
+                return x.LifetimeStart.CompareTo(y.LifetimeStart);
+            }
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/FrameMarker.cs b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/FrameMarker.cs
new file mode 100644
index 000000000000..35ee1445683a
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/FrameMarker.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 System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.UI.ReplayAnalysis
+{
+    /// <summary>
+    /// A marker which shows one movement frame, include any buttons which are pressed.
+    /// </summary>
+    public partial class FrameMarker : AnalysisMarker
+    {
+        private CircularProgress leftClickDisplay = null!;
+        private CircularProgress rightClickDisplay = null!;
+        private Circle mainCircle = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
+            {
+                mainCircle = new Circle
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Colours.Pink2,
+                },
+                leftClickDisplay = new CircularProgress
+                {
+                    Colour = Colours.Yellow,
+                    Size = new Vector2(0.8f),
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreRight,
+                    Rotation = 180,
+                    Progress = 0.5f,
+                    InnerRadius = 0.5f,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                rightClickDisplay = new CircularProgress
+                {
+                    Colour = Colours.Yellow,
+                    Size = new Vector2(0.8f),
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    Progress = 0.5f,
+                    InnerRadius = 0.5f,
+                    RelativeSizeAxes = Axes.Both,
+                },
+            };
+        }
+
+        protected override void OnApply(AnalysisFrameEntry entry)
+        {
+            base.OnApply(entry);
+            Size = new Vector2(entry.Action.Any() ? 4 : 2.5f);
+
+            mainCircle.Colour = entry.Action.Any() ? Colours.Gray4 : Colours.Pink2;
+
+            leftClickDisplay.Alpha = entry.Action.Contains(OsuAction.LeftButton) ? 1 : 0;
+            rightClickDisplay.Alpha = entry.Action.Contains(OsuAction.RightButton) ? 1 : 0;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/FrameMarkerContainer.cs b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/FrameMarkerContainer.cs
new file mode 100644
index 000000000000..63aea259f7cf
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ReplayAnalysis/FrameMarkerContainer.cs
@@ -0,0 +1,20 @@
+// 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.Pooling;
+using osu.Game.Rulesets.Objects.Pooling;
+
+namespace osu.Game.Rulesets.Osu.UI.ReplayAnalysis
+{
+    public partial class FrameMarkerContainer : PooledDrawableWithLifetimeContainer<AnalysisFrameEntry, AnalysisMarker>
+    {
+        private readonly DrawablePool<FrameMarker> pool;
+
+        public FrameMarkerContainer()
+        {
+            AddInternal(pool = new DrawablePool<FrameMarker>(80));
+        }
+
+        protected override AnalysisMarker GetDrawable(AnalysisFrameEntry entry) => pool.Get(d => d.Apply(entry));
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/ReplayAnalysisOverlay.cs b/osu.Game.Rulesets.Osu/UI/ReplayAnalysisOverlay.cs
new file mode 100644
index 000000000000..2b7f6c9fc96d
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ReplayAnalysisOverlay.cs
@@ -0,0 +1,128 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Threading;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Osu.Configuration;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.UI.ReplayAnalysis;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public partial class ReplayAnalysisOverlay : CompositeDrawable
+    {
+        private BindableBool showClickMarkers { get; } = new BindableBool();
+        private BindableBool showFrameMarkers { get; } = new BindableBool();
+        private BindableBool showCursorPath { get; } = new BindableBool();
+        private BindableInt displayLength { get; } = new BindableInt();
+
+        protected ClickMarkerContainer? ClickMarkers;
+        protected FrameMarkerContainer? FrameMarkers;
+        protected CursorPathContainer? CursorPath;
+
+        private readonly Replay replay;
+
+        public ReplayAnalysisOverlay(Replay replay)
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            this.replay = replay;
+        }
+
+        private bool requireDisplay => showClickMarkers.Value || showFrameMarkers.Value || showCursorPath.Value;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuRulesetConfigManager config)
+        {
+            config.BindWith(OsuRulesetSetting.ReplayClickMarkersEnabled, showClickMarkers);
+            config.BindWith(OsuRulesetSetting.ReplayFrameMarkersEnabled, showFrameMarkers);
+            config.BindWith(OsuRulesetSetting.ReplayCursorPathEnabled, showCursorPath);
+            config.BindWith(OsuRulesetSetting.ReplayAnalysisDisplayLength, displayLength);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            displayLength.BindValueChanged(_ =>
+            {
+                // Need to fully reload to make this work.
+                loaded.Invalidate();
+            }, true);
+        }
+
+        private readonly Cached loaded = new Cached();
+
+        private CancellationTokenSource? generationCancellationSource;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (requireDisplay)
+                initialise();
+
+            if (ClickMarkers != null) ClickMarkers.Alpha = showClickMarkers.Value ? 1 : 0;
+            if (FrameMarkers != null) FrameMarkers.Alpha = showFrameMarkers.Value ? 1 : 0;
+            if (CursorPath != null) CursorPath.Alpha = showCursorPath.Value ? 1 : 0;
+        }
+
+        private void initialise()
+        {
+            if (loaded.IsValid)
+                return;
+
+            loaded.Validate();
+
+            generationCancellationSource?.Cancel();
+            generationCancellationSource = new CancellationTokenSource();
+
+            // It's faster to reinitialise the whole drawable stack than use `Clear` on `PooledDrawableWithLifetimeContainer`
+            var newDrawables = new Drawable[]
+            {
+                CursorPath = new CursorPathContainer(),
+                ClickMarkers = new ClickMarkerContainer(),
+                FrameMarkers = new FrameMarkerContainer(),
+            };
+
+            bool leftHeld = false;
+            bool rightHeld = false;
+
+            // This should probably be async as well, but it's a bit of a pain to debounce and everything.
+            // Let's address concerns when they are raised.
+            foreach (var frame in replay.Frames)
+            {
+                var osuFrame = (OsuReplayFrame)frame;
+
+                bool leftButton = osuFrame.Actions.Contains(OsuAction.LeftButton);
+                bool rightButton = osuFrame.Actions.Contains(OsuAction.RightButton);
+
+                if (leftHeld && !leftButton)
+                    leftHeld = false;
+                else if (!leftHeld && leftButton)
+                {
+                    leftHeld = true;
+                    ClickMarkers.Add(new AnalysisFrameEntry(osuFrame.Time, displayLength.Value, osuFrame.Position, OsuAction.LeftButton));
+                }
+
+                if (rightHeld && !rightButton)
+                    rightHeld = false;
+                else if (!rightHeld && rightButton)
+                {
+                    rightHeld = true;
+                    ClickMarkers.Add(new AnalysisFrameEntry(osuFrame.Time, displayLength.Value, osuFrame.Position, OsuAction.RightButton));
+                }
+
+                FrameMarkers.Add(new AnalysisFrameEntry(osuFrame.Time, displayLength.Value, osuFrame.Position, osuFrame.Actions.ToArray()));
+                CursorPath.Add(new AnalysisFrameEntry(osuFrame.Time, displayLength.Value, osuFrame.Position));
+            }
+
+            LoadComponentsAsync(newDrawables, drawables => InternalChildrenEnumerable = drawables, generationCancellationSource.Token);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/ReplayAnalysisSettings.cs b/osu.Game.Rulesets.Osu/UI/ReplayAnalysisSettings.cs
new file mode 100644
index 000000000000..dc4730d76ab5
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ReplayAnalysisSettings.cs
@@ -0,0 +1,55 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Osu.Configuration;
+using osu.Game.Screens.Play.PlayerSettings;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public partial class ReplayAnalysisSettings : PlayerSettingsGroup
+    {
+        private readonly OsuRulesetConfigManager config;
+
+        [SettingSource("Show click markers", SettingControlType = typeof(PlayerCheckbox))]
+        public BindableBool ShowClickMarkers { get; } = new BindableBool();
+
+        [SettingSource("Show frame markers", SettingControlType = typeof(PlayerCheckbox))]
+        public BindableBool ShowAimMarkers { get; } = new BindableBool();
+
+        [SettingSource("Show cursor path", SettingControlType = typeof(PlayerCheckbox))]
+        public BindableBool ShowCursorPath { get; } = new BindableBool();
+
+        [SettingSource("Hide gameplay cursor", SettingControlType = typeof(PlayerCheckbox))]
+        public BindableBool HideSkinCursor { get; } = new BindableBool();
+
+        [SettingSource("Display length", SettingControlType = typeof(PlayerSliderBar<int>))]
+        public BindableInt DisplayLength { get; } = new BindableInt
+        {
+            MinValue = 200,
+            MaxValue = 2000,
+            Default = 800,
+            Precision = 200,
+        };
+
+        public ReplayAnalysisSettings(OsuRulesetConfigManager config)
+            : base("Analysis Settings")
+        {
+            this.config = config;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddRange(this.CreateSettingsControls());
+
+            config.BindWith(OsuRulesetSetting.ReplayClickMarkersEnabled, ShowClickMarkers);
+            config.BindWith(OsuRulesetSetting.ReplayFrameMarkersEnabled, ShowAimMarkers);
+            config.BindWith(OsuRulesetSetting.ReplayCursorPathEnabled, ShowCursorPath);
+            config.BindWith(OsuRulesetSetting.ReplayCursorHideEnabled, HideSkinCursor);
+            config.BindWith(OsuRulesetSetting.ReplayAnalysisDisplayLength, DisplayLength);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko.Tests/VolumeAwareHitSampleInfoTest.cs b/osu.Game.Rulesets.Taiko.Tests/VolumeAwareHitSampleInfoTest.cs
new file mode 100644
index 000000000000..2b3a922067fc
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko.Tests/VolumeAwareHitSampleInfoTest.cs
@@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Audio;
+using osu.Game.Rulesets.Taiko.Skinning.Argon;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    [TestFixture]
+    public class VolumeAwareHitSampleInfoTest
+    {
+        [Test]
+        public void TestVolumeAwareHitSampleInfoIsNotEqualToItsUnderlyingSample(
+            [Values(HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_CLAP)]
+            string sample,
+            [Values(HitSampleInfo.BANK_NORMAL, HitSampleInfo.BANK_SOFT)]
+            string bank,
+            [Values(30, 70, 100)] int volume)
+        {
+            var underlyingSample = new HitSampleInfo(sample, bank, volume: volume);
+            var volumeAwareSample = new VolumeAwareHitSampleInfo(underlyingSample);
+
+            Assert.That(underlyingSample, Is.Not.EqualTo(volumeAwareSample));
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
index 9b746d47eaf3..e3c550fbe9e7 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
@@ -14,19 +14,16 @@
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour;
 using osu.Game.Rulesets.Taiko.Difficulty.Skills;
 using osu.Game.Rulesets.Taiko.Mods;
-using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Scoring;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
 {
     public class TaikoDifficultyCalculator : DifficultyCalculator
     {
-        private const double difficulty_multiplier = 1.35;
-
-        private const double final_multiplier = 0.0625;
-        private const double rhythm_skill_multiplier = 0.2 * final_multiplier;
-        private const double colour_skill_multiplier = 0.375 * final_multiplier;
-        private const double stamina_skill_multiplier = 0.375 * final_multiplier;
+        private const double difficulty_multiplier = 0.084375;
+        private const double rhythm_skill_multiplier = 0.2 * difficulty_multiplier;
+        private const double colour_skill_multiplier = 0.375 * difficulty_multiplier;
+        private const double stamina_skill_multiplier = 0.375 * difficulty_multiplier;
 
         public override int Version => 20221107;
 
@@ -83,11 +80,11 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
             Rhythm rhythm = (Rhythm)skills.First(x => x is Rhythm);
             Stamina stamina = (Stamina)skills.First(x => x is Stamina);
 
-            double colourRating = colour.DifficultyValue() * colour_skill_multiplier * difficulty_multiplier;
-            double rhythmRating = rhythm.DifficultyValue() * rhythm_skill_multiplier * difficulty_multiplier;
-            double staminaRating = stamina.DifficultyValue() * stamina_skill_multiplier * difficulty_multiplier;
+            double colourRating = colour.DifficultyValue() * colour_skill_multiplier;
+            double rhythmRating = rhythm.DifficultyValue() * rhythm_skill_multiplier;
+            double staminaRating = stamina.DifficultyValue() * stamina_skill_multiplier;
 
-            double combinedRating = combinedDifficultyValue(rhythm, colour, stamina) * difficulty_multiplier;
+            double combinedRating = combinedDifficultyValue(rhythm, colour, stamina);
             double starRating = rescale(combinedRating * 1.4);
 
             HitWindows hitWindows = new TaikoHitWindows();
@@ -102,7 +99,7 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
                 ColourDifficulty = colourRating,
                 PeakDifficulty = combinedRating,
                 GreatHitWindow = hitWindows.WindowFor(HitResult.Great) / clockRate,
-                MaxCombo = beatmap.HitObjects.Count(h => h is Hit),
+                MaxCombo = beatmap.GetMaxCombo(),
             };
 
             return attributes;
diff --git a/osu.Game.Rulesets.Taiko/Edit/Blueprints/HitPlacementBlueprint.cs b/osu.Game.Rulesets.Taiko/Edit/Blueprints/HitPlacementBlueprint.cs
index 329fff5b423f..7f45123bd69d 100644
--- a/osu.Game.Rulesets.Taiko/Edit/Blueprints/HitPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/Blueprints/HitPlacementBlueprint.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Taiko.Edit.Blueprints
 {
-    public partial class HitPlacementBlueprint : PlacementBlueprint
+    public partial class HitPlacementBlueprint : HitObjectPlacementBlueprint
     {
         private readonly HitPiece piece;
 
diff --git a/osu.Game.Rulesets.Taiko/Edit/Blueprints/TaikoSpanPlacementBlueprint.cs b/osu.Game.Rulesets.Taiko/Edit/Blueprints/TaikoSpanPlacementBlueprint.cs
index cd52398086ff..de3a4d96eb5e 100644
--- a/osu.Game.Rulesets.Taiko/Edit/Blueprints/TaikoSpanPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/Blueprints/TaikoSpanPlacementBlueprint.cs
@@ -17,7 +17,7 @@
 
 namespace osu.Game.Rulesets.Taiko.Edit.Blueprints
 {
-    public partial class TaikoSpanPlacementBlueprint : PlacementBlueprint
+    public partial class TaikoSpanPlacementBlueprint : HitObjectPlacementBlueprint
     {
         private readonly HitPiece headPiece;
         private readonly HitPiece tailPiece;
diff --git a/osu.Game.Rulesets.Taiko/Edit/DrumRollCompositionTool.cs b/osu.Game.Rulesets.Taiko/Edit/DrumRollCompositionTool.cs
index f332441875cd..ba0fda67712b 100644
--- a/osu.Game.Rulesets.Taiko/Edit/DrumRollCompositionTool.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/DrumRollCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Taiko.Edit
 {
-    public class DrumRollCompositionTool : HitObjectCompositionTool
+    public class DrumRollCompositionTool : CompositionTool
     {
         public DrumRollCompositionTool()
             : base(nameof(DrumRoll))
@@ -19,6 +19,6 @@ public DrumRollCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new DrumRollPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new DrumRollPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Edit/HitCompositionTool.cs b/osu.Game.Rulesets.Taiko/Edit/HitCompositionTool.cs
index fa5084189390..f58defba83e8 100644
--- a/osu.Game.Rulesets.Taiko/Edit/HitCompositionTool.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/HitCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Taiko.Edit
 {
-    public class HitCompositionTool : HitObjectCompositionTool
+    public class HitCompositionTool : CompositionTool
     {
         public HitCompositionTool()
             : base(nameof(Hit))
@@ -19,6 +19,6 @@ public HitCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new HitPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new HitPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Edit/SwellCompositionTool.cs b/osu.Game.Rulesets.Taiko/Edit/SwellCompositionTool.cs
index 4d4ee8effed1..4ec623e29ef1 100644
--- a/osu.Game.Rulesets.Taiko/Edit/SwellCompositionTool.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/SwellCompositionTool.cs
@@ -10,7 +10,7 @@
 
 namespace osu.Game.Rulesets.Taiko.Edit
 {
-    public class SwellCompositionTool : HitObjectCompositionTool
+    public class SwellCompositionTool : CompositionTool
     {
         public SwellCompositionTool()
             : base(nameof(Swell))
@@ -19,6 +19,6 @@ public SwellCompositionTool()
 
         public override Drawable CreateIcon() => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners);
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => new SwellPlacementBlueprint();
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => new SwellPlacementBlueprint();
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Edit/TaikoHitObjectComposer.cs b/osu.Game.Rulesets.Taiko/Edit/TaikoHitObjectComposer.cs
index 6020f6e04c3c..d97a854ff785 100644
--- a/osu.Game.Rulesets.Taiko/Edit/TaikoHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/TaikoHitObjectComposer.cs
@@ -21,7 +21,7 @@ public TaikoHitObjectComposer(TaikoRuleset ruleset)
         {
         }
 
-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
+        protected override IReadOnlyList<CompositionTool> CompositionTools => new CompositionTool[]
         {
             new HitCompositionTool(),
             new DrumRollCompositionTool(),
diff --git a/osu.Game.Rulesets.Taiko/Skinning/Argon/TaikoArgonSkinTransformer.cs b/osu.Game.Rulesets.Taiko/Skinning/Argon/TaikoArgonSkinTransformer.cs
index 973b4a91ff25..bfc9e8648dc2 100644
--- a/osu.Game.Rulesets.Taiko/Skinning/Argon/TaikoArgonSkinTransformer.cs
+++ b/osu.Game.Rulesets.Taiko/Skinning/Argon/TaikoArgonSkinTransformer.cs
@@ -18,7 +18,7 @@ public TaikoArgonSkinTransformer(ISkin skin)
         {
             switch (lookup)
             {
-                case GameplaySkinComponentLookup<HitResult> resultComponent:
+                case SkinComponentLookup<HitResult> resultComponent:
                     // This should eventually be moved to a skin setting, when supported.
                     if (Skin is ArgonProSkin && resultComponent.Component >= HitResult.Great)
                         return Drawable.Empty();
diff --git a/osu.Game.Rulesets.Taiko/Skinning/Argon/VolumeAwareHitSampleInfo.cs b/osu.Game.Rulesets.Taiko/Skinning/Argon/VolumeAwareHitSampleInfo.cs
index 3ca4b5a3c7a7..288ffde05212 100644
--- a/osu.Game.Rulesets.Taiko/Skinning/Argon/VolumeAwareHitSampleInfo.cs
+++ b/osu.Game.Rulesets.Taiko/Skinning/Argon/VolumeAwareHitSampleInfo.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 osu.Game.Audio;
 
@@ -48,5 +49,24 @@ private static string getBank(string originalBank, string sampleName, int volume
                     return originalBank;
             }
         }
+
+        public override bool Equals(HitSampleInfo? other) => other is VolumeAwareHitSampleInfo && base.Equals(other);
+
+        /// <remarks>
+        /// <para>
+        /// This override attempts to match the <see cref="Equals"/> override above, but in theory it is not strictly necessary.
+        /// Recall that <see cref="GetHashCode"/> <a href="https://learn.microsoft.com/en-us/dotnet/api/system.object.gethashcode?view=net-8.0#notes-to-inheritors">must meet the following requirements</a>:
+        /// </para>
+        /// <para>
+        /// "If two objects compare as equal, the <see cref="GetHashCode"/> method for each object must return the same value.
+        /// However, if two objects do not compare as equal, <see cref="GetHashCode"/> methods for the two objects do not have to return different values."
+        /// </para>
+        /// <para>
+        /// Making this override combine the value generated by the base <see cref="GetHashCode"/> implementation with a constant means
+        /// that <see cref="HitSampleInfo"/> and <see cref="VolumeAwareHitSampleInfo"/> instances which have the same values of their members
+        /// will not have equal hash codes, which is slightly more efficient when these objects are used as dictionary keys.
+        /// </para>
+        /// </remarks>
+        public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), 1);
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacySkinTransformer.cs b/osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacySkinTransformer.cs
index 894b91e9cebf..5bdb824f1c1c 100644
--- a/osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacySkinTransformer.cs
+++ b/osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacySkinTransformer.cs
@@ -29,7 +29,7 @@ public TaikoLegacySkinTransformer(ISkin skin)
 
         public override Drawable? GetDrawableComponent(ISkinComponentLookup lookup)
         {
-            if (lookup is GameplaySkinComponentLookup<HitResult>)
+            if (lookup is SkinComponentLookup<HitResult>)
             {
                 // if a taiko skin is providing explosion sprites, hide the judgements completely
                 if (hasExplosion.Value)
diff --git a/osu.Game.Rulesets.Taiko/TaikoSkinComponentLookup.cs b/osu.Game.Rulesets.Taiko/TaikoSkinComponentLookup.cs
index 8841c3d3cade..2fa4d3c9cb1b 100644
--- a/osu.Game.Rulesets.Taiko/TaikoSkinComponentLookup.cs
+++ b/osu.Game.Rulesets.Taiko/TaikoSkinComponentLookup.cs
@@ -5,7 +5,7 @@
 
 namespace osu.Game.Rulesets.Taiko
 {
-    public class TaikoSkinComponentLookup : GameplaySkinComponentLookup<TaikoSkinComponents>
+    public class TaikoSkinComponentLookup : SkinComponentLookup<TaikoSkinComponents>
     {
         public TaikoSkinComponentLookup(TaikoSkinComponents component)
             : base(component)
diff --git a/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs b/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
index cf8c3c6ef10f..4f4556b82021 100644
--- a/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
+++ b/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
@@ -112,6 +112,7 @@ public void TestConversionsWithSliderVelocity()
             {
                 SliderVelocityMultiplier = slider_velocity
             };
+            AddStep("add to beatmap", () => composer.EditorBeatmap.Add(referenceObject));
 
             assertSnapDistance(base_distance * slider_velocity, referenceObject, true);
             assertSnappedDistance(base_distance * slider_velocity + 10, base_distance * slider_velocity, referenceObject);
@@ -227,6 +228,42 @@ public void GetSnappedDistanceFromDistance()
             assertSnappedDistance(400, 400);
         }
 
+        [Test]
+        public void TestUnsnappedObject()
+        {
+            var slider = new Slider
+            {
+                StartTime = 0,
+                Path = new SliderPath
+                {
+                    ControlPoints =
+                    {
+                        new PathControlPoint(),
+                        // simulate object snapped to 1/3rds
+                        // this object's end time will be 2000 / 3 = 666.66... ms
+                        new PathControlPoint(new Vector2(200 / 3f, 0)),
+                    }
+                }
+            };
+
+            AddStep("add slider", () => composer.EditorBeatmap.Add(slider));
+            AddStep("set snap to 1/4", () => BeatDivisor.Value = 4);
+
+            // with default beat length of 1000ms and snap at 1/4, the valid snap times are 500ms, 750ms, and 1000ms
+            // with default settings, the snapped distance will be a tenth of the difference of the time delta
+
+            // (500 - 666.66...) / 10 = -16.66... = -100 / 6
+            assertSnappedDistance(0, -100 / 6f, slider);
+            assertSnappedDistance(7, -100 / 6f, slider);
+
+            // (750 - 666.66...) / 10 = 8.33... = 100 / 12
+            assertSnappedDistance(9, 100 / 12f, slider);
+            assertSnappedDistance(33, 100 / 12f, slider);
+
+            // (1000 - 666.66...) / 10 = 33.33... = 100 / 3
+            assertSnappedDistance(34, 100 / 3f, slider);
+        }
+
         [Test]
         public void TestUseCurrentSnap()
         {
@@ -262,7 +299,7 @@ private void assertSnappedDuration(float distance, double expectedDuration, HitO
             => AddAssert($"distance = {distance} -> duration = {expectedDuration} (snapped)", () => composer.DistanceSnapProvider.FindSnappedDuration(referenceObject ?? new HitObject(), distance), () => 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(referenceObject ?? new HitObject(), distance), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
+            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)", () => composer.DistanceSnapProvider.FindSnappedDistance(referenceObject ?? new HitObject(), distance, DistanceSnapTarget.End), () => Is.EqualTo(expectedDistance).Within(Precision.FLOAT_EPSILON));
 
         private partial class TestHitObjectComposer : OsuHitObjectComposer
         {
diff --git a/osu.Game.Tests/NonVisual/ControlPointInfoTest.cs b/osu.Game.Tests/NonVisual/ControlPointInfoTest.cs
index 2d5d425ee8f9..d7df3d318db9 100644
--- a/osu.Game.Tests/NonVisual/ControlPointInfoTest.cs
+++ b/osu.Game.Tests/NonVisual/ControlPointInfoTest.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.Linq;
 using NUnit.Framework;
 using osu.Game.Beatmaps.ControlPoints;
@@ -286,5 +287,62 @@ public void TestDeepClone()
 
             Assert.That(cpi.TimingPoints[0].BeatLength, Is.Not.EqualTo(cpiCopy.TimingPoints[0].BeatLength));
         }
+
+        [Test]
+        public void TestBinarySearchEmptyList()
+        {
+            Assert.That(ControlPointInfo.BinarySearch(Array.Empty<TimingControlPoint>(), 0, EqualitySelection.FirstFound), Is.EqualTo(-1));
+            Assert.That(ControlPointInfo.BinarySearch(Array.Empty<TimingControlPoint>(), 0, EqualitySelection.Leftmost), Is.EqualTo(-1));
+            Assert.That(ControlPointInfo.BinarySearch(Array.Empty<TimingControlPoint>(), 0, EqualitySelection.Rightmost), Is.EqualTo(-1));
+        }
+
+        [TestCase(new[] { 1 }, 0, -1)]
+        [TestCase(new[] { 1 }, 1, 0)]
+        [TestCase(new[] { 1 }, 2, -2)]
+        [TestCase(new[] { 1, 3 }, 0, -1)]
+        [TestCase(new[] { 1, 3 }, 1, 0)]
+        [TestCase(new[] { 1, 3 }, 2, -2)]
+        [TestCase(new[] { 1, 3 }, 3, 1)]
+        [TestCase(new[] { 1, 3 }, 4, -3)]
+        public void TestBinarySearchUniqueScenarios(int[] values, int search, int expectedIndex)
+        {
+            var items = values.Select(t => new TimingControlPoint { Time = t }).ToArray();
+            Assert.That(ControlPointInfo.BinarySearch(items, search, EqualitySelection.FirstFound), Is.EqualTo(expectedIndex));
+            Assert.That(ControlPointInfo.BinarySearch(items, search, EqualitySelection.Leftmost), Is.EqualTo(expectedIndex));
+            Assert.That(ControlPointInfo.BinarySearch(items, search, EqualitySelection.Rightmost), Is.EqualTo(expectedIndex));
+        }
+
+        [TestCase(new[] { 1, 1 }, 1, 0)]
+        [TestCase(new[] { 1, 2, 2 }, 2, 1)]
+        [TestCase(new[] { 1, 2, 2, 2 }, 2, 1)]
+        [TestCase(new[] { 1, 2, 2, 2, 3 }, 2, 2)]
+        [TestCase(new[] { 1, 2, 2, 3 }, 2, 1)]
+        public void TestBinarySearchFirstFoundDuplicateScenarios(int[] values, int search, int expectedIndex)
+        {
+            var items = values.Select(t => new TimingControlPoint { Time = t }).ToArray();
+            Assert.That(ControlPointInfo.BinarySearch(items, search, EqualitySelection.FirstFound), Is.EqualTo(expectedIndex));
+        }
+
+        [TestCase(new[] { 1, 1 }, 1, 0)]
+        [TestCase(new[] { 1, 2, 2 }, 2, 1)]
+        [TestCase(new[] { 1, 2, 2, 2 }, 2, 1)]
+        [TestCase(new[] { 1, 2, 2, 2, 3 }, 2, 1)]
+        [TestCase(new[] { 1, 2, 2, 3 }, 2, 1)]
+        public void TestBinarySearchLeftMostDuplicateScenarios(int[] values, int search, int expectedIndex)
+        {
+            var items = values.Select(t => new TimingControlPoint { Time = t }).ToArray();
+            Assert.That(ControlPointInfo.BinarySearch(items, search, EqualitySelection.Leftmost), Is.EqualTo(expectedIndex));
+        }
+
+        [TestCase(new[] { 1, 1 }, 1, 1)]
+        [TestCase(new[] { 1, 2, 2 }, 2, 2)]
+        [TestCase(new[] { 1, 2, 2, 2 }, 2, 3)]
+        [TestCase(new[] { 1, 2, 2, 2, 3 }, 2, 3)]
+        [TestCase(new[] { 1, 2, 2, 3 }, 2, 2)]
+        public void TestBinarySearchRightMostDuplicateScenarios(int[] values, int search, int expectedIndex)
+        {
+            var items = values.Select(t => new TimingControlPoint { Time = t }).ToArray();
+            Assert.That(ControlPointInfo.BinarySearch(items, search, EqualitySelection.Rightmost), Is.EqualTo(expectedIndex));
+        }
     }
 }
diff --git a/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs b/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
index 7897b3d8c0f9..9ecfa72947d8 100644
--- a/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
+++ b/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
@@ -537,7 +537,7 @@ public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)
         [TestCaseSource(nameof(correct_date_query_examples))]
         public void TestValidDateQueries(string dateQuery)
         {
-            string query = $"played<{dateQuery} time";
+            string query = $"lastplayed<{dateQuery} time";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
             Assert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
@@ -571,7 +571,7 @@ public void TestInvalidDateQueries(string dateQuery)
         [Test]
         public void TestGreaterDateQuery()
         {
-            const string query = "played>50";
+            const string query = "lastplayed>50";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
             Assert.That(filterCriteria.LastPlayed.Max, Is.Not.Null);
@@ -584,7 +584,7 @@ public void TestGreaterDateQuery()
         [Test]
         public void TestLowerDateQuery()
         {
-            const string query = "played<50";
+            const string query = "lastplayed<50";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
             Assert.That(filterCriteria.LastPlayed.Max, Is.Null);
@@ -597,7 +597,7 @@ public void TestLowerDateQuery()
         [Test]
         public void TestBothSidesDateQuery()
         {
-            const string query = "played>3M played<1y6M";
+            const string query = "lastplayed>3M lastplayed<1y6M";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
             Assert.That(filterCriteria.LastPlayed.Min, Is.Not.Null);
@@ -611,7 +611,7 @@ public void TestBothSidesDateQuery()
         [Test]
         public void TestEqualDateQuery()
         {
-            const string query = "played=50";
+            const string query = "lastplayed=50";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
             Assert.AreEqual(false, filterCriteria.LastPlayed.HasFilter);
@@ -620,11 +620,38 @@ public void TestEqualDateQuery()
         [Test]
         public void TestOutOfRangeDateQuery()
         {
-            const string query = "played<10000y";
+            const string query = "lastplayed<10000y";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
             Assert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
             Assert.AreEqual(DateTimeOffset.MinValue.AddMilliseconds(1), filterCriteria.LastPlayed.Min);
         }
+
+        private static readonly object[] played_query_tests =
+        {
+            new object[] { "0", DateTimeOffset.MinValue, true },
+            new object[] { "0", DateTimeOffset.Now, false },
+            new object[] { "false", DateTimeOffset.MinValue, true },
+            new object[] { "false", DateTimeOffset.Now, false },
+            new object[] { "no", DateTimeOffset.MinValue, true },
+            new object[] { "no", DateTimeOffset.Now, false },
+
+            new object[] { "1", DateTimeOffset.MinValue, false },
+            new object[] { "1", DateTimeOffset.Now, true },
+            new object[] { "true", DateTimeOffset.MinValue, false },
+            new object[] { "true", DateTimeOffset.Now, true },
+            new object[] { "yes", DateTimeOffset.MinValue, false },
+            new object[] { "yes", DateTimeOffset.Now, true },
+        };
+
+        [Test]
+        [TestCaseSource(nameof(played_query_tests))]
+        public void TestPlayedQuery(string query, DateTimeOffset reference, bool matched)
+        {
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, $"played={query}");
+            Assert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
+            Assert.AreEqual(matched, filterCriteria.LastPlayed.IsInRange(reference));
+        }
     }
 }
diff --git a/osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs b/osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs
index 585fd516bd7b..ae3451c3e0ec 100644
--- a/osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs
+++ b/osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs
@@ -257,7 +257,7 @@ public TestDownloadRequest(IBeatmapSetInfo model)
             {
             }
 
-            protected override string Target => null;
+            protected override string Target => string.Empty;
         }
     }
 }
diff --git a/osu.Game.Tests/Resources/Archives/argon-invalid-drawable.osk b/osu.Game.Tests/Resources/Archives/argon-invalid-drawable.osk
new file mode 100644
index 000000000000..23c318149cbe
Binary files /dev/null and b/osu.Game.Tests/Resources/Archives/argon-invalid-drawable.osk differ
diff --git a/osu.Game.Tests/Skins/SkinDeserialisationTest.cs b/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
index 534d47d617bd..73725571613e 100644
--- a/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
+++ b/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
@@ -12,6 +12,7 @@
 using osu.Game.Audio;
 using osu.Game.IO;
 using osu.Game.IO.Archives;
+using osu.Game.Screens.Menu;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Play.HUD.HitErrorMeters;
 using osu.Game.Skinning;
@@ -107,7 +108,7 @@ public void TestDeserialiseModifiedDefault()
                 var skin = new TestSkin(new SkinInfo(), null, storage);
 
                 Assert.That(skin.LayoutInfos, Has.Count.EqualTo(2));
-                Assert.That(skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.MainHUDComponents].AllDrawables.ToArray(), Has.Length.EqualTo(9));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.ToArray(), Has.Length.EqualTo(9));
             }
         }
 
@@ -120,8 +121,20 @@ public void TestDeserialiseModifiedArgon()
                 var skin = new TestSkin(new SkinInfo(), null, storage);
 
                 Assert.That(skin.LayoutInfos, Has.Count.EqualTo(2));
-                Assert.That(skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.MainHUDComponents].AllDrawables.ToArray(), Has.Length.EqualTo(10));
-                Assert.That(skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(PlayerName)));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.ToArray(), Has.Length.EqualTo(10));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(PlayerName)));
+            }
+        }
+
+        [Test]
+        public void TestDeserialiseInvalidDrawables()
+        {
+            using (var stream = TestResources.OpenResource("Archives/argon-invalid-drawable.osk"))
+            using (var storage = new ZipArchiveReader(stream))
+            {
+                var skin = new TestSkin(new SkinInfo(), null, storage);
+
+                Assert.That(skin.LayoutInfos.Any(kvp => kvp.Value.AllDrawables.Any(d => d.Type == typeof(StarFountain))), Is.False);
             }
         }
 
@@ -134,10 +147,10 @@ public void TestDeserialiseModifiedClassic()
                 var skin = new TestSkin(new SkinInfo(), null, storage);
 
                 Assert.That(skin.LayoutInfos, Has.Count.EqualTo(2));
-                Assert.That(skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.MainHUDComponents].AllDrawables.ToArray(), Has.Length.EqualTo(6));
-                Assert.That(skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.SongSelect].AllDrawables.ToArray(), Has.Length.EqualTo(1));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.ToArray(), Has.Length.EqualTo(6));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.SongSelect].AllDrawables.ToArray(), Has.Length.EqualTo(1));
 
-                var skinnableInfo = skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.SongSelect].AllDrawables.First();
+                var skinnableInfo = skin.LayoutInfos[GlobalSkinnableContainers.SongSelect].AllDrawables.First();
 
                 Assert.That(skinnableInfo.Type, Is.EqualTo(typeof(SkinnableSprite)));
                 Assert.That(skinnableInfo.Settings.First().Key, Is.EqualTo("sprite_name"));
@@ -148,10 +161,10 @@ public void TestDeserialiseModifiedClassic()
             using (var storage = new ZipArchiveReader(stream))
             {
                 var skin = new TestSkin(new SkinInfo(), null, storage);
-                Assert.That(skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.MainHUDComponents].AllDrawables.ToArray(), Has.Length.EqualTo(8));
-                Assert.That(skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(UnstableRateCounter)));
-                Assert.That(skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(ColourHitErrorMeter)));
-                Assert.That(skin.LayoutInfos[SkinComponentsContainerLookup.TargetArea.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(LegacySongProgress)));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.ToArray(), Has.Length.EqualTo(8));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(UnstableRateCounter)));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(ColourHitErrorMeter)));
+                Assert.That(skin.LayoutInfos[GlobalSkinnableContainers.MainHUDComponents].AllDrawables.Select(i => i.Type), Contains.Item(typeof(LegacySongProgress)));
             }
         }
 
diff --git a/osu.Game.Tests/Utils/BindableValueAccessorTest.cs b/osu.Game.Tests/Utils/BindableValueAccessorTest.cs
new file mode 100644
index 000000000000..f09623dbfc4c
--- /dev/null
+++ b/osu.Game.Tests/Utils/BindableValueAccessorTest.cs
@@ -0,0 +1,52 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Game.Utils;
+
+namespace osu.Game.Tests.Utils
+{
+    [TestFixture]
+    public class BindableValueAccessorTest
+    {
+        [Test]
+        public void GetValue()
+        {
+            const int value = 1337;
+
+            BindableInt bindable = new BindableInt(value);
+            Assert.That(BindableValueAccessor.GetValue(bindable), Is.EqualTo(value));
+        }
+
+        [Test]
+        public void SetValue()
+        {
+            const int value = 1337;
+
+            BindableInt bindable = new BindableInt();
+            BindableValueAccessor.SetValue(bindable, value);
+
+            Assert.That(bindable.Value, Is.EqualTo(value));
+        }
+
+        [Test]
+        public void GetInvalidBindable()
+        {
+            BindableList<object> list = new BindableList<object>();
+            Assert.That(BindableValueAccessor.GetValue(list), Is.EqualTo(list));
+        }
+
+        [Test]
+        public void SetInvalidBindable()
+        {
+            const int value = 1337;
+
+            BindableList<int> list = new BindableList<int> { value };
+            BindableValueAccessor.SetValue(list, 2);
+
+            Assert.That(list, Has.Exactly(1).Items);
+            Assert.That(list[0], Is.EqualTo(value));
+        }
+    }
+}
diff --git a/osu.Game.Tests/Utils/GeometryUtilsTest.cs b/osu.Game.Tests/Utils/GeometryUtilsTest.cs
new file mode 100644
index 000000000000..f73175bb5ba5
--- /dev/null
+++ b/osu.Game.Tests/Utils/GeometryUtilsTest.cs
@@ -0,0 +1,51 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Utils;
+using osuTK;
+
+namespace osu.Game.Tests.Utils
+{
+    [TestFixture]
+    public class GeometryUtilsTest
+    {
+        [TestCase(new int[] { }, new int[] { })]
+        [TestCase(new[] { 0, 0 }, new[] { 0, 0 })]
+        [TestCase(new[] { 0, 0, 1, 1, 1, -1, 2, 0 }, new[] { 0, 0, 1, 1, 2, 0, 1, -1 })]
+        [TestCase(new[] { 0, 0, 1, 1, 1, -1, 2, 0, 1, 0 }, new[] { 0, 0, 1, 1, 2, 0, 1, -1 })]
+        [TestCase(new[] { 0, 0, 1, 1, 2, -1, 2, 0, 1, 0, 4, 10 }, new[] { 0, 0, 4, 10, 2, -1 })]
+        public void TestConvexHull(int[] values, int[] expected)
+        {
+            var points = new Vector2[values.Length / 2];
+            for (int i = 0; i < values.Length; i += 2)
+                points[i / 2] = new Vector2(values[i], values[i + 1]);
+
+            var expectedPoints = new Vector2[expected.Length / 2];
+            for (int i = 0; i < expected.Length; i += 2)
+                expectedPoints[i / 2] = new Vector2(expected[i], expected[i + 1]);
+
+            var hull = GeometryUtils.GetConvexHull(points);
+
+            Assert.That(hull, Is.EquivalentTo(expectedPoints));
+        }
+
+        [TestCase(new int[] { }, 0, 0, 0)]
+        [TestCase(new[] { 0, 0 }, 0, 0, 0)]
+        [TestCase(new[] { 0, 0, 1, 1, 1, -1, 2, 0 }, 1, 0, 1)]
+        [TestCase(new[] { 0, 0, 1, 1, 1, -1, 2, 0, 1, 0 }, 1, 0, 1)]
+        [TestCase(new[] { 0, 0, 1, 1, 2, -1, 2, 0, 1, 0, 4, 10 }, 3, 4.5f, 5.5901699f)]
+        public void TestMinimumEnclosingCircle(int[] values, float x, float y, float r)
+        {
+            var points = new Vector2[values.Length / 2];
+            for (int i = 0; i < values.Length; i += 2)
+                points[i / 2] = new Vector2(values[i], values[i + 1]);
+
+            (var centre, float radius) = GeometryUtils.MinimumEnclosingCircle(points);
+
+            Assert.That(centre.X, Is.EqualTo(x).Within(0.0001));
+            Assert.That(centre.Y, Is.EqualTo(y).Within(0.0001));
+            Assert.That(radius, Is.EqualTo(r).Within(0.0001));
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
index aac7689b1b3e..d8be57382f32 100644
--- a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
+++ b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
@@ -18,6 +18,7 @@
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -48,13 +49,18 @@ public partial class TestSceneUserDimBackgrounds : ScreenTestScene
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
+            DetachedBeatmapStore detachedBeatmapStore;
+
             Dependencies.Cache(rulesets = new RealmRulesetStore(Realm));
             Dependencies.Cache(manager = new BeatmapManager(LocalStorage, Realm, null, audio, Resources, host, Beatmap.Default));
             Dependencies.Cache(new OsuConfigManager(LocalStorage));
+            Dependencies.Cache(detachedBeatmapStore = new DetachedBeatmapStore());
             Dependencies.Cache(Realm);
 
             manager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
 
+            Add(detachedBeatmapStore);
+
             Beatmap.SetDefault();
         }
 
diff --git a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeIntro.cs b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeIntro.cs
index a3541d957e4a..f1a2d6b5f2a3 100644
--- a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeIntro.cs
+++ b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeIntro.cs
@@ -2,19 +2,21 @@
 // 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.Screens;
-using osu.Framework.Testing;
+using osu.Game.Configuration;
 using osu.Game.Online.API;
 using osu.Game.Online.Metadata;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Tests.Resources;
+using osu.Game.Screens.Menu;
+using osu.Game.Screens.OnlinePlay.DailyChallenge;
 using osu.Game.Tests.Visual.Metadata;
 using osu.Game.Tests.Visual.OnlinePlay;
+using osuTK.Graphics;
+using osuTK.Input;
 using CreateRoomRequest = osu.Game.Online.Rooms.CreateRoomRequest;
 
 namespace osu.Game.Tests.Visual.DailyChallenge
@@ -27,63 +29,61 @@ public partial class TestSceneDailyChallengeIntro : OnlinePlayTestScene
         [Cached(typeof(INotificationOverlay))]
         private NotificationOverlay notificationOverlay = new NotificationOverlay();
 
+        private Room room = null!;
+
         [BackgroundDependencyLoader]
         private void load()
         {
-            base.Content.Add(notificationOverlay);
-            base.Content.Add(metadataClient);
+            Add(notificationOverlay);
+            Add(metadataClient);
+
+            // add button to observe for daily challenge changes and perform its logic.
+            Add(new DailyChallengeButton(@"button-default-select", new Color4(102, 68, 204, 255), _ => { }, 0, Key.D));
         }
 
         [Test]
-        [Solo]
         public void TestDailyChallenge()
         {
-            var room = new Room
-            {
-                RoomID = { Value = 1234 },
-                Name = { Value = "Daily Challenge: June 4, 2024" },
-                Playlist =
-                {
-                    new PlaylistItem(CreateAPIBeatmapSet().Beatmaps.First())
-                    {
-                        RequiredMods = [new APIMod(new OsuModTraceable())],
-                        AllowedMods = [new APIMod(new OsuModDoubleTime())]
-                    }
-                },
-                EndDate = { Value = DateTimeOffset.Now.AddHours(12) },
-                Category = { Value = RoomCategory.DailyChallenge }
-            };
-
-            AddStep("add room", () => API.Perform(new CreateRoomRequest(room)));
-            AddStep("push screen", () => LoadScreen(new Screens.OnlinePlay.DailyChallenge.DailyChallengeIntro(room)));
+            startChallenge(1234);
+            AddStep("push screen", () => LoadScreen(new DailyChallengeIntro(room)));
         }
 
         [Test]
-        public void TestNotifications()
+        public void TestPlayIntroOnceFlag()
+        {
+            startChallenge(1234);
+            AddStep("set intro played flag", () => Dependencies.Get<SessionStatics>().SetValue(Static.DailyChallengeIntroPlayed, true));
+
+            startChallenge(1235);
+
+            AddAssert("intro played flag reset", () => Dependencies.Get<SessionStatics>().Get<bool>(Static.DailyChallengeIntroPlayed), () => Is.False);
+
+            AddStep("push screen", () => LoadScreen(new DailyChallengeIntro(room)));
+            AddUntilStep("intro played flag set", () => Dependencies.Get<SessionStatics>().Get<bool>(Static.DailyChallengeIntroPlayed), () => Is.True);
+        }
+
+        private void startChallenge(int roomId)
         {
-            var room = new Room
+            AddStep("add room", () =>
             {
-                RoomID = { Value = 1234 },
-                Name = { Value = "Daily Challenge: June 4, 2024" },
-                Playlist =
+                API.Perform(new CreateRoomRequest(room = new Room
                 {
-                    new PlaylistItem(TestResources.CreateTestBeatmapSetInfo().Beatmaps.First())
+                    RoomID = { Value = roomId },
+                    Name = { Value = "Daily Challenge: June 4, 2024" },
+                    Playlist =
                     {
-                        RequiredMods = [new APIMod(new OsuModTraceable())],
-                        AllowedMods = [new APIMod(new OsuModDoubleTime())]
-                    }
-                },
-                EndDate = { Value = DateTimeOffset.Now.AddHours(12) },
-                Category = { Value = RoomCategory.DailyChallenge }
-            };
-
-            AddStep("add room", () => API.Perform(new CreateRoomRequest(room)));
-            AddStep("set daily challenge info", () => metadataClient.DailyChallengeInfo.Value = new DailyChallengeInfo { RoomID = 1234 });
-
-            Screens.OnlinePlay.DailyChallenge.DailyChallenge screen = null!;
-            AddStep("push screen", () => LoadScreen(screen = new Screens.OnlinePlay.DailyChallenge.DailyChallenge(room)));
-            AddUntilStep("wait for screen", () => screen.IsCurrentScreen());
-            AddStep("daily challenge ended", () => metadataClient.DailyChallengeInfo.Value = null);
+                        new PlaylistItem(CreateAPIBeatmap(new OsuRuleset().RulesetInfo))
+                        {
+                            RequiredMods = [new APIMod(new OsuModTraceable())],
+                            AllowedMods = [new APIMod(new OsuModDoubleTime())]
+                        }
+                    },
+                    StartDate = { Value = DateTimeOffset.Now },
+                    EndDate = { Value = DateTimeOffset.Now.AddHours(24) },
+                    Category = { Value = RoomCategory.DailyChallenge }
+                }));
+            });
+            AddStep("signal client", () => metadataClient.DailyChallengeUpdated(new DailyChallengeInfo { RoomID = roomId }));
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs b/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
index 28763051e375..2bf07d8e274f 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
@@ -84,6 +84,7 @@ public override void Begin()
 
                 targetContainer = getTargetContainer();
                 initialRotation = targetContainer!.Rotation;
+                DefaultOrigin = ToLocalSpace(targetContainer.ToScreenSpace(Vector2.Zero));
 
                 base.Begin();
             }
@@ -134,7 +135,7 @@ public override void Begin()
                 OriginalSurroundingQuad = new Quad(targetContainer!.X, targetContainer.Y, targetContainer.Width, targetContainer.Height);
             }
 
-            public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+            public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
             {
                 if (targetContainer == null)
                     throw new InvalidOperationException($"Cannot {nameof(Update)} a scale operation without calling {nameof(Begin)} first!");
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneComposerSelection.cs b/osu.Game.Tests/Visual/Editing/TestSceneComposerSelection.cs
index 3884a3108fee..8cc91d68b5c3 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneComposerSelection.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneComposerSelection.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Testing;
@@ -36,6 +37,9 @@ private ComposeBlueprintContainer blueprintContainer
         private ContextMenuContainer contextMenuContainer
             => Editor.ChildrenOfType<ContextMenuContainer>().First();
 
+        private SelectionBoxScaleHandle getScaleHandle(Anchor anchor)
+            => Editor.ChildrenOfType<SelectionBoxScaleHandle>().First(it => it.Anchor == anchor);
+
         private void moveMouseToObject(Func<HitObject> targetFunc)
         {
             AddStep("move mouse to object", () =>
@@ -215,6 +219,51 @@ public void TestMultiSelect()
             AddAssert("2 hitobjects selected", () => EditorBeatmap.SelectedHitObjects.Count == 2 && !EditorBeatmap.SelectedHitObjects.Contains(addedObjects[1]));
         }
 
+        [Test]
+        public void TestMultiSelectWithDragBox()
+        {
+            var addedObjects = new[]
+            {
+                new HitCircle { StartTime = 100 },
+                new HitCircle { StartTime = 200, Position = new Vector2(100) },
+                new HitCircle { StartTime = 300, Position = new Vector2(512, 0) },
+                new HitCircle { StartTime = 400, Position = new Vector2(412, 100) },
+            };
+            AddStep("add hitobjects", () => EditorBeatmap.AddRange(addedObjects));
+
+            AddStep("start dragging", () =>
+            {
+                InputManager.MoveMouseTo(blueprintContainer.ScreenSpaceDrawQuad.Centre);
+                InputManager.PressButton(MouseButton.Left);
+            });
+            AddStep("drag to left corner", () => InputManager.MoveMouseTo(blueprintContainer.ScreenSpaceDrawQuad.TopLeft - new Vector2(5)));
+            AddStep("end dragging", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("2 hitobjects selected", () => EditorBeatmap.SelectedHitObjects, () => Has.Count.EqualTo(2));
+
+            AddStep("start dragging with control", () =>
+            {
+                InputManager.MoveMouseTo(blueprintContainer.ScreenSpaceDrawQuad.Centre);
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.PressKey(Key.ControlLeft);
+            });
+            AddStep("drag to left corner", () => InputManager.MoveMouseTo(blueprintContainer.ScreenSpaceDrawQuad.TopRight + new Vector2(5, -5)));
+            AddStep("end dragging", () => InputManager.ReleaseButton(MouseButton.Left));
+            AddStep("release control", () => InputManager.ReleaseKey(Key.ControlLeft));
+
+            AddAssert("4 hitobjects selected", () => EditorBeatmap.SelectedHitObjects, () => Has.Count.EqualTo(4));
+
+            AddStep("start dragging without control", () =>
+            {
+                InputManager.MoveMouseTo(blueprintContainer.ScreenSpaceDrawQuad.Centre);
+                InputManager.PressButton(MouseButton.Left);
+            });
+            AddStep("drag to left corner", () => InputManager.MoveMouseTo(blueprintContainer.ScreenSpaceDrawQuad.TopRight + new Vector2(5, -5)));
+            AddStep("end dragging", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("2 hitobjects selected", () => EditorBeatmap.SelectedHitObjects, () => Has.Count.EqualTo(2));
+        }
+
         [Test]
         public void TestNearestSelection()
         {
@@ -519,5 +568,137 @@ public void TestQuickDeleteRemovesSliderControlPoint()
 
             AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
         }
+
+        [Test]
+        public void TestShiftModifierMaintainsAspectRatio()
+        {
+            HitCircle[] addedObjects = null!;
+
+            float aspectRatioBeforeDrag = 0;
+
+            float getAspectRatio() => (addedObjects[1].X - addedObjects[0].X) / (addedObjects[1].Y - addedObjects[0].Y);
+
+            AddStep("add hitobjects", () =>
+            {
+                EditorBeatmap.AddRange(addedObjects = new[]
+                {
+                    new HitCircle { StartTime = 100, Position = new Vector2(150, 150) },
+                    new HitCircle { StartTime = 200, Position = new Vector2(250, 200) },
+                });
+
+                aspectRatioBeforeDrag = getAspectRatio();
+            });
+
+            AddStep("select objects", () => EditorBeatmap.SelectedHitObjects.AddRange(addedObjects));
+
+            AddStep("move mouse to handle", () => InputManager.MoveMouseTo(getScaleHandle(Anchor.BottomRight).ScreenSpaceDrawQuad.Centre));
+
+            AddStep("begin drag", () => InputManager.PressButton(MouseButton.Left));
+
+            AddStep("move mouse", () => InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(50, 0)));
+
+            AddStep("aspect ratio does not equal", () => Assert.AreNotEqual(aspectRatioBeforeDrag, getAspectRatio()));
+
+            AddStep("press shift", () => InputManager.PressKey(Key.ShiftLeft));
+
+            AddStep("aspect ratio does equal", () => Assert.AreEqual(aspectRatioBeforeDrag, getAspectRatio()));
+
+            AddStep("end drag", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
+        }
+
+        [Test]
+        public void TestAltModifierScalesAroundCenter()
+        {
+            HitCircle[] addedObjects = null!;
+
+            Vector2 centerBeforeDrag = Vector2.Zero;
+
+            Vector2 getCenter() => (addedObjects[0].Position + addedObjects[1].Position) / 2;
+
+            AddStep("add hitobjects", () =>
+            {
+                EditorBeatmap.AddRange(addedObjects = new[]
+                {
+                    new HitCircle { StartTime = 100, Position = new Vector2(150, 150) },
+                    new HitCircle { StartTime = 200, Position = new Vector2(250, 200) },
+                });
+
+                centerBeforeDrag = getCenter();
+            });
+
+            AddStep("select objects", () => EditorBeatmap.SelectedHitObjects.AddRange(addedObjects));
+
+            AddStep("move mouse to handle", () => InputManager.MoveMouseTo(getScaleHandle(Anchor.BottomRight).ScreenSpaceDrawQuad.Centre));
+
+            AddStep("begin drag", () => InputManager.PressButton(MouseButton.Left));
+
+            AddStep("move mouse", () => InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(50, 0)));
+
+            AddStep("center does not equal", () => Assert.AreNotEqual(centerBeforeDrag, getCenter()));
+
+            AddStep("press alt", () => InputManager.PressKey(Key.AltLeft));
+
+            AddStep("center does equal", () => Assert.AreEqual(centerBeforeDrag, getCenter()));
+
+            AddStep("end drag", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddStep("release alt", () => InputManager.ReleaseKey(Key.AltLeft));
+        }
+
+        [Test]
+        public void TestShiftAndAltModifierKeys()
+        {
+            HitCircle[] addedObjects = null!;
+
+            float aspectRatioBeforeDrag = 0;
+
+            Vector2 centerBeforeDrag = Vector2.Zero;
+
+            float getAspectRatio() => (addedObjects[1].X - addedObjects[0].X) / (addedObjects[1].Y - addedObjects[0].Y);
+
+            Vector2 getCenter() => (addedObjects[0].Position + addedObjects[1].Position) / 2;
+
+            AddStep("add hitobjects", () =>
+            {
+                EditorBeatmap.AddRange(addedObjects = new[]
+                {
+                    new HitCircle { StartTime = 100, Position = new Vector2(150, 150) },
+                    new HitCircle { StartTime = 200, Position = new Vector2(250, 200) },
+                });
+
+                aspectRatioBeforeDrag = getAspectRatio();
+                centerBeforeDrag = getCenter();
+            });
+
+            AddStep("select objects", () => EditorBeatmap.SelectedHitObjects.AddRange(addedObjects));
+
+            AddStep("move mouse to handle", () => InputManager.MoveMouseTo(getScaleHandle(Anchor.BottomRight).ScreenSpaceDrawQuad.Centre));
+
+            AddStep("begin drag", () => InputManager.PressButton(MouseButton.Left));
+
+            AddStep("move mouse", () => InputManager.MoveMouseTo(InputManager.CurrentState.Mouse.Position + new Vector2(50, 0)));
+
+            AddStep("aspect ratio does not equal", () => Assert.AreNotEqual(aspectRatioBeforeDrag, getAspectRatio()));
+
+            AddStep("center does not equal", () => Assert.AreNotEqual(centerBeforeDrag, getCenter()));
+
+            AddStep("press shift", () => InputManager.PressKey(Key.ShiftLeft));
+
+            AddStep("aspect ratio does equal", () => Assert.AreEqual(aspectRatioBeforeDrag, getAspectRatio()));
+
+            AddStep("center does not equal", () => Assert.AreNotEqual(centerBeforeDrag, getCenter()));
+
+            AddStep("press alt", () => InputManager.PressKey(Key.AltLeft));
+
+            AddStep("center does equal", () => Assert.AreEqual(centerBeforeDrag, getCenter()));
+
+            AddStep("end drag", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
+
+            AddStep("release alt", () => InputManager.ReleaseKey(Key.AltLeft));
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneDistanceSnapGrid.cs b/osu.Game.Tests/Visual/Editing/TestSceneDistanceSnapGrid.cs
index f2a015402a7a..c1a788cd22bf 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneDistanceSnapGrid.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneDistanceSnapGrid.cs
@@ -199,7 +199,7 @@ private class SnapProvider : IDistanceSnapProvider
 
             public double FindSnappedDuration(HitObject referenceObject, float distance) => 0;
 
-            public float FindSnappedDistance(HitObject referenceObject, float distance) => 0;
+            public float FindSnappedDistance(HitObject referenceObject, float distance, DistanceSnapTarget target) => 0;
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneEditorSummaryTimeline.cs b/osu.Game.Tests/Visual/Editing/TestSceneEditorSummaryTimeline.cs
index ddca2f85533f..677d3135ba8a 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorSummaryTimeline.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorSummaryTimeline.cs
@@ -24,7 +24,10 @@ public TestSceneEditorSummaryTimeline()
 
             beatmap.ControlPointInfo.Add(100000, new TimingControlPoint { BeatLength = 100 });
             beatmap.ControlPointInfo.Add(50000, new DifficultyControlPoint { SliderVelocity = 2 });
+            beatmap.ControlPointInfo.Add(80000, new EffectControlPoint { KiaiMode = true });
+            beatmap.ControlPointInfo.Add(110000, new EffectControlPoint { KiaiMode = false });
             beatmap.BeatmapInfo.Bookmarks = new[] { 75000, 125000 };
+            beatmap.Breaks.Add(new ManualBreakPeriod(90000, 120000));
 
             editorBeatmap = new EditorBeatmap(beatmap);
         }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
index 5c1b9b4986b8..f0eadf8f9e19 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
@@ -7,6 +7,7 @@
 using NUnit.Framework;
 using osu.Framework.Input;
 using osu.Framework.Testing;
+using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
@@ -307,6 +308,46 @@ public void TestNodeSamplePopover()
             hitObjectNodeHasSampleVolume(0, 1, 10);
         }
 
+        [Test]
+        public void TestSamplePointSeek()
+        {
+            AddStep("add slider", () =>
+            {
+                EditorBeatmap.Clear();
+                EditorBeatmap.Add(new Slider
+                {
+                    Position = new Vector2(256, 256),
+                    StartTime = 0,
+                    Path = new SliderPath(new[] { new PathControlPoint(Vector2.Zero), new PathControlPoint(new Vector2(250, 0)) }),
+                    Samples =
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
+                    },
+                    NodeSamples =
+                    {
+                        new List<HitSampleInfo> { new HitSampleInfo(HitSampleInfo.HIT_NORMAL) },
+                        new List<HitSampleInfo> { new HitSampleInfo(HitSampleInfo.HIT_NORMAL) },
+                    },
+                    RepeatCount = 1
+                });
+            });
+
+            seekSamplePiece(-1);
+            editorTimeIs(0);
+            samplePopoverIsOpen();
+            seekSamplePiece(-1);
+            editorTimeIs(0);
+            samplePopoverIsOpen();
+            seekSamplePiece(1);
+            editorTimeIs(406);
+            seekSamplePiece(1);
+            editorTimeIs(813);
+            seekSamplePiece(1);
+            editorTimeIs(1627);
+            seekSamplePiece(1);
+            editorTimeIs(1627);
+        }
+
         [Test]
         public void TestHotkeysMultipleSelectionWithSameSampleBank()
         {
@@ -658,6 +699,63 @@ public void TestHotkeysAffectNodeSamples()
             hitObjectNodeHasSamples(2, 1, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_WHISTLE);
         }
 
+        [Test]
+        public void TestHotkeysUnifySliderSamplesAndNodeSamples()
+        {
+            AddStep("add slider", () =>
+            {
+                EditorBeatmap.Clear();
+                EditorBeatmap.Add(new Slider
+                {
+                    Position = new Vector2(256, 256),
+                    StartTime = 1000,
+                    Path = new SliderPath(new[] { new PathControlPoint(Vector2.Zero), new PathControlPoint(new Vector2(250, 0)) }),
+                    Samples =
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL, HitSampleInfo.BANK_SOFT),
+                        new HitSampleInfo(HitSampleInfo.HIT_WHISTLE, bank: HitSampleInfo.BANK_DRUM),
+                    },
+                    NodeSamples = new List<IList<HitSampleInfo>>
+                    {
+                        new List<HitSampleInfo>
+                        {
+                            new HitSampleInfo(HitSampleInfo.HIT_NORMAL, bank: HitSampleInfo.BANK_DRUM),
+                            new HitSampleInfo(HitSampleInfo.HIT_CLAP, bank: HitSampleInfo.BANK_DRUM),
+                        },
+                        new List<HitSampleInfo>
+                        {
+                            new HitSampleInfo(HitSampleInfo.HIT_NORMAL, bank: HitSampleInfo.BANK_SOFT),
+                            new HitSampleInfo(HitSampleInfo.HIT_WHISTLE, bank: HitSampleInfo.BANK_SOFT),
+                        },
+                    }
+                });
+            });
+            AddStep("select everything", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
+
+            AddStep("set soft bank", () =>
+            {
+                InputManager.PressKey(Key.LShift);
+                InputManager.Key(Key.E);
+                InputManager.ReleaseKey(Key.LShift);
+            });
+
+            hitObjectHasSampleBank(0, HitSampleInfo.BANK_SOFT);
+            hitObjectHasSamples(0, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_WHISTLE);
+            hitObjectNodeHasSampleBank(0, 0, HitSampleInfo.BANK_SOFT);
+            hitObjectNodeHasSamples(0, 0, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_CLAP);
+            hitObjectNodeHasSampleBank(0, 1, HitSampleInfo.BANK_SOFT);
+            hitObjectNodeHasSamples(0, 1, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_WHISTLE);
+
+            AddStep("unify whistle addition", () => InputManager.Key(Key.W));
+
+            hitObjectHasSampleBank(0, HitSampleInfo.BANK_SOFT);
+            hitObjectHasSamples(0, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_WHISTLE);
+            hitObjectNodeHasSampleBank(0, 0, HitSampleInfo.BANK_SOFT);
+            hitObjectNodeHasSamples(0, 0, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_CLAP, HitSampleInfo.HIT_WHISTLE);
+            hitObjectNodeHasSampleBank(0, 1, HitSampleInfo.BANK_SOFT);
+            hitObjectNodeHasSamples(0, 1, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_WHISTLE);
+        }
+
         [Test]
         public void TestSelectingObjectDoesNotMutateSamples()
         {
@@ -679,7 +777,7 @@ public void TestSelectingObjectDoesNotMutateSamples()
 
         private void clickSamplePiece(int objectIndex) => AddStep($"click {objectIndex.ToOrdinalWords()} sample piece", () =>
         {
-            var samplePiece = this.ChildrenOfType<SamplePointPiece>().Single(piece => piece.HitObject == EditorBeatmap.HitObjects.ElementAt(objectIndex));
+            var samplePiece = this.ChildrenOfType<SamplePointPiece>().Single(piece => piece is not NodeSamplePointPiece && piece.HitObject == EditorBeatmap.HitObjects.ElementAt(objectIndex));
 
             InputManager.MoveMouseTo(samplePiece);
             InputManager.Click(MouseButton.Left);
@@ -693,6 +791,21 @@ private void clickNodeSamplePiece(int objectIndex, int nodeIndex) => AddStep($"c
             InputManager.Click(MouseButton.Left);
         });
 
+        private void seekSamplePiece(int direction) => AddStep($"seek sample piece {direction}", () =>
+        {
+            InputManager.PressKey(Key.ControlLeft);
+            InputManager.PressKey(Key.ShiftLeft);
+            InputManager.Key(direction < 1 ? Key.Left : Key.Right);
+            InputManager.ReleaseKey(Key.ShiftLeft);
+            InputManager.ReleaseKey(Key.ControlLeft);
+        });
+
+        private void samplePopoverIsOpen() => AddUntilStep("sample popover is open", () =>
+        {
+            var popover = this.ChildrenOfType<SamplePointPiece.SampleEditPopover>().SingleOrDefault(o => o.IsPresent);
+            return popover != null;
+        });
+
         private void samplePopoverHasNoFocus() => AddUntilStep("sample popover textbox not focused", () =>
         {
             var popover = this.ChildrenOfType<SamplePointPiece.SampleEditPopover>().SingleOrDefault();
@@ -837,5 +950,7 @@ private void hitObjectNodeHasSampleAdditionBank(int objectIndex, int nodeIndex,
             var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
             return h is not null && h.NodeSamples[nodeIndex].Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
         });
+
+        private void editorTimeIs(double time) => AddAssert($"editor time is {time}", () => Precision.AlmostEquals(EditorClock.CurrentTimeAccurate, time, 1));
     }
 }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneOpenEditorTimestamp.cs b/osu.Game.Tests/Visual/Editing/TestSceneOpenEditorTimestamp.cs
index 1f46a088314d..971eb223eba8 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneOpenEditorTimestamp.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneOpenEditorTimestamp.cs
@@ -36,7 +36,7 @@ public void TestErrorNotifications()
                 () => Is.EqualTo(1));
 
             AddStep("enter song select", () => Game.ChildrenOfType<ButtonSystem>().Single().OnSolo?.Invoke());
-            AddUntilStep("entered song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
+            AddUntilStep("entered song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect && songSelect.BeatmapSetsLoaded);
 
             addStepClickLink("00:00:000 (1)", waitForSeek: false);
             AddUntilStep("received 'must be in edit'",
@@ -138,7 +138,7 @@ private void setUpEditor(RulesetInfo ruleset)
             AddUntilStep("Wait for song select", () =>
                 Game.Beatmap.Value.BeatmapSetInfo.Equals(beatmapSet)
                 && Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect
-                && songSelect.IsLoaded
+                && songSelect.BeatmapSetsLoaded
             );
             AddStep("Switch ruleset", () => Game.Ruleset.Value = ruleset);
             AddStep("Open editor for ruleset", () =>
diff --git a/osu.Game.Tests/Visual/Editing/TestScenePlacementBlueprint.cs b/osu.Game.Tests/Visual/Editing/TestScenePlacementBlueprint.cs
index 8e15edcda4c2..966e6513bb54 100644
--- a/osu.Game.Tests/Visual/Editing/TestScenePlacementBlueprint.cs
+++ b/osu.Game.Tests/Visual/Editing/TestScenePlacementBlueprint.cs
@@ -96,32 +96,6 @@ public void TestCommitPlacementViaRightClick()
             AddAssert("slider placed", () => EditorBeatmap.HitObjects.Count, () => Is.EqualTo(1));
         }
 
-        [Test]
-        public void TestCommitPlacementViaGlobalAction()
-        {
-            Playfield playfield = null!;
-
-            AddStep("select slider placement tool", () => InputManager.Key(Key.Number3));
-            AddStep("move mouse to top left of playfield", () =>
-            {
-                playfield = this.ChildrenOfType<Playfield>().Single();
-                var location = (3 * playfield.ScreenSpaceDrawQuad.TopLeft + playfield.ScreenSpaceDrawQuad.BottomRight) / 4;
-                InputManager.MoveMouseTo(location);
-            });
-            AddStep("begin placement", () => InputManager.Click(MouseButton.Left));
-            AddStep("move mouse to bottom right of playfield", () =>
-            {
-                var location = (playfield.ScreenSpaceDrawQuad.TopLeft + 3 * playfield.ScreenSpaceDrawQuad.BottomRight) / 4;
-                InputManager.MoveMouseTo(location);
-            });
-            AddStep("confirm via global action", () =>
-            {
-                globalActionContainer.TriggerPressed(GlobalAction.Select);
-                globalActionContainer.TriggerReleased(GlobalAction.Select);
-            });
-            AddAssert("slider placed", () => EditorBeatmap.HitObjects.Count, () => Is.EqualTo(1));
-        }
-
         [Test]
         public void TestAbortPlacementViaGlobalAction()
         {
@@ -276,11 +250,7 @@ public void TestNodeSamplesAndSamplesAreSame()
                 var location = (playfield.ScreenSpaceDrawQuad.TopLeft + 3 * playfield.ScreenSpaceDrawQuad.BottomRight) / 4;
                 InputManager.MoveMouseTo(location);
             });
-            AddStep("confirm via global action", () =>
-            {
-                globalActionContainer.TriggerPressed(GlobalAction.Select);
-                globalActionContainer.TriggerReleased(GlobalAction.Select);
-            });
+            AddStep("confirm via right click", () => InputManager.Click(MouseButton.Right));
             AddAssert("slider placed", () => EditorBeatmap.HitObjects.Count, () => Is.EqualTo(1));
 
             AddAssert("slider samples have drum bank", () => EditorBeatmap.HitObjects[0].Samples.All(s => s.Bank == HitSampleInfo.BANK_DRUM));
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneTimingScreen.cs b/osu.Game.Tests/Visual/Editing/TestSceneTimingScreen.cs
index 6181024230e5..cf07ce24315a 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneTimingScreen.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneTimingScreen.cs
@@ -114,40 +114,6 @@ public void TestSelectedRetainedOverUndo()
             });
         }
 
-        [Test]
-        public void TestTrackingCurrentTimeWhileRunning()
-        {
-            AddStep("Select first effect point", () =>
-            {
-                InputManager.MoveMouseTo(Child.ChildrenOfType<EffectRowAttribute>().First());
-                InputManager.Click(MouseButton.Left);
-            });
-
-            AddUntilStep("Selection changed", () => timingScreen.SelectedGroup.Value.Time == 54670);
-            AddUntilStep("Ensure seeked to correct time", () => EditorClock.CurrentTimeAccurate == 54670);
-
-            AddStep("Seek to just before next point", () => EditorClock.Seek(69000));
-            AddStep("Start clock", () => EditorClock.Start());
-
-            AddUntilStep("Selection changed", () => timingScreen.SelectedGroup.Value.Time == 69670);
-        }
-
-        [Test]
-        public void TestTrackingCurrentTimeWhilePaused()
-        {
-            AddStep("Select first effect point", () =>
-            {
-                InputManager.MoveMouseTo(Child.ChildrenOfType<EffectRowAttribute>().First());
-                InputManager.Click(MouseButton.Left);
-            });
-
-            AddUntilStep("Selection changed", () => timingScreen.SelectedGroup.Value.Time == 54670);
-            AddUntilStep("Ensure seeked to correct time", () => EditorClock.CurrentTimeAccurate == 54670);
-
-            AddStep("Seek to later", () => EditorClock.Seek(80000));
-            AddUntilStep("Selection changed", () => timingScreen.SelectedGroup.Value.Time == 69670);
-        }
-
         [Test]
         public void TestScrollControlGroupIntoView()
         {
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
index 3b88750013a8..c7f1eabab235 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
@@ -5,6 +5,7 @@
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
@@ -136,6 +137,59 @@ public void TestCalibrationFromNonZero()
             AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
         }
 
+        [Test]
+        public void TestCalibrationFromNonZeroWithImmediateReferenceScore()
+        {
+            const double average_error = -4.5;
+            const double initial_offset = -2;
+
+            AddStep("Set beatmap offset non-neutral", () => Realm.Write(r =>
+            {
+                r.Add(new BeatmapInfo
+                {
+                    ID = Beatmap.Value.BeatmapInfo.ID,
+                    Ruleset = Beatmap.Value.BeatmapInfo.Ruleset,
+                    UserSettings =
+                    {
+                        Offset = initial_offset,
+                    }
+                });
+            }));
+
+            AddStep("Create control with preloaded reference score", () =>
+            {
+                Child = new PlayerSettingsGroup("Some settings")
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        offsetControl = new BeatmapOffsetControl
+                        {
+                            ReferenceScore =
+                            {
+                                Value = new ScoreInfo
+                                {
+                                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error),
+                                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
+                                }
+                            }
+                        }
+                    }
+                };
+            });
+
+            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>()));
+        }
+
         [Test]
         public void TestCalibrationNoChange()
         {
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapSkinFallbacks.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapSkinFallbacks.cs
index a2ce62105ecf..5ec32f318cee 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapSkinFallbacks.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapSkinFallbacks.cs
@@ -37,8 +37,8 @@ public partial class TestSceneBeatmapSkinFallbacks : OsuPlayerTestScene
         public void TestEmptyLegacyBeatmapSkinFallsBack()
         {
             CreateSkinTest(TrianglesSkin.CreateInfo(), () => new LegacyBeatmapSkin(new BeatmapInfo(), null));
-            AddUntilStep("wait for hud load", () => Player.ChildrenOfType<SkinComponentsContainer>().All(c => c.ComponentsLoaded));
-            AddAssert("hud from default skin", () => AssertComponentsFromExpectedSource(SkinComponentsContainerLookup.TargetArea.MainHUDComponents, skinManager.CurrentSkin.Value));
+            AddUntilStep("wait for hud load", () => Player.ChildrenOfType<SkinnableContainer>().All(c => c.ComponentsLoaded));
+            AddAssert("hud from default skin", () => AssertComponentsFromExpectedSource(GlobalSkinnableContainers.MainHUDComponents, skinManager.CurrentSkin.Value));
         }
 
         protected void CreateSkinTest(SkinInfo gameCurrentSkin, Func<ISkin> getBeatmapSkin)
@@ -53,9 +53,9 @@ protected void CreateSkinTest(SkinInfo gameCurrentSkin, Func<ISkin> getBeatmapSk
             });
         }
 
-        protected bool AssertComponentsFromExpectedSource(SkinComponentsContainerLookup.TargetArea target, ISkin expectedSource)
+        protected bool AssertComponentsFromExpectedSource(GlobalSkinnableContainers target, ISkin expectedSource)
         {
-            var targetContainer = Player.ChildrenOfType<SkinComponentsContainer>().First(s => s.Lookup.Target == target);
+            var targetContainer = Player.ChildrenOfType<SkinnableContainer>().First(s => s.Lookup.Lookup == target);
             var actualComponentsContainer = targetContainer.ChildrenOfType<Container>().SingleOrDefault(c => c.Parent == targetContainer);
 
             if (actualComponentsContainer == null)
@@ -63,7 +63,7 @@ protected bool AssertComponentsFromExpectedSource(SkinComponentsContainerLookup.
 
             var actualInfo = actualComponentsContainer.CreateSerialisedInfo();
 
-            var expectedComponentsContainer = expectedSource.GetDrawableComponent(new SkinComponentsContainerLookup(target)) as Container;
+            var expectedComponentsContainer = expectedSource.GetDrawableComponent(new GlobalSkinnableContainerLookup(target)) as Container;
             if (expectedComponentsContainer == null)
                 return false;
 
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneBreakTracker.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneBreakTracker.cs
index c010b2c80913..21b64958650a 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneBreakTracker.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneBreakTracker.cs
@@ -7,9 +7,13 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play;
+using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -28,14 +32,20 @@ public partial class TestSceneBreakTracker : OsuTestScene
 
         public TestSceneBreakTracker()
         {
-            AddRange(new Drawable[]
+            Children = new Drawable[]
             {
+                new Box
+                {
+                    Colour = Color4.White,
+                    RelativeSizeAxes = Axes.Both,
+                },
                 breakTracker = new TestBreakTracker(),
-                breakOverlay = new BreakOverlay(true, null)
+                breakOverlay = new BreakOverlay(true, new ScoreProcessor(new OsuRuleset()))
                 {
                     ProcessCustomClock = false,
+                    BreakTracker = breakTracker,
                 }
-            });
+            };
         }
 
         protected override void Update()
@@ -48,9 +58,6 @@ protected override void Update()
         [Test]
         public void TestShowBreaks()
         {
-            setClock(false);
-
-            addShowBreakStep(2);
             addShowBreakStep(5);
             addShowBreakStep(15);
         }
@@ -115,7 +122,7 @@ private void addShowBreakStep(double seconds)
         {
             AddStep($"show '{seconds}s' break", () =>
             {
-                breakOverlay.Breaks = breakTracker.Breaks = new List<BreakPeriod>
+                breakTracker.Breaks = new List<BreakPeriod>
                 {
                     new BreakPeriod(Clock.CurrentTime, Clock.CurrentTime + seconds * 1000)
                 };
@@ -129,7 +136,7 @@ private void setClock(bool useManual)
 
         private void loadBreaksStep(string breakDescription, IReadOnlyList<BreakPeriod> breaks)
         {
-            AddStep($"load {breakDescription}", () => breakOverlay.Breaks = breakTracker.Breaks = breaks);
+            AddStep($"load {breakDescription}", () => breakTracker.Breaks = breaks);
             seekAndAssertBreak("seek back to 0", 0, false);
         }
 
@@ -175,6 +182,7 @@ public double ManualClockTime
             }
 
             public TestBreakTracker()
+                : base(0, new ScoreProcessor(new OsuRuleset()))
             {
                 FramedManualClock = new FramedClock(manualClock = new ManualClock());
                 ProcessCustomClock = false;
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs
index 16b2a54a4546..d51c9b3f8836 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneHUDOverlay.cs
@@ -43,7 +43,7 @@ public partial class TestSceneHUDOverlay : OsuManualInputManagerTestScene
         private readonly IGameplayClock gameplayClock = new GameplayClockContainer(new TrackVirtual(60000), false, false);
 
         // best way to check without exposing.
-        private Drawable hideTarget => hudOverlay.ChildrenOfType<SkinComponentsContainer>().First();
+        private Drawable hideTarget => hudOverlay.ChildrenOfType<SkinnableContainer>().First();
         private Drawable keyCounterContent => hudOverlay.ChildrenOfType<KeyCounterDisplay>().First().ChildrenOfType<Drawable>().Skip(1).First();
 
         public TestSceneHUDOverlay()
@@ -174,6 +174,7 @@ public void TestHoldForMenuDoesWorkWhenHidden()
                 holdForMenu.Action += () => activated = true;
             });
 
+            AddStep("set hold button always visible", () => localConfig.SetValue(OsuSetting.AlwaysShowHoldForMenuButton, true));
             AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
             AddUntilStep("hidetarget is hidden", () => hideTarget.Alpha, () => Is.LessThanOrEqualTo(0));
 
@@ -214,6 +215,7 @@ public void TestInputDoesntWorkWhenHUDHidden()
                 progress.ChildrenOfType<ArgonSongProgressBar>().Single().OnSeek += _ => seeked = true;
             });
 
+            AddStep("set hold button always visible", () => localConfig.SetValue(OsuSetting.AlwaysShowHoldForMenuButton, true));
             AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
             AddUntilStep("hidetarget is hidden", () => hideTarget.Alpha, () => Is.LessThanOrEqualTo(0));
 
@@ -240,8 +242,8 @@ public void TestHiddenHUDDoesntBlockComponentUpdates()
 
             createNew();
 
-            AddUntilStep("wait for components to be hidden", () => hudOverlay.ChildrenOfType<SkinComponentsContainer>().Single().Alpha == 0);
-            AddUntilStep("wait for hud load", () => hudOverlay.ChildrenOfType<SkinComponentsContainer>().All(c => c.ComponentsLoaded));
+            AddUntilStep("wait for components to be hidden", () => hudOverlay.ChildrenOfType<SkinnableContainer>().Single().Alpha == 0);
+            AddUntilStep("wait for hud load", () => hudOverlay.ChildrenOfType<SkinnableContainer>().All(c => c.ComponentsLoaded));
 
             AddStep("bind on update", () =>
             {
@@ -258,10 +260,10 @@ public void TestHiddenHUDDoesntBlockSkinnableComponentsLoad()
 
             createNew();
 
-            AddUntilStep("wait for components to be hidden", () => hudOverlay.ChildrenOfType<SkinComponentsContainer>().Single().Alpha == 0);
+            AddUntilStep("wait for components to be hidden", () => hudOverlay.ChildrenOfType<SkinnableContainer>().Single().Alpha == 0);
 
-            AddStep("reload components", () => hudOverlay.ChildrenOfType<SkinComponentsContainer>().Single().Reload());
-            AddUntilStep("skinnable components loaded", () => hudOverlay.ChildrenOfType<SkinComponentsContainer>().Single().ComponentsLoaded);
+            AddStep("reload components", () => hudOverlay.ChildrenOfType<SkinnableContainer>().Single().Reload());
+            AddUntilStep("skinnable components loaded", () => hudOverlay.ChildrenOfType<SkinnableContainer>().Single().ComponentsLoaded);
         }
 
         private void createNew(Action<HUDOverlay>? action = null)
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneHoldForMenuButton.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneHoldForMenuButton.cs
index 3c225d60e049..cd1334165b3c 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneHoldForMenuButton.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneHoldForMenuButton.cs
@@ -1,13 +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.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
+using osu.Game.Configuration;
 using osu.Game.Screens.Play.HUD;
 using osuTK;
 using osuTK.Input;
@@ -21,11 +21,19 @@ public partial class TestSceneHoldForMenuButton : OsuManualInputManagerTestScene
 
         protected override double TimePerAction => 100; // required for the early exit test, since hold-to-confirm delay is 200ms
 
-        private HoldForMenuButton holdForMenuButton;
+        private HoldForMenuButton holdForMenuButton = null!;
+
+        [Resolved]
+        private OsuConfigManager config { get; set; } = null!;
 
         [SetUpSteps]
         public void SetUpSteps()
         {
+            AddStep("set button always on", () =>
+            {
+                config.SetValue(OsuSetting.AlwaysShowHoldForMenuButton, true);
+            });
+
             AddStep("create button", () =>
             {
                 exitAction = false;
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneLeadIn.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneLeadIn.cs
index 5a71369976a2..5af7540f6f02 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneLeadIn.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneLeadIn.cs
@@ -27,6 +27,7 @@ public partial class TestSceneLeadIn : RateAdjustedBeatmapTestScene
         [TestCase(2000, 0)]
         [TestCase(3000, first_hit_object - 3000)]
         [TestCase(10000, first_hit_object - 10000)]
+        [FlakyTest]
         public void TestLeadInProducesCorrectStartTime(double leadIn, double expectedStartTime)
         {
             loadPlayerWithBeatmap(new TestBeatmap(new OsuRuleset().RulesetInfo)
@@ -41,6 +42,7 @@ public void TestLeadInProducesCorrectStartTime(double leadIn, double expectedSta
         [TestCase(0, 0)]
         [TestCase(-1000, -1000)]
         [TestCase(-10000, -10000)]
+        [FlakyTest]
         public void TestStoryboardProducesCorrectStartTimeSimpleAlpha(double firstStoryboardEvent, double expectedStartTime)
         {
             var storyboard = new Storyboard();
@@ -64,6 +66,7 @@ public void TestStoryboardProducesCorrectStartTimeSimpleAlpha(double firstStoryb
         [TestCase(0, 0, true)]
         [TestCase(-1000, -1000, true)]
         [TestCase(-10000, -10000, true)]
+        [FlakyTest]
         public void TestStoryboardProducesCorrectStartTimeFadeInAfterOtherEvents(double firstStoryboardEvent, double expectedStartTime, bool addEventToLoop)
         {
             const double loop_start_time = -20000;
diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs
index 030f2592ed19..6aa2c4e40dac 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePause.cs
@@ -320,6 +320,8 @@ public void TestQuickExitFromGameplay()
         [Test]
         public void TestExitViaHoldToExit()
         {
+            AddStep("set hold button always visible", () => LocalConfig.SetValue(OsuSetting.AlwaysShowHoldForMenuButton, true));
+
             AddStep("exit", () =>
             {
                 InputManager.MoveMouseTo(Player.HUDOverlay.HoldToQuit.First(c => c is HoldToConfirmContainer));
diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePauseInputHandling.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePauseInputHandling.cs
index bc66947ccd2b..2c0d7d674489 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePauseInputHandling.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePauseInputHandling.cs
@@ -47,6 +47,16 @@ public partial class TestScenePauseInputHandling : PlayerTestScene
                 {
                     Position = OsuPlayfield.BASE_SIZE / 2,
                     StartTime = 5000,
+                },
+                new HitCircle
+                {
+                    Position = OsuPlayfield.BASE_SIZE / 2,
+                    StartTime = 10000,
+                },
+                new HitCircle
+                {
+                    Position = OsuPlayfield.BASE_SIZE / 2,
+                    StartTime = 15000,
                 }
             }
         };
@@ -256,7 +266,7 @@ public void TestManiaHeldInputRemainHeldAfterResume()
         }
 
         [Test]
-        public void TestOsuRegisterInputFromPressingOrangeCursorButPressIsBlocked()
+        public void TestOsuHitCircleNotReceivingInputOnResume()
         {
             KeyCounter counter = null!;
 
@@ -281,19 +291,82 @@ public void TestOsuRegisterInputFromPressingOrangeCursorButPressIsBlocked()
             AddAssert("button is released in kbc", () => !Player.DrawableRuleset.Playfield.FindClosestParent<OsuInputManager>()!.PressedActions.Any());
         }
 
+        [Test]
+        public void TestOsuHitCircleNotReceivingInputOnResume_PauseWhileHoldingSameKey()
+        {
+            KeyCounter counter = null!;
+
+            loadPlayer(() => new OsuRuleset());
+            AddStep("get key counter", () => counter = this.ChildrenOfType<KeyCounter>().Single(k => k.Trigger is KeyCounterActionTrigger<OsuAction> actionTrigger && actionTrigger.Action == OsuAction.LeftButton));
+
+            AddStep("press Z", () => InputManager.PressKey(Key.Z));
+            AddAssert("circle hit", () => Player.ScoreProcessor.HighestCombo.Value, () => Is.EqualTo(1));
+
+            AddStep("pause", () => Player.Pause());
+            AddStep("release Z", () => InputManager.ReleaseKey(Key.Z));
+
+            AddStep("resume", () => Player.Resume());
+            AddStep("go to resume cursor", () => InputManager.MoveMouseTo(this.ChildrenOfType<OsuResumeOverlay.OsuClickToResumeCursor>().Single()));
+            AddStep("press Z to resume", () => InputManager.PressKey(Key.Z));
+            AddStep("release Z", () => InputManager.ReleaseKey(Key.Z));
+
+            checkKey(() => counter, 1, false);
+
+            seekTo(5000);
+
+            AddStep("press Z", () => InputManager.PressKey(Key.Z));
+
+            checkKey(() => counter, 2, true);
+            AddAssert("circle hit", () => Player.ScoreProcessor.HighestCombo.Value, () => Is.EqualTo(2));
+
+            AddStep("release Z", () => InputManager.ReleaseKey(Key.Z));
+            checkKey(() => counter, 2, false);
+        }
+
+        [Test]
+        public void TestOsuHitCircleNotReceivingInputOnResume_PauseWhileHoldingOtherKey()
+        {
+            loadPlayer(() => new OsuRuleset());
+
+            AddStep("press X", () => InputManager.PressKey(Key.X));
+            AddAssert("circle hit", () => Player.ScoreProcessor.HighestCombo.Value, () => Is.EqualTo(1));
+
+            seekTo(5000);
+
+            AddStep("pause", () => Player.Pause());
+            AddStep("release X", () => InputManager.ReleaseKey(Key.X));
+
+            AddStep("resume", () => Player.Resume());
+            AddStep("go to resume cursor", () => InputManager.MoveMouseTo(this.ChildrenOfType<OsuResumeOverlay.OsuClickToResumeCursor>().Single()));
+            AddStep("press Z to resume", () => InputManager.PressKey(Key.Z));
+            AddStep("release Z", () => InputManager.ReleaseKey(Key.Z));
+
+            AddAssert("circle not hit", () => Player.ScoreProcessor.HighestCombo.Value, () => Is.EqualTo(1));
+
+            AddStep("press X", () => InputManager.PressKey(Key.X));
+            AddStep("release X", () => InputManager.ReleaseKey(Key.X));
+
+            AddAssert("circle hit", () => Player.ScoreProcessor.HighestCombo.Value, () => Is.EqualTo(2));
+        }
+
         private void loadPlayer(Func<Ruleset> createRuleset)
         {
             AddStep("set ruleset", () => currentRuleset = createRuleset());
             AddStep("load player", LoadPlayer);
             AddUntilStep("player loaded", () => Player.IsLoaded && Player.Alpha == 1);
-            AddUntilStep("wait for hud", () => Player.HUDOverlay.ChildrenOfType<SkinComponentsContainer>().All(s => s.ComponentsLoaded));
+            AddUntilStep("wait for hud", () => Player.HUDOverlay.ChildrenOfType<SkinnableContainer>().All(s => s.ComponentsLoaded));
 
-            AddStep("seek to gameplay", () => Player.GameplayClockContainer.Seek(0));
-            AddUntilStep("wait for seek to finish", () => Player.DrawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(0).Within(500));
+            seekTo(0);
             AddAssert("not in break", () => !Player.IsBreakTime.Value);
             AddStep("move cursor to center", () => InputManager.MoveMouseTo(Player.DrawableRuleset.Playfield));
         }
 
+        private void seekTo(double time)
+        {
+            AddStep($"seek to {time}ms", () => Player.GameplayClockContainer.Seek(time));
+            AddUntilStep("wait for seek to finish", () => Player.DrawableRuleset.FrameStableClock.CurrentTime, () => Is.EqualTo(time).Within(500));
+        }
+
         private void checkKey(Func<KeyCounter> counter, int count, bool active)
         {
             AddAssert($"key count = {count}", () => counter().CountPresses.Value, () => Is.EqualTo(count));
diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs
index 5e22e4757241..c382f0828b15 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePlayerScoreSubmission.cs
@@ -8,7 +8,9 @@
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Screens;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
@@ -26,6 +28,7 @@
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
 using osu.Game.Tests.Beatmaps;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -177,6 +180,30 @@ public void TestNoSubmissionOnEmptyFail()
             AddAssert("ensure no submission", () => Player.SubmittedScore == null);
         }
 
+        [Test]
+        public void TestEmptyFailStillImports()
+        {
+            prepareTestAPI(true);
+
+            createPlayerTest(true);
+
+            AddUntilStep("wait for token request", () => Player.TokenCreationRequested);
+
+            AddUntilStep("wait for fail", () => Player.GameplayState.HasFailed);
+            AddUntilStep("wait for fail overlay", () => Player.FailOverlay.State.Value, () => Is.EqualTo(Visibility.Visible));
+
+            AddStep("attempt import", () =>
+            {
+                InputManager.MoveMouseTo(Player.ChildrenOfType<SaveFailedScoreButton>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+            AddUntilStep("wait for import to start", () => Player.ScoreImportStarted);
+            AddStep("allow import", () => Player.AllowImportCompletion.Release());
+
+            AddUntilStep("import completed", () => Player.ImportedScore, () => Is.Not.Null);
+            AddAssert("ensure no submission", () => Player.SubmittedScore, () => Is.Null);
+        }
+
         [Test]
         public void TestSubmissionOnFail()
         {
@@ -378,6 +405,8 @@ protected partial class FakeImportingPlayer : TestPlayer
             public SemaphoreSlim AllowImportCompletion { get; }
             public Score ImportedScore { get; private set; }
 
+            public new FailOverlay FailOverlay => base.FailOverlay;
+
             public FakeImportingPlayer(bool allowPause = true, bool showResults = true, bool pauseOnFocusLost = false)
                 : base(allowPause, showResults, pauseOnFocusLost)
             {
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.cs
index 7466442674cf..91188f5bacd8 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.cs
@@ -46,7 +46,7 @@ public partial class TestSceneSkinEditor : PlayerTestScene
         [Resolved]
         private SkinManager skins { get; set; } = null!;
 
-        private SkinComponentsContainer targetContainer => Player.ChildrenOfType<SkinComponentsContainer>().First();
+        private SkinnableContainer targetContainer => Player.ChildrenOfType<SkinnableContainer>().First();
 
         [SetUpSteps]
         public override void SetUpSteps()
@@ -75,7 +75,7 @@ public void TestDragSelection()
 
             AddStep("Add big black boxes", () =>
             {
-                var target = Player.ChildrenOfType<SkinComponentsContainer>().First();
+                var target = Player.ChildrenOfType<SkinnableContainer>().First();
                 target.Add(box1 = new BigBlackBox
                 {
                     Position = new Vector2(-90),
@@ -200,14 +200,14 @@ public void TestCyclicSelection()
         [Test]
         public void TestUndoEditHistory()
         {
-            SkinComponentsContainer firstTarget = null!;
+            SkinnableContainer firstTarget = null!;
             TestSkinEditorChangeHandler changeHandler = null!;
             byte[] defaultState = null!;
             IEnumerable<ISerialisableDrawable> testComponents = null!;
 
             AddStep("Load necessary things", () =>
             {
-                firstTarget = Player.ChildrenOfType<SkinComponentsContainer>().First();
+                firstTarget = Player.ChildrenOfType<SkinnableContainer>().First();
                 changeHandler = new TestSkinEditorChangeHandler(firstTarget);
 
                 changeHandler.SaveState();
@@ -377,11 +377,11 @@ public void TestCopyPaste()
                 () => Is.EqualTo(3));
         }
 
-        private SkinComponentsContainer globalHUDTarget => Player.ChildrenOfType<SkinComponentsContainer>()
-                                                                 .Single(c => c.Lookup.Target == SkinComponentsContainerLookup.TargetArea.MainHUDComponents && c.Lookup.Ruleset == null);
+        private SkinnableContainer globalHUDTarget => Player.ChildrenOfType<SkinnableContainer>()
+                                                            .Single(c => c.Lookup.Lookup == GlobalSkinnableContainers.MainHUDComponents && c.Lookup.Ruleset == null);
 
-        private SkinComponentsContainer rulesetHUDTarget => Player.ChildrenOfType<SkinComponentsContainer>()
-                                                                  .Single(c => c.Lookup.Target == SkinComponentsContainerLookup.TargetArea.MainHUDComponents && c.Lookup.Ruleset != null);
+        private SkinnableContainer rulesetHUDTarget => Player.ChildrenOfType<SkinnableContainer>()
+                                                             .Single(c => c.Lookup.Lookup == GlobalSkinnableContainers.MainHUDComponents && c.Lookup.Ruleset != null);
 
         [Test]
         public void TestMigrationArgon()
@@ -440,8 +440,8 @@ public void TestMigrationLegacy()
 
             AddStep("import old classic skin", () => skins.CurrentSkinInfo.Value = importedSkin = importSkinFromArchives(@"classic-layout-version-0.osk").SkinInfo);
             AddUntilStep("wait for load", () => globalHUDTarget.ComponentsLoaded && rulesetHUDTarget.ComponentsLoaded);
-            AddAssert("no combo in global target", () => !globalHUDTarget.Components.OfType<LegacyComboCounter>().Any());
-            AddAssert("combo placed in ruleset target", () => rulesetHUDTarget.Components.OfType<LegacyComboCounter>().Count() == 1);
+            AddAssert("no combo in global target", () => !globalHUDTarget.Components.OfType<LegacyDefaultComboCounter>().Any());
+            AddAssert("combo placed in ruleset target", () => rulesetHUDTarget.Components.OfType<LegacyDefaultComboCounter>().Count() == 1);
 
             AddStep("add combo to global target", () => globalHUDTarget.Add(new LegacyDefaultComboCounter
             {
@@ -454,8 +454,8 @@ public void TestMigrationLegacy()
             AddStep("select another skin", () => skins.CurrentSkinInfo.SetDefault());
             AddStep("select skin again", () => skins.CurrentSkinInfo.Value = importedSkin);
             AddUntilStep("wait for load", () => globalHUDTarget.ComponentsLoaded && rulesetHUDTarget.ComponentsLoaded);
-            AddAssert("combo placed in global target", () => globalHUDTarget.Components.OfType<LegacyComboCounter>().Count() == 1);
-            AddAssert("combo placed in ruleset target", () => rulesetHUDTarget.Components.OfType<LegacyComboCounter>().Count() == 1);
+            AddAssert("combo placed in global target", () => globalHUDTarget.Components.OfType<LegacyDefaultComboCounter>().Count() == 1);
+            AddAssert("combo placed in ruleset target", () => rulesetHUDTarget.Components.OfType<LegacyDefaultComboCounter>().Count() == 1);
         }
 
         private Skin importSkinFromArchives(string filename)
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditorComponentsList.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditorComponentsList.cs
index b7b2a6c1750d..b5fe6633b625 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditorComponentsList.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditorComponentsList.cs
@@ -20,7 +20,7 @@ public partial class TestSceneSkinEditorComponentsList : SkinnableTestScene
         [Test]
         public void TestToggleEditor()
         {
-            var skinComponentsContainer = new SkinComponentsContainer(new SkinComponentsContainerLookup(SkinComponentsContainerLookup.TargetArea.SongSelect));
+            var skinComponentsContainer = new SkinnableContainer(new GlobalSkinnableContainerLookup(GlobalSkinnableContainers.SongSelect));
 
             AddStep("show available components", () => SetContents(_ => new SkinComponentToolbox(skinComponentsContainer, null)
             {
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.cs
index d1e224a91052..fcaa2996e1fd 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableHUDOverlay.cs
@@ -45,7 +45,7 @@ public partial class TestSceneSkinnableHUDOverlay : SkinnableTestScene
         private IEnumerable<HUDOverlay> hudOverlays => CreatedDrawables.OfType<HUDOverlay>();
 
         // best way to check without exposing.
-        private Drawable hideTarget => hudOverlay.ChildrenOfType<SkinComponentsContainer>().First();
+        private Drawable hideTarget => hudOverlay.ChildrenOfType<SkinnableContainer>().First();
         private Drawable keyCounterFlow => hudOverlay.ChildrenOfType<KeyCounterDisplay>().First().ChildrenOfType<FillFlowContainer<KeyCounter>>().Single();
 
         public TestSceneSkinnableHUDOverlay()
@@ -101,7 +101,7 @@ private void createNew(Action<HUDOverlay> action = null)
             });
             AddUntilStep("HUD overlay loaded", () => hudOverlay.IsAlive);
             AddUntilStep("components container loaded",
-                () => hudOverlay.ChildrenOfType<SkinComponentsContainer>().Any(scc => scc.ComponentsLoaded));
+                () => hudOverlay.ChildrenOfType<SkinnableContainer>().Any(scc => scc.ComponentsLoaded));
         }
 
         protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSpectator.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSpectator.cs
index 0de2b6a9807d..d8817e563cef 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSpectator.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSpectator.cs
@@ -19,6 +19,7 @@
 using osu.Game.Scoring;
 using osu.Game.Screens;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD.JudgementCounter;
 using osu.Game.Tests.Beatmaps.IO;
 using osu.Game.Tests.Gameplay;
 using osu.Game.Tests.Visual.Multiplayer;
@@ -167,14 +168,16 @@ public void TestPlayStartsWithNoFrames()
         public void TestSpectatingDuringGameplay()
         {
             start();
-            sendFrames(300);
+            sendFrames(300, initialResultCount: 100);
 
             loadSpectatingScreen();
             waitForPlayerCurrent();
 
-            sendFrames(300);
+            sendFrames(300, initialResultCount: 100);
 
             AddUntilStep("playing from correct point in time", () => player.ChildrenOfType<DrawableRuleset>().First().FrameStableClock.CurrentTime, () => Is.GreaterThan(30000));
+            AddAssert("check judgement counts are correct", () => player.ChildrenOfType<JudgementCountController>().Single().Counters.Sum(c => c.ResultCount.Value),
+                () => Is.GreaterThanOrEqualTo(100));
         }
 
         [Test]
@@ -405,9 +408,9 @@ private double currentFrameStableTime
         private void checkPaused(bool state) =>
             AddUntilStep($"game is {(state ? "paused" : "playing")}", () => player.ChildrenOfType<DrawableRuleset>().First().IsPaused.Value == state);
 
-        private void sendFrames(int count = 10, double startTime = 0)
+        private void sendFrames(int count = 10, double startTime = 0, int initialResultCount = 0)
         {
-            AddStep("send frames", () => spectatorClient.SendFramesFromUser(streamingUser.Id, count, startTime));
+            AddStep("send frames", () => spectatorClient.SendFramesFromUser(streamingUser.Id, count, startTime, initialResultCount));
         }
 
         private void loadSpectatingScreen()
diff --git a/osu.Game.Tests/Visual/Menus/TestSceneStarFountain.cs b/osu.Game.Tests/Visual/Menus/TestSceneStarFountain.cs
index bb327e596223..29fa7287d254 100644
--- a/osu.Game.Tests/Visual/Menus/TestSceneStarFountain.cs
+++ b/osu.Game.Tests/Visual/Menus/TestSceneStarFountain.cs
@@ -4,17 +4,17 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Screens.Menu;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Tests.Visual.Menus
 {
     [TestFixture]
     public partial class TestSceneStarFountain : OsuTestScene
     {
-        [SetUpSteps]
-        public void SetUpSteps()
+        [Test]
+        public void TestMenu()
         {
             AddStep("make fountains", () =>
             {
@@ -34,11 +34,7 @@ public void SetUpSteps()
                     },
                 };
             });
-        }
 
-        [Test]
-        public void TestPew()
-        {
             AddRepeatStep("activate fountains sometimes", () =>
             {
                 foreach (var fountain in Children.OfType<StarFountain>())
@@ -48,5 +44,34 @@ public void TestPew()
                 }
             }, 150);
         }
+
+        [Test]
+        public void TestGameplay()
+        {
+            AddStep("make fountains", () =>
+            {
+                Children = new[]
+                {
+                    new KiaiGameplayFountains.GameplayStarFountain
+                    {
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft,
+                        X = 75,
+                    },
+                    new KiaiGameplayFountains.GameplayStarFountain
+                    {
+                        Anchor = Anchor.BottomRight,
+                        Origin = Anchor.BottomRight,
+                        X = -75,
+                    },
+                };
+            });
+
+            AddStep("activate fountains", () =>
+            {
+                ((StarFountain)Children[0]).Shoot(1);
+                ((StarFountain)Children[1]).Shoot(-1);
+            });
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Menus/TestSceneToolbarUserButton.cs b/osu.Game.Tests/Visual/Menus/TestSceneToolbarUserButton.cs
index 1a4ca6597524..71a45e239852 100644
--- a/osu.Game.Tests/Visual/Menus/TestSceneToolbarUserButton.cs
+++ b/osu.Game.Tests/Visual/Menus/TestSceneToolbarUserButton.cs
@@ -97,6 +97,7 @@ public void TestStates()
         public void TestTransientUserStatisticsDisplay()
         {
             AddStep("Log in", () => dummyAPI.Login("wang", "jang"));
+
             AddStep("Gain", () =>
             {
                 var transientUpdateDisplay = this.ChildrenOfType<TransientUserStatisticsUpdateDisplay>().Single();
@@ -113,6 +114,7 @@ public void TestTransientUserStatisticsDisplay()
                         PP = 1357
                     });
             });
+
             AddStep("Loss", () =>
             {
                 var transientUpdateDisplay = this.ChildrenOfType<TransientUserStatisticsUpdateDisplay>().Single();
@@ -129,7 +131,9 @@ public void TestTransientUserStatisticsDisplay()
                         PP = 1234
                     });
             });
-            AddStep("No change", () =>
+
+            // Tests flooring logic works as expected.
+            AddStep("Tiny increase in PP", () =>
             {
                 var transientUpdateDisplay = this.ChildrenOfType<TransientUserStatisticsUpdateDisplay>().Single();
                 transientUpdateDisplay.LatestUpdate.Value = new UserStatisticsUpdate(
@@ -137,14 +141,32 @@ public void TestTransientUserStatisticsDisplay()
                     new UserStatistics
                     {
                         GlobalRank = 111_111,
-                        PP = 1357
+                        PP = 1357.6m
                     },
                     new UserStatistics
                     {
                         GlobalRank = 111_111,
-                        PP = 1357
+                        PP = 1358.1m
                     });
             });
+
+            AddStep("No change 1", () =>
+            {
+                var transientUpdateDisplay = this.ChildrenOfType<TransientUserStatisticsUpdateDisplay>().Single();
+                transientUpdateDisplay.LatestUpdate.Value = new UserStatisticsUpdate(
+                    new ScoreInfo(),
+                    new UserStatistics
+                    {
+                        GlobalRank = 111_111,
+                        PP = 1357m
+                    },
+                    new UserStatistics
+                    {
+                        GlobalRank = 111_111,
+                        PP = 1357.1m
+                    });
+            });
+
             AddStep("Was null", () =>
             {
                 var transientUpdateDisplay = this.ChildrenOfType<TransientUserStatisticsUpdateDisplay>().Single();
@@ -161,6 +183,7 @@ public void TestTransientUserStatisticsDisplay()
                         PP = 1357
                     });
             });
+
             AddStep("Became null", () =>
             {
                 var transientUpdateDisplay = this.ChildrenOfType<TransientUserStatisticsUpdateDisplay>().Single();
diff --git a/osu.Game.Tests/Visual/Multiplayer/QueueModeTestScene.cs b/osu.Game.Tests/Visual/Multiplayer/QueueModeTestScene.cs
index 0f1ba9ba7516..8bcd5aab1c29 100644
--- a/osu.Game.Tests/Visual/Multiplayer/QueueModeTestScene.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/QueueModeTestScene.cs
@@ -12,6 +12,7 @@
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
@@ -45,9 +46,14 @@ public abstract partial class QueueModeTestScene : ScreenTestScene
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
+            DetachedBeatmapStore detachedBeatmapStore;
+
             Dependencies.Cache(new RealmRulesetStore(Realm));
             Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, Realm, null, audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(detachedBeatmapStore = new DetachedBeatmapStore());
             Dependencies.Cache(Realm);
+
+            Add(detachedBeatmapStore);
         }
 
         public override void SetUpSteps()
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
index ad7e21135456..df2021dbaf1c 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
@@ -19,6 +19,7 @@
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
@@ -65,9 +66,14 @@ public partial class TestSceneMultiplayer : ScreenTestScene
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
+            DetachedBeatmapStore detachedBeatmapStore;
+
             Dependencies.Cache(new RealmRulesetStore(Realm));
             Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, Realm, API, audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(detachedBeatmapStore = new DetachedBeatmapStore());
             Dependencies.Cache(Realm);
+
+            Add(detachedBeatmapStore);
         }
 
         public override void SetUpSteps()
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSongSelect.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSongSelect.cs
index 8dc41cd70750..88cc7eb9b32a 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSongSelect.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSongSelect.cs
@@ -45,11 +45,16 @@ public partial class TestSceneMultiplayerMatchSongSelect : MultiplayerTestScene
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
+            DetachedBeatmapStore detachedBeatmapStore;
+
             Dependencies.Cache(rulesets = new RealmRulesetStore(Realm));
             Dependencies.Cache(manager = new BeatmapManager(LocalStorage, Realm, null, audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(detachedBeatmapStore = new DetachedBeatmapStore());
             Dependencies.Cache(Realm);
 
             importedBeatmapSet = manager.Import(TestResources.CreateTestBeatmapSetInfo(8, rulesets.AvailableRulesets.ToArray()));
+
+            Add(detachedBeatmapStore);
         }
 
         public override void SetUpSteps()
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs b/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs
index b0b753fc2211..cc78bed5de58 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs
@@ -12,6 +12,7 @@
 using osu.Framework.Screens;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
@@ -33,13 +34,18 @@ public partial class TestScenePlaylistsSongSelect : OnlinePlayTestScene
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
+            DetachedBeatmapStore detachedBeatmapStore;
+
             Dependencies.Cache(new RealmRulesetStore(Realm));
             Dependencies.Cache(manager = new BeatmapManager(LocalStorage, Realm, null, audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(detachedBeatmapStore = new DetachedBeatmapStore());
             Dependencies.Cache(Realm);
 
             var beatmapSet = TestResources.CreateTestBeatmapSetInfo();
 
             manager.Import(beatmapSet);
+
+            Add(detachedBeatmapStore);
         }
 
         public override void SetUpSteps()
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs
index 5640682d0637..d76e0290efb5 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs
@@ -165,16 +165,19 @@ private void makeMetadataChange(bool commit = true)
         }
 
         [Test]
+        [Solo]
         public void TestEditorGameplayTestAlwaysUsesOriginalRuleset()
         {
             prepareBeatmap();
 
-            AddStep("switch ruleset", () => Game.Ruleset.Value = new ManiaRuleset().RulesetInfo);
+            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)));
+
             AddUntilStep("wait for editor open", () => Game.ScreenStack.CurrentScreen is Editor editor && editor.ReadyForUse);
-            AddStep("test gameplay", () => getEditor().TestGameplay());
+            AddAssert("editor ruleset is osu!", () => Game.Ruleset.Value, () => Is.EqualTo(new OsuRuleset().RulesetInfo));
 
+            AddStep("test gameplay", () => getEditor().TestGameplay());
             AddUntilStep("wait for player", () =>
             {
                 // notifications may fire at almost any inopportune time and cause annoying test failures.
@@ -183,8 +186,7 @@ public void TestEditorGameplayTestAlwaysUsesOriginalRuleset()
                 Game.CloseAllOverlays();
                 return Game.ScreenStack.CurrentScreen is EditorPlayer editorPlayer && editorPlayer.IsLoaded;
             });
-
-            AddAssert("current ruleset is osu!", () => Game.Ruleset.Value.Equals(new OsuRuleset().RulesetInfo));
+            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);
@@ -352,7 +354,7 @@ private void prepareBeatmap()
             AddUntilStep("wait for song select",
                 () => Game.Beatmap.Value.BeatmapSetInfo.Equals(beatmapSet)
                       && Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect
-                      && songSelect.IsLoaded);
+                      && songSelect.BeatmapSetsLoaded);
         }
 
         private void openEditor()
diff --git a/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs b/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
index c0547921686d..f036b4b3ef9f 100644
--- a/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
@@ -176,6 +176,12 @@ private Func<BeatmapSetInfo> importBeatmap(int i, RulesetInfo ruleset = null)
 
         private void confirmBeatmapInSongSelect(Func<BeatmapSetInfo> getImport)
         {
+            AddUntilStep("wait for carousel loaded", () =>
+            {
+                var songSelect = (Screens.Select.SongSelect)Game.ScreenStack.CurrentScreen;
+                return songSelect.ChildrenOfType<BeatmapCarousel>().SingleOrDefault()?.IsLoaded == true;
+            });
+
             AddUntilStep("beatmap in song select", () =>
             {
                 var songSelect = (Screens.Select.SongSelect)Game.ScreenStack.CurrentScreen;
@@ -187,7 +193,7 @@ private void presentAndConfirm(Func<BeatmapSetInfo> getImport)
         {
             AddStep("present beatmap", () => Game.PresentBeatmap(getImport()));
 
-            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is Screens.Select.SongSelect songSelect && songSelect.IsLoaded);
+            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is Screens.Select.SongSelect songSelect && songSelect.BeatmapSetsLoaded);
             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));
         }
@@ -197,7 +203,7 @@ private void presentSecondDifficultyAndConfirm(Func<BeatmapSetInfo> getImport, i
             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.IsLoaded);
+            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is Screens.Select.SongSelect songSelect && songSelect.BeatmapSetsLoaded);
             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/TestSceneScreenNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
index db9ecd90b9fe..eda7ce925a08 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
@@ -144,6 +144,28 @@ public void TestExitSongSelectWithEscape()
             exitViaEscapeAndConfirm();
         }
 
+        [Test]
+        public void TestEnterGameplayWhileFilteringToNoSelection()
+        {
+            TestPlaySongSelect songSelect = null;
+
+            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("force selection", () =>
+            {
+                songSelect.FinaliseSelection();
+                songSelect.FilterControl.CurrentTextSearch.Value = "test";
+            });
+
+            AddUntilStep("wait for player", () => !songSelect.IsCurrentScreen());
+            AddStep("return to song select", () => songSelect.MakeCurrent());
+
+            AddUntilStep("wait for selection lost", () => songSelect.Beatmap.IsDefault);
+        }
+
         [Test]
         public void TestSongSelectBackActionHandling()
         {
@@ -1035,9 +1057,11 @@ public void TestTouchScreenDetectionAtSongSelect()
         [Test]
         public void TestTouchScreenDetectionInGame()
         {
+            BeatmapSetInfo beatmapSet = null;
+
             PushAndConfirm(() => new TestPlaySongSelect());
-            AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
-            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+            AddStep("import beatmap", () => beatmapSet = BeatmapImportHelper.LoadQuickOszIntoOsu(Game).GetResultSafely());
+            AddUntilStep("wait for selected", () => Game.Beatmap.Value.BeatmapSetInfo.Equals(beatmapSet));
             AddStep("select", () => InputManager.Key(Key.Enter));
 
             Player player = null;
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
index 38fb2846aaab..5267a57a054c 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
@@ -336,13 +336,13 @@ public void TestSkinSavesOnChange()
             });
 
             AddStep("change to triangles skin", () => Game.Dependencies.Get<SkinManager>().SetSkinFromConfiguration(SkinInfo.TRIANGLES_SKIN.ToString()));
-            AddUntilStep("components loaded", () => Game.ChildrenOfType<SkinComponentsContainer>().All(c => c.ComponentsLoaded));
+            AddUntilStep("components loaded", () => Game.ChildrenOfType<SkinnableContainer>().All(c => c.ComponentsLoaded));
             // sort of implicitly relies on song select not being skinnable.
             // TODO: revisit if the above ever changes
             AddUntilStep("skin changed", () => !skinEditor.ChildrenOfType<SkinBlueprint>().Any());
 
             AddStep("change back to modified skin", () => Game.Dependencies.Get<SkinManager>().SetSkinFromConfiguration(editedSkinId.ToString()));
-            AddUntilStep("components loaded", () => Game.ChildrenOfType<SkinComponentsContainer>().All(c => c.ComponentsLoaded));
+            AddUntilStep("components loaded", () => Game.ChildrenOfType<SkinnableContainer>().All(c => c.ComponentsLoaded));
             AddUntilStep("changes saved", () => skinEditor.ChildrenOfType<SkinBlueprint>().Any());
         }
 
diff --git a/osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs b/osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs
index a47205094e7e..b6445dec6b53 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs
@@ -446,7 +446,7 @@ public void TestKeyboardCloseAndRestoreChannel()
         {
             AddStep("Show overlay with channel 1", () =>
             {
-                channelManager.JoinChannel(testChannel1);
+                channelManager.CurrentChannel.Value = channelManager.JoinChannel(testChannel1);
                 chatOverlay.Show();
             });
             waitForChannel1Visible();
@@ -462,7 +462,7 @@ public void TestKeyboardNewChannel()
         {
             AddStep("Show overlay with channel 1", () =>
             {
-                channelManager.JoinChannel(testChannel1);
+                channelManager.CurrentChannel.Value = channelManager.JoinChannel(testChannel1);
                 chatOverlay.Show();
             });
             waitForChannel1Visible();
diff --git a/osu.Game.Tests/Visual/Online/TestSceneCommentsContainer.cs b/osu.Game.Tests/Visual/Online/TestSceneCommentsContainer.cs
index acc3c9b8b466..eb805b27cb7b 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneCommentsContainer.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneCommentsContainer.cs
@@ -17,6 +17,7 @@
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.Comments;
+using osu.Game.Overlays.Comments.Buttons;
 
 namespace osu.Game.Tests.Visual.Online
 {
@@ -58,6 +59,11 @@ public void TestSingleCommentsPage(bool withPinned)
             AddStep("show comments", () => commentsContainer.ShowComments(CommentableType.Beatmapset, 123));
             AddUntilStep("show more button hidden",
                 () => commentsContainer.ChildrenOfType<CommentsShowMoreButton>().Single().Alpha == 0);
+
+            if (withPinned)
+                AddAssert("pinned comment replies collapsed", () => commentsContainer.ChildrenOfType<ShowRepliesButton>().First().Expanded.Value, () => Is.False);
+            else
+                AddAssert("first comment replies expanded", () => commentsContainer.ChildrenOfType<ShowRepliesButton>().First().Expanded.Value, () => Is.True);
         }
 
         [TestCase(false)]
@@ -302,7 +308,7 @@ private static CommentBundle getExampleComments(bool withPinned = false)
                 bundle.Comments.Add(new Comment
                 {
                     Id = 20,
-                    Message = "Reply to pinned comment",
+                    Message = "Reply to pinned comment initially hidden",
                     LegacyName = "AbandonedUser",
                     CreatedAt = DateTimeOffset.Now,
                     VotesCount = 0,
diff --git a/osu.Game.Tests/Visual/Online/TestSceneUserProfileDailyChallenge.cs b/osu.Game.Tests/Visual/Online/TestSceneUserProfileDailyChallenge.cs
index f2135ec99289..9db30380f650 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneUserProfileDailyChallenge.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneUserProfileDailyChallenge.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -11,6 +12,7 @@
 using osu.Game.Overlays.Profile;
 using osu.Game.Overlays.Profile.Header.Components;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Scoring;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Online
@@ -60,5 +62,12 @@ private void update(Action<APIUserDailyChallengeStatistics> change)
             change.Invoke(User.Value!.User.DailyChallengeStatistics);
             User.Value = new UserProfileData(User.Value.User, User.Value.Ruleset);
         }
+
+        [Test]
+        public void TestPlayCountRankingTier()
+        {
+            AddAssert("1 before silver", () => DailyChallengeStatsTooltip.TierForPlayCount(30) == RankingTier.Bronze);
+            AddAssert("first silver", () => DailyChallengeStatsTooltip.TierForPlayCount(31) == RankingTier.Silver);
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneCollectionButton.cs b/osu.Game.Tests/Visual/Ranking/TestSceneCollectionButton.cs
new file mode 100644
index 000000000000..5b6721bc0fb2
--- /dev/null
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneCollectionButton.cs
@@ -0,0 +1,67 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Screens.Ranking;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Ranking
+{
+    public partial class TestSceneCollectionButton : OsuManualInputManagerTestScene
+    {
+        private CollectionButton? collectionButton;
+        private readonly BeatmapInfo beatmapInfo = new BeatmapInfo { OnlineID = 88 };
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create button", () => Child = new PopoverContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Child = collectionButton = new CollectionButton(beatmapInfo)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
+            });
+        }
+
+        [Test]
+        public void TestCollectionButton()
+        {
+            AddStep("click collection button", () =>
+            {
+                InputManager.MoveMouseTo(collectionButton!);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("collection popover is visible", () => this.ChildrenOfType<CollectionPopover>().Single().State.Value == Visibility.Visible);
+
+            AddStep("click outside popover", () =>
+            {
+                InputManager.MoveMouseTo(ScreenSpaceDrawQuad.TopLeft);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("collection popover is hidden", () => this.ChildrenOfType<CollectionPopover>().Single().State.Value == Visibility.Hidden);
+
+            AddStep("click collection button", () =>
+            {
+                InputManager.MoveMouseTo(collectionButton!);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("press escape", () => InputManager.Key(Key.Escape));
+
+            AddAssert("collection popover is hidden", () => this.ChildrenOfType<CollectionPopover>().Single().State.Value == Visibility.Hidden);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneFavouriteButton.cs b/osu.Game.Tests/Visual/Ranking/TestSceneFavouriteButton.cs
new file mode 100644
index 000000000000..77a63a39957d
--- /dev/null
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneFavouriteButton.cs
@@ -0,0 +1,82 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Screens.Ranking;
+
+namespace osu.Game.Tests.Visual.Ranking
+{
+    public partial class TestSceneFavouriteButton : OsuTestScene
+    {
+        private FavouriteButton? favourite;
+
+        private readonly BeatmapSetInfo beatmapSetInfo = new BeatmapSetInfo { OnlineID = 88 };
+        private readonly BeatmapSetInfo invalidBeatmapSetInfo = new BeatmapSetInfo();
+
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create button", () => Child = favourite = new FavouriteButton(beatmapSetInfo)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+
+            AddStep("register request handling", () => dummyAPI.HandleRequest = request =>
+            {
+                if (!(request is GetBeatmapSetRequest beatmapSetRequest)) return false;
+
+                beatmapSetRequest.TriggerSuccess(new APIBeatmapSet
+                {
+                    OnlineID = beatmapSetRequest.ID,
+                    HasFavourited = false,
+                    FavouriteCount = 0,
+                });
+
+                return true;
+            });
+        }
+
+        [Test]
+        public void TestLoggedOutIn()
+        {
+            AddStep("log out", () => API.Logout());
+            checkEnabled(false);
+            AddStep("log in", () =>
+            {
+                API.Login("test", "test");
+                ((DummyAPIAccess)API).AuthenticateSecondFactor("abcdefgh");
+            });
+            checkEnabled(true);
+        }
+
+        [Test]
+        public void TestInvalidBeatmap()
+        {
+            AddStep("make beatmap invalid", () => Child = favourite = new FavouriteButton(invalidBeatmapSetInfo)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+            AddStep("log in", () =>
+            {
+                API.Login("test", "test");
+                ((DummyAPIAccess)API).AuthenticateSecondFactor("abcdefgh");
+            });
+            checkEnabled(false);
+        }
+
+        private void checkEnabled(bool expected)
+        {
+            AddAssert("is " + (expected ? "enabled" : "disabled"), () => favourite!.Enabled.Value == expected);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs b/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
index acfa519c8112..f46f76cbb8ad 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
@@ -5,14 +5,18 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using NUnit.Framework;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
@@ -23,6 +27,7 @@
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Ranking.Statistics.User;
 using osu.Game.Tests.Resources;
 using osu.Game.Users;
 using osuTK;
@@ -80,6 +85,69 @@ public void TestNullScore()
             loadPanel(null);
         }
 
+        [Test]
+        public void TestStatisticsShownCorrectlyIfUpdateDeliveredBeforeLoad()
+        {
+            UserStatisticsWatcher userStatisticsWatcher = null!;
+            ScoreInfo score = null!;
+
+            AddStep("create user statistics watcher", () => Add(userStatisticsWatcher = new UserStatisticsWatcher()));
+            AddStep("set user statistics update", () =>
+            {
+                score = TestResources.CreateTestScoreInfo();
+                score.OnlineID = 1234;
+                ((Bindable<UserStatisticsUpdate>)userStatisticsWatcher.LatestUpdate).Value = new UserStatisticsUpdate(score,
+                    new UserStatistics
+                    {
+                        Level = new UserStatistics.LevelInfo
+                        {
+                            Current = 5,
+                            Progress = 20,
+                        },
+                        GlobalRank = 38000,
+                        CountryRank = 12006,
+                        PP = 2134,
+                        RankedScore = 21123849,
+                        Accuracy = 0.985,
+                        PlayCount = 13375,
+                        PlayTime = 354490,
+                        TotalScore = 128749597,
+                        TotalHits = 0,
+                        MaxCombo = 1233,
+                    }, new UserStatistics
+                    {
+                        Level = new UserStatistics.LevelInfo
+                        {
+                            Current = 5,
+                            Progress = 30,
+                        },
+                        GlobalRank = 36000,
+                        CountryRank = 12000,
+                        PP = (decimal)2134.5,
+                        RankedScore = 23897015,
+                        Accuracy = 0.984,
+                        PlayCount = 13376,
+                        PlayTime = 35789,
+                        TotalScore = 132218497,
+                        TotalHits = 0,
+                        MaxCombo = 1233,
+                    });
+            });
+            AddStep("load user statistics panel", () => Child = new DependencyProvidingContainer
+            {
+                CachedDependencies = [(typeof(UserStatisticsWatcher), userStatisticsWatcher)],
+                RelativeSizeAxes = Axes.Both,
+                Child = new UserStatisticsPanel(score)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    State = { Value = Visibility.Visible },
+                    Score = { Value = score, }
+                }
+            });
+            AddUntilStep("overall ranking present", () => this.ChildrenOfType<OverallRanking>().Any());
+            AddUntilStep("loading spinner not visible", () => this.ChildrenOfType<LoadingLayer>().All(l => l.State.Value == Visibility.Hidden));
+        }
+
         private void loadPanel(ScoreInfo score) => AddStep("load panel", () =>
         {
             Child = new UserStatisticsPanel(score)
diff --git a/osu.Game.Tests/Visual/Settings/TestSceneDirectorySelector.cs b/osu.Game.Tests/Visual/Settings/TestSceneDirectorySelector.cs
index 3ef0ffc13abf..03ecd4af6140 100644
--- a/osu.Game.Tests/Visual/Settings/TestSceneDirectorySelector.cs
+++ b/osu.Game.Tests/Visual/Settings/TestSceneDirectorySelector.cs
@@ -9,6 +9,11 @@ namespace osu.Game.Tests.Visual.Settings
 {
     public partial class TestSceneDirectorySelector : ThemeComparisonTestScene
     {
+        public TestSceneDirectorySelector()
+            : base(false)
+        {
+        }
+
         protected override Drawable CreateContent() => new OsuDirectorySelector
         {
             RelativeSizeAxes = Axes.Both
diff --git a/osu.Game.Tests/Visual/Settings/TestSceneFileSelector.cs b/osu.Game.Tests/Visual/Settings/TestSceneFileSelector.cs
index c70277987e42..cf8a5891522f 100644
--- a/osu.Game.Tests/Visual/Settings/TestSceneFileSelector.cs
+++ b/osu.Game.Tests/Visual/Settings/TestSceneFileSelector.cs
@@ -1,37 +1,49 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays;
 using osu.Game.Tests.Visual.UserInterface;
 
 namespace osu.Game.Tests.Visual.Settings
 {
     public partial class TestSceneFileSelector : ThemeComparisonTestScene
     {
-        [Resolved]
-        private OsuColour colours { get; set; } = null!;
+        public TestSceneFileSelector()
+            : base(false)
+        {
+        }
 
         [Test]
         public void TestJpgFilesOnly()
         {
             AddStep("create", () =>
             {
-                ContentContainer.Children = new Drawable[]
+                var colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
+                ContentContainer.Child = new DependencyProvidingContainer
                 {
-                    new Box
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = new (Type, object)[]
                     {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = colours.GreySeaFoam
+                        (typeof(OverlayColourProvider), colourProvider)
                     },
-                    new OsuFileSelector(validFileExtensions: new[] { ".jpg" })
+                    Children = new Drawable[]
                     {
-                        RelativeSizeAxes = Axes.Both,
-                    },
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = colourProvider.Background3
+                        },
+                        new OsuFileSelector(validFileExtensions: new[] { ".jpg" })
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                    }
                 };
             });
         }
diff --git a/osu.Game.Tests/Visual/Settings/TestSceneSettingsSource.cs b/osu.Game.Tests/Visual/Settings/TestSceneSettingsSource.cs
index 309438e51cbf..9544f7794077 100644
--- a/osu.Game.Tests/Visual/Settings/TestSceneSettingsSource.cs
+++ b/osu.Game.Tests/Visual/Settings/TestSceneSettingsSource.cs
@@ -5,6 +5,7 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
 using osu.Game.Overlays.Settings;
@@ -19,16 +20,20 @@ public TestSceneSettingsSource()
         {
             Children = new Drawable[]
             {
-                new FillFlowContainer
+                new PopoverContainer
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Direction = FillDirection.Vertical,
-                    Spacing = new Vector2(20),
-                    Width = 0.5f,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Padding = new MarginPadding(50),
-                    ChildrenEnumerable = new TestTargetClass().CreateSettingsControls()
+                    Child = new FillFlowContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(20),
+                        Width = 0.5f,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Padding = new MarginPadding(50),
+                        ChildrenEnumerable = new TestTargetClass().CreateSettingsControls()
+                    },
                 },
             };
         }
@@ -66,6 +71,13 @@ private class TestTargetClass
 
             [SettingSource("Sample number textbox", "Textbox number entry", SettingControlType = typeof(SettingsNumberBox))]
             public Bindable<int?> IntTextBoxBindable { get; } = new Bindable<int?>();
+
+            [SettingSource("Sample colour", "Change the colour", SettingControlType = typeof(SettingsColour))]
+            public BindableColour4 ColourBindable { get; } = new BindableColour4
+            {
+                Default = Colour4.White,
+                Value = Colour4.Red
+            };
         }
 
         private enum TestEnum
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs
index c0102b238c8e..97c46a11fc58 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using JetBrains.Annotations;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
@@ -52,11 +53,11 @@ public void TestExternalRulesetChange()
         {
             createCarousel(new List<BeatmapSetInfo>());
 
-            AddStep("filter to ruleset 0", () => carousel.Filter(new FilterCriteria
+            AddStep("filter to ruleset 0", () => carousel.FilterImmediately(new FilterCriteria
             {
                 Ruleset = rulesets.AvailableRulesets.ElementAt(0),
                 AllowConvertedBeatmaps = true,
-            }, false));
+            }));
 
             AddStep("add mixed ruleset beatmapset", () =>
             {
@@ -78,11 +79,11 @@ public void TestExternalRulesetChange()
                        && visibleBeatmapPanels.Count(p => ((CarouselBeatmap)p.Item)!.BeatmapInfo.Ruleset.OnlineID == 0) == 1;
             });
 
-            AddStep("filter to ruleset 1", () => carousel.Filter(new FilterCriteria
+            AddStep("filter to ruleset 1", () => carousel.FilterImmediately(new FilterCriteria
             {
                 Ruleset = rulesets.AvailableRulesets.ElementAt(1),
                 AllowConvertedBeatmaps = true,
-            }, false));
+            }));
 
             AddUntilStep("wait for filtered difficulties", () =>
             {
@@ -93,11 +94,11 @@ public void TestExternalRulesetChange()
                        && visibleBeatmapPanels.Count(p => ((CarouselBeatmap)p.Item)!.BeatmapInfo.Ruleset.OnlineID == 1) == 1;
             });
 
-            AddStep("filter to ruleset 2", () => carousel.Filter(new FilterCriteria
+            AddStep("filter to ruleset 2", () => carousel.FilterImmediately(new FilterCriteria
             {
                 Ruleset = rulesets.AvailableRulesets.ElementAt(2),
                 AllowConvertedBeatmaps = true,
-            }, false));
+            }));
 
             AddUntilStep("wait for filtered difficulties", () =>
             {
@@ -344,7 +345,7 @@ public void TestFiltering()
             // basic filtering
             setSelected(1, 1);
 
-            AddStep("Filter", () => carousel.Filter(new FilterCriteria { SearchText = carousel.BeatmapSets.ElementAt(2).Metadata.Title }, false));
+            AddStep("Filter", () => carousel.FilterImmediately(new FilterCriteria { SearchText = carousel.BeatmapSets.ElementAt(2).Metadata.Title }));
             checkVisibleItemCount(diff: false, count: 1);
             checkVisibleItemCount(diff: true, count: 3);
             waitForSelection(3, 1);
@@ -360,13 +361,13 @@ public void TestFiltering()
             // test filtering some difficulties (and keeping current beatmap set selected).
 
             setSelected(1, 2);
-            AddStep("Filter some difficulties", () => carousel.Filter(new FilterCriteria { SearchText = "Normal" }, false));
+            AddStep("Filter some difficulties", () => carousel.FilterImmediately(new FilterCriteria { SearchText = "Normal" }));
             waitForSelection(1, 1);
 
-            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+            AddStep("Un-filter", () => carousel.FilterImmediately(new FilterCriteria()));
             waitForSelection(1, 1);
 
-            AddStep("Filter all", () => carousel.Filter(new FilterCriteria { SearchText = "Dingo" }, false));
+            AddStep("Filter all", () => carousel.FilterImmediately(new FilterCriteria { SearchText = "Dingo" }));
 
             checkVisibleItemCount(false, 0);
             checkVisibleItemCount(true, 0);
@@ -378,7 +379,7 @@ public void TestFiltering()
             advanceSelection(false);
             AddAssert("Selection is null", () => currentSelection == null);
 
-            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+            AddStep("Un-filter", () => carousel.FilterImmediately(new FilterCriteria()));
 
             AddAssert("Selection is non-null", () => currentSelection != null);
 
@@ -399,7 +400,7 @@ public void TestFilterRange()
 
             setSelected(1, 3);
 
-            AddStep("Apply a range filter", () => carousel.Filter(new FilterCriteria
+            AddStep("Apply a range filter", () => carousel.FilterImmediately(new FilterCriteria
             {
                 SearchText = searchText,
                 StarDifficulty = new FilterCriteria.OptionalRange<double>
@@ -408,7 +409,7 @@ public void TestFilterRange()
                     Max = 5.5,
                     IsLowerInclusive = true
                 }
-            }, false));
+            }));
 
             // should reselect the buffered selection.
             waitForSelection(3, 2);
@@ -445,13 +446,13 @@ public void TestRandom()
             AddAssert("ensure repeat", () => selectedSets.Contains(carousel.SelectedBeatmapSet));
 
             AddStep("Add set with 100 difficulties", () => carousel.UpdateBeatmapSet(TestResources.CreateTestBeatmapSetInfo(100, rulesets.AvailableRulesets.ToArray())));
-            AddStep("Filter Extra", () => carousel.Filter(new FilterCriteria { SearchText = "Extra 10" }, false));
+            AddStep("Filter Extra", () => carousel.FilterImmediately(new FilterCriteria { SearchText = "Extra 10" }));
             checkInvisibleDifficultiesUnselectable();
             checkInvisibleDifficultiesUnselectable();
             checkInvisibleDifficultiesUnselectable();
             checkInvisibleDifficultiesUnselectable();
             checkInvisibleDifficultiesUnselectable();
-            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+            AddStep("Un-filter", () => carousel.FilterImmediately(new FilterCriteria()));
         }
 
         [Test]
@@ -519,6 +520,17 @@ public void TestAddRemove()
             waitForSelection(set_count);
         }
 
+        [Test]
+        public void TestDifficultiesSplitOutOnLoad()
+        {
+            loadBeatmaps(new List<BeatmapSetInfo> { TestResources.CreateTestBeatmapSetInfo(diff_count) }, () => new FilterCriteria
+            {
+                Sort = SortMode.Difficulty,
+            });
+
+            checkVisibleItemCount(false, 3);
+        }
+
         [Test]
         public void TestAddRemoveDifficultySort()
         {
@@ -527,7 +539,7 @@ public void TestAddRemoveDifficultySort()
 
             loadBeatmaps(setCount: local_set_count, diffCount: local_diff_count);
 
-            AddStep("Sort by difficulty", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty }, false));
+            AddStep("Sort by difficulty", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Difficulty }));
 
             checkVisibleItemCount(false, local_set_count * local_diff_count);
 
@@ -566,7 +578,7 @@ public void TestSelectionEnteringFromEmptyRuleset()
             loadBeatmaps(sets, () => new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(0) });
 
             AddStep("Set non-empty mode filter", () =>
-                carousel.Filter(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(1) }, false));
+                carousel.FilterImmediately(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(1) }));
 
             AddAssert("Something is selected", () => carousel.SelectedBeatmapInfo != null);
         }
@@ -601,7 +613,7 @@ public void TestSortingDateSubmitted()
 
             loadBeatmaps(sets);
 
-            AddStep("Sort by date submitted", () => carousel.Filter(new FilterCriteria { Sort = SortMode.DateSubmitted }, false));
+            AddStep("Sort by date submitted", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.DateSubmitted }));
             checkVisibleItemCount(diff: false, count: 10);
             checkVisibleItemCount(diff: true, count: 5);
 
@@ -610,11 +622,11 @@ public void TestSortingDateSubmitted()
             AddAssert("rest are at start", () => carousel.Items.OfType<DrawableCarouselBeatmapSet>().TakeWhile(i => i.Item is CarouselBeatmapSet s && s.BeatmapSet.DateSubmitted != null).Count(),
                 () => Is.EqualTo(6));
 
-            AddStep("Sort by date submitted and string", () => carousel.Filter(new FilterCriteria
+            AddStep("Sort by date submitted and string", () => carousel.FilterImmediately(new FilterCriteria
             {
                 Sort = SortMode.DateSubmitted,
                 SearchText = zzz_string
-            }, false));
+            }));
             checkVisibleItemCount(diff: false, count: 5);
             checkVisibleItemCount(diff: true, count: 5);
 
@@ -658,10 +670,10 @@ public void TestSorting()
 
             loadBeatmaps(sets);
 
-            AddStep("Sort by author", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Author }, false));
+            AddStep("Sort by author", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Author }));
             AddAssert($"Check {zzz_uppercase} is last", () => carousel.BeatmapSets.Last().Metadata.Author.Username == zzz_uppercase);
             AddAssert($"Check {zzz_lowercase} is second last", () => carousel.BeatmapSets.SkipLast(1).Last().Metadata.Author.Username == zzz_lowercase);
-            AddStep("Sort by artist", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Artist }, false));
+            AddStep("Sort by artist", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Artist }));
             AddAssert($"Check {zzz_uppercase} is last", () => carousel.BeatmapSets.Last().Metadata.Artist == zzz_uppercase);
             AddAssert($"Check {zzz_lowercase} is second last", () => carousel.BeatmapSets.SkipLast(1).Last().Metadata.Artist == zzz_lowercase);
         }
@@ -703,7 +715,7 @@ public void TestSortByArtistUsesTitleAsTiebreaker()
 
             loadBeatmaps(sets);
 
-            AddStep("Sort by artist", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Artist }, false));
+            AddStep("Sort by artist", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Artist }));
             AddAssert("Check last item", () =>
             {
                 var lastItem = carousel.BeatmapSets.Last();
@@ -746,10 +758,10 @@ public void TestSortingStabilityDateAdded()
 
             loadBeatmaps(sets);
 
-            AddStep("Sort by title", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Title }, false));
+            AddStep("Sort by title", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Title }));
             AddAssert("Items remain in descending added order", () => carousel.BeatmapSets.Select(s => s.DateAdded), () => Is.Ordered.Descending);
 
-            AddStep("Sort by artist", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Artist }, false));
+            AddStep("Sort by artist", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Artist }));
             AddAssert("Items remain in descending added order", () => carousel.BeatmapSets.Select(s => s.DateAdded), () => Is.Ordered.Descending);
         }
 
@@ -786,7 +798,7 @@ public void TestSortingStabilityWithRemovedAndReaddedItem()
 
             loadBeatmaps(sets);
 
-            AddStep("Sort by artist", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Artist }, false));
+            AddStep("Sort by artist", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Artist }));
 
             AddAssert("Items in descending added order", () => carousel.BeatmapSets.Select(s => s.DateAdded), () => Is.Ordered.Descending);
             AddStep("Save order", () => originalOrder = carousel.BeatmapSets.Select(s => s.ID).ToArray());
@@ -796,7 +808,7 @@ public void TestSortingStabilityWithRemovedAndReaddedItem()
 
             AddAssert("Order didn't change", () => carousel.BeatmapSets.Select(s => s.ID), () => Is.EqualTo(originalOrder));
 
-            AddStep("Sort by title", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Title }, false));
+            AddStep("Sort by title", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Title }));
             AddAssert("Order didn't change", () => carousel.BeatmapSets.Select(s => s.ID), () => Is.EqualTo(originalOrder));
         }
 
@@ -833,7 +845,7 @@ public void TestSortingStabilityWithNewItems()
 
             loadBeatmaps(sets);
 
-            AddStep("Sort by artist", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Artist }, false));
+            AddStep("Sort by artist", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Artist }));
 
             AddAssert("Items in descending added order", () => carousel.BeatmapSets.Select(s => s.DateAdded), () => Is.Ordered.Descending);
             AddStep("Save order", () => originalOrder = carousel.BeatmapSets.Select(s => s.ID).ToArray());
@@ -858,7 +870,7 @@ public void TestSortingStabilityWithNewItems()
 
             AddAssert("Order didn't change", () => carousel.BeatmapSets.Select(s => s.ID), () => Is.EqualTo(originalOrder));
 
-            AddStep("Sort by title", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Title }, false));
+            AddStep("Sort by title", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Title }));
             AddAssert("Order didn't change", () => carousel.BeatmapSets.Select(s => s.ID), () => Is.EqualTo(originalOrder));
         }
 
@@ -885,12 +897,12 @@ public void TestSortingWithDifficultyFiltered()
 
             loadBeatmaps(sets);
 
-            AddStep("Sort by difficulty", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty }, false));
+            AddStep("Sort by difficulty", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Difficulty }));
 
             checkVisibleItemCount(false, local_set_count * local_diff_count);
             checkVisibleItemCount(true, 1);
 
-            AddStep("Filter to normal", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty, SearchText = "Normal" }, false));
+            AddStep("Filter to normal", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Difficulty, SearchText = "Normal" }));
             checkVisibleItemCount(false, local_set_count);
             checkVisibleItemCount(true, 1);
 
@@ -901,7 +913,7 @@ public void TestSortingWithDifficultyFiltered()
                                .Count(p => ((CarouselBeatmapSet)p.Item)!.Beatmaps.Single().BeatmapInfo.DifficultyName.StartsWith("Normal", StringComparison.Ordinal)) == local_set_count;
             });
 
-            AddStep("Filter to insane", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty, SearchText = "Insane" }, false));
+            AddStep("Filter to insane", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Difficulty, SearchText = "Insane" }));
             checkVisibleItemCount(false, local_set_count);
             checkVisibleItemCount(true, 1);
 
@@ -1022,7 +1034,7 @@ public void TestSelectingFilteredRuleset()
                 carousel.UpdateBeatmapSet(testMixed);
             });
             AddStep("filter to ruleset 0", () =>
-                carousel.Filter(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(0) }, false));
+                carousel.FilterImmediately(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(0) }));
             AddStep("select filtered map skipping filtered", () => carousel.SelectBeatmap(testMixed.Beatmaps[1], false));
             AddAssert("unfiltered beatmap not selected", () => carousel.SelectedBeatmapInfo?.Ruleset.OnlineID == 0);
 
@@ -1068,12 +1080,12 @@ public void TestCarouselRemembersSelection()
             {
                 AddStep("Toggle non-matching filter", () =>
                 {
-                    carousel.Filter(new FilterCriteria { SearchText = Guid.NewGuid().ToString() }, false);
+                    carousel.FilterImmediately(new FilterCriteria { SearchText = Guid.NewGuid().ToString() });
                 });
 
                 AddStep("Restore no filter", () =>
                 {
-                    carousel.Filter(new FilterCriteria(), false);
+                    carousel.FilterImmediately(new FilterCriteria());
                     eagerSelectedIDs.Add(carousel.SelectedBeatmapSet!.ID);
                 });
             }
@@ -1097,7 +1109,7 @@ public void TestCarouselRemembersSelectionDifficultySort()
 
             loadBeatmaps(manySets);
 
-            AddStep("Sort by difficulty", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty }, false));
+            AddStep("Sort by difficulty", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Difficulty }));
 
             advanceSelection(direction: 1, diff: false);
 
@@ -1105,12 +1117,12 @@ public void TestCarouselRemembersSelectionDifficultySort()
             {
                 AddStep("Toggle non-matching filter", () =>
                 {
-                    carousel.Filter(new FilterCriteria { SearchText = Guid.NewGuid().ToString() }, false);
+                    carousel.FilterImmediately(new FilterCriteria { SearchText = Guid.NewGuid().ToString() });
                 });
 
                 AddStep("Restore no filter", () =>
                 {
-                    carousel.Filter(new FilterCriteria(), false);
+                    carousel.FilterImmediately(new FilterCriteria());
                     eagerSelectedIDs.Add(carousel.SelectedBeatmapSet!.ID);
                 });
             }
@@ -1119,6 +1131,32 @@ public void TestCarouselRemembersSelectionDifficultySort()
             AddAssert("Selection was remembered", () => eagerSelectedIDs.Count == 1);
         }
 
+        [Test]
+        public void TestCarouselRetainsSelectionFromDifficultySort()
+        {
+            List<BeatmapSetInfo> manySets = new List<BeatmapSetInfo>();
+
+            AddStep("Populate beatmap sets", () =>
+            {
+                manySets.Clear();
+
+                for (int i = 1; i <= 50; i++)
+                    manySets.Add(TestResources.CreateTestBeatmapSetInfo(diff_count));
+            });
+
+            loadBeatmaps(manySets);
+
+            BeatmapInfo chosenBeatmap = null!;
+            AddStep("select given beatmap", () => carousel.SelectBeatmap(chosenBeatmap = manySets[20].Beatmaps[0]));
+            AddUntilStep("selection changed", () => carousel.SelectedBeatmapInfo, () => Is.EqualTo(chosenBeatmap));
+
+            AddStep("sort by difficulty", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Difficulty }));
+            AddAssert("selection retained", () => carousel.SelectedBeatmapInfo, () => Is.EqualTo(chosenBeatmap));
+
+            AddStep("sort by title", () => carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Title }));
+            AddAssert("selection retained", () => carousel.SelectedBeatmapInfo, () => Is.EqualTo(chosenBeatmap));
+        }
+
         [Test]
         public void TestFilteringByUserStarDifficulty()
         {
@@ -1185,7 +1223,7 @@ public void TestCarouselSelectsNextWhenPreviousIsFiltered()
 
                 AddStep($"Set ruleset to {rulesetInfo.ShortName}", () =>
                 {
-                    carousel.Filter(new FilterCriteria { Ruleset = rulesetInfo, Sort = SortMode.Title }, false);
+                    carousel.FilterImmediately(new FilterCriteria { Ruleset = rulesetInfo, Sort = SortMode.Title });
                 });
                 waitForSelection(i + 1, 1);
             }
@@ -1223,12 +1261,12 @@ public void TestCarouselSelectsBackwardsWhenDistanceIsShorter()
                 setSelected(i, 1);
                 AddStep("Set ruleset to taiko", () =>
                 {
-                    carousel.Filter(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(1), Sort = SortMode.Title }, false);
+                    carousel.FilterImmediately(new FilterCriteria { Ruleset = rulesets.AvailableRulesets.ElementAt(1), Sort = SortMode.Title });
                 });
                 waitForSelection(i - 1, 1);
                 AddStep("Remove ruleset filter", () =>
                 {
-                    carousel.Filter(new FilterCriteria { Sort = SortMode.Title }, false);
+                    carousel.FilterImmediately(new FilterCriteria { Sort = SortMode.Title });
                 });
             }
 
@@ -1268,26 +1306,23 @@ private void loadBeatmaps(List<BeatmapSetInfo> beatmapSets = null, Func<FilterCr
                 }
             }
 
-            createCarousel(beatmapSets, c =>
+            createCarousel(beatmapSets, initialCriteria, c =>
             {
-                carouselAdjust?.Invoke(c);
-
-                carousel.Filter(initialCriteria?.Invoke() ?? new FilterCriteria());
                 carousel.BeatmapSetsChanged = () => changed = true;
-                carousel.BeatmapSets = beatmapSets;
+                carouselAdjust?.Invoke(c);
             });
 
             AddUntilStep("Wait for load", () => changed);
         }
 
-        private void createCarousel(List<BeatmapSetInfo> beatmapSets, Action<BeatmapCarousel> carouselAdjust = null, Container target = null)
+        private void createCarousel(List<BeatmapSetInfo> beatmapSets, [CanBeNull] Func<FilterCriteria> initialCriteria = null, Action<BeatmapCarousel> carouselAdjust = null, Container target = null)
         {
             AddStep("Create carousel", () =>
             {
                 selectedSets.Clear();
                 eagerSelectedIDs.Clear();
 
-                carousel = new TestBeatmapCarousel
+                carousel = new TestBeatmapCarousel(initialCriteria?.Invoke() ?? new FilterCriteria())
                 {
                     RelativeSizeAxes = Axes.Both,
                 };
@@ -1389,6 +1424,11 @@ private void checkInvisibleDifficultiesUnselectable()
 
         private partial class TestBeatmapCarousel : BeatmapCarousel
         {
+            public TestBeatmapCarousel(FilterCriteria criteria)
+                : base(criteria)
+            {
+            }
+
             public bool PendingFilterTask => PendingFilter != null;
 
             public IEnumerable<DrawableCarouselItem> Items
@@ -1410,6 +1450,12 @@ public IEnumerable<DrawableCarouselItem> Items
                     }
                 }
             }
+
+            public void FilterImmediately(FilterCriteria newCriteria)
+            {
+                Filter(newCriteria);
+                FlushPendingFilterOperations();
+            }
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs b/osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs
index 4c6a5c93d9aa..3a95aca6b94c 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs
@@ -56,16 +56,20 @@ public partial class TestScenePlaySongSelect : ScreenTestScene
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
+            DetachedBeatmapStore detachedBeatmapStore;
+
             // 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.Cache(detachedBeatmapStore = new DetachedBeatmapStore());
 
             Dependencies.Cache(music = new MusicController());
 
             // required to get bindables attached
             Add(music);
+            Add(detachedBeatmapStore);
 
             Dependencies.Cache(config = new OsuConfigManager(LocalStorage));
         }
@@ -171,6 +175,29 @@ public void TestSpeedChange()
             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);
@@ -242,7 +269,7 @@ public void TestSingleFilterOnEnter()
 
             createSongSelect();
 
-            AddAssert("filter count is 1", () => songSelect?.FilterCount == 1);
+            AddAssert("filter count is 0", () => songSelect?.FilterCount, () => Is.EqualTo(0));
         }
 
         [Test]
@@ -362,7 +389,7 @@ public void TestNoFilterOnSimpleResume()
 
             AddStep("return", () => songSelect!.MakeCurrent());
             AddUntilStep("wait for current", () => songSelect!.IsCurrentScreen());
-            AddAssert("filter count is 1", () => songSelect!.FilterCount == 1);
+            AddAssert("filter count is 0", () => songSelect!.FilterCount, () => Is.EqualTo(0));
         }
 
         [Test]
@@ -382,7 +409,7 @@ public void TestFilterOnResumeAfterChange()
 
             AddStep("return", () => songSelect!.MakeCurrent());
             AddUntilStep("wait for current", () => songSelect!.IsCurrentScreen());
-            AddAssert("filter count is 2", () => songSelect!.FilterCount == 2);
+            AddAssert("filter count is 1", () => songSelect!.FilterCount, () => Is.EqualTo(1));
         }
 
         [Test]
@@ -1270,11 +1297,11 @@ public void TestNonFilterableModChange()
 
             // Mod that is guaranteed to never re-filter.
             AddStep("add non-filterable mod", () => SelectedMods.Value = new Mod[] { new OsuModCinema() });
-            AddAssert("filter count is 1", () => songSelect!.FilterCount, () => Is.EqualTo(1));
+            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 1", () => songSelect!.FilterCount, () => Is.EqualTo(1));
+            AddAssert("filter count is 0", () => songSelect!.FilterCount, () => Is.EqualTo(0));
         }
 
         [Test]
@@ -1286,35 +1313,35 @@ public void TestFilterableModChange()
 
             // 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(2));
+            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 2", () => songSelect!.FilterCount, () => Is.EqualTo(2));
+            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 3", () => songSelect!.FilterCount, () => Is.EqualTo(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 4", () => songSelect!.FilterCount, () => Is.EqualTo(4));
+            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 4", () => songSelect!.FilterCount, () => Is.EqualTo(4));
+            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 5", () => songSelect!.FilterCount, () => Is.EqualTo(5));
+            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 5", () => songSelect!.FilterCount, () => Is.EqualTo(5));
+            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 6", () => songSelect!.FilterCount, () => Is.EqualTo(6));
+            AddAssert("filter count is 5", () => songSelect!.FilterCount, () => Is.EqualTo(5));
         }
 
         private void waitForInitialSelection()
@@ -1397,8 +1424,6 @@ private partial class TestSongSelect : PlaySongSelect
         {
             public Action? StartRequested;
 
-            public new Bindable<RulesetInfo> Ruleset => base.Ruleset;
-
             public new FilterControl FilterControl => base.FilterControl;
 
             public WorkingBeatmap CurrentBeatmap => Beatmap.Value;
@@ -1408,18 +1433,18 @@ private partial class TestSongSelect : PlaySongSelect
 
             public new void PresentScore(ScoreInfo score) => base.PresentScore(score);
 
+            public int FilterCount;
+
             protected override bool OnStart()
             {
                 StartRequested?.Invoke();
                 return base.OnStart();
             }
 
-            public int FilterCount;
-
-            protected override void ApplyFilterToCarousel(FilterCriteria criteria)
+            [BackgroundDependencyLoader]
+            private void load()
             {
-                FilterCount++;
-                base.ApplyFilterToCarousel(criteria);
+                FilterControl.FilterChanged += _ => FilterCount++;
             }
         }
     }
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneUpdateBeatmapSetButton.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneUpdateBeatmapSetButton.cs
index 6d97be730b5a..0b0cd0317a67 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneUpdateBeatmapSetButton.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneUpdateBeatmapSetButton.cs
@@ -246,7 +246,7 @@ public void TestSplitDisplay()
 
         private BeatmapCarousel createCarousel()
         {
-            return carousel = new BeatmapCarousel
+            return carousel = new BeatmapCarousel(new FilterCriteria())
             {
                 RelativeSizeAxes = Axes.Both,
                 BeatmapSets = new List<BeatmapSetInfo>
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneFormControls.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneFormControls.cs
new file mode 100644
index 000000000000..2a0b0515a11c
--- /dev/null
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneFormControls.cs
@@ -0,0 +1,113 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.Cursor;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public partial class TestSceneFormControls : ThemeComparisonTestScene
+    {
+        public TestSceneFormControls()
+            : base(false)
+        {
+        }
+
+        protected override Drawable CreateContent() => new OsuContextMenuContainer
+        {
+            RelativeSizeAxes = Axes.Both,
+            Child = new PopoverContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.Y,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Width = 400,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(5),
+                    Padding = new MarginPadding(10),
+                    Children = new Drawable[]
+                    {
+                        new FormTextBox
+                        {
+                            Caption = "Artist",
+                            HintText = "Poot artist here!",
+                            PlaceholderText = "Here is an artist",
+                            TabbableContentContainer = this,
+                        },
+                        new FormTextBox
+                        {
+                            Caption = "Artist",
+                            HintText = "Poot artist here!",
+                            PlaceholderText = "Here is an artist",
+                            Current = { Disabled = true },
+                            TabbableContentContainer = this,
+                        },
+                        new FormNumberBox
+                        {
+                            Caption = "Number",
+                            HintText = "Insert your favourite number",
+                            PlaceholderText = "Mine is 42!",
+                            TabbableContentContainer = this,
+                        },
+                        new FormCheckBox
+                        {
+                            Caption = EditorSetupStrings.LetterboxDuringBreaks,
+                            HintText = EditorSetupStrings.LetterboxDuringBreaksDescription,
+                        },
+                        new FormCheckBox
+                        {
+                            Caption = EditorSetupStrings.LetterboxDuringBreaks,
+                            HintText = EditorSetupStrings.LetterboxDuringBreaksDescription,
+                            Current = { Disabled = true },
+                        },
+                        new FormSliderBar<float>
+                        {
+                            Caption = "Instantaneous slider",
+                            Current = new BindableFloat
+                            {
+                                MinValue = 0,
+                                MaxValue = 10,
+                                Value = 5,
+                                Precision = 0.1f,
+                            },
+                            TabbableContentContainer = this,
+                        },
+                        new FormSliderBar<float>
+                        {
+                            Caption = "Non-instantaneous slider",
+                            Current = new BindableFloat
+                            {
+                                MinValue = 0,
+                                MaxValue = 10,
+                                Value = 5,
+                                Precision = 0.1f,
+                            },
+                            Instantaneous = false,
+                            TabbableContentContainer = this,
+                        },
+                        new FormEnumDropdown<CountdownType>
+                        {
+                            Caption = EditorSetupStrings.EnableCountdown,
+                            HintText = EditorSetupStrings.CountdownDescription,
+                        },
+                        new FormFileSelector
+                        {
+                            Caption = "Audio file",
+                            PlaceholderText = "Select an audio file",
+                        },
+                    },
+                },
+            }
+        };
+    }
+}
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneMainMenuButton.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneMainMenuButton.cs
index 98f2b129ff4a..41543669ebbe 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneMainMenuButton.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneMainMenuButton.cs
@@ -103,15 +103,79 @@ public void TestDailyChallengeButton()
                 foreach (var notification in notificationOverlay.AllNotifications)
                     notification.Close(runFlingAnimation: false);
             });
+
             AddStep("beatmap of the day not active", () => metadataClient.DailyChallengeUpdated(null));
             AddAssert("no notification posted", () => notificationOverlay.AllNotifications.Count(), () => Is.Zero);
 
             AddStep("hide button's parent", () => buttonContainer.Hide());
+
             AddStep("beatmap of the day active", () => metadataClient.DailyChallengeUpdated(new DailyChallengeInfo
             {
                 RoomID = 1234,
             }));
             AddAssert("no notification posted", () => notificationOverlay.AllNotifications.Count(), () => Is.Zero);
         }
+
+        [Test]
+        public void TestDailyChallengeButtonOldChallenge()
+        {
+            AddStep("set up API", () => dummyAPI.HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case GetRoomRequest getRoomRequest:
+                        if (getRoomRequest.RoomId != 1234)
+                            return false;
+
+                        var beatmap = CreateAPIBeatmap();
+                        beatmap.OnlineID = 1001;
+                        getRoomRequest.TriggerSuccess(new Room
+                        {
+                            RoomID = { Value = 1234 },
+                            Playlist =
+                            {
+                                new PlaylistItem(beatmap)
+                            },
+                            StartDate = { Value = DateTimeOffset.Now.AddMinutes(-50) },
+                            EndDate = { Value = DateTimeOffset.Now.AddSeconds(30) }
+                        });
+                        return true;
+
+                    default:
+                        return false;
+                }
+            });
+
+            NotificationOverlay notificationOverlay = null!;
+
+            AddStep("beatmap of the day not active", () => metadataClient.DailyChallengeUpdated(null));
+            AddStep("add content", () =>
+            {
+                notificationOverlay = new NotificationOverlay();
+                Children = new Drawable[]
+                {
+                    notificationOverlay,
+                    new DependencyProvidingContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        AutoSizeAxes = Axes.Both,
+                        CachedDependencies = [(typeof(INotificationOverlay), notificationOverlay)],
+                        Child = new DailyChallengeButton(@"button-default-select", new Color4(102, 68, 204, 255), _ => { }, 0, Key.D)
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            ButtonSystemState = ButtonSystemState.TopLevel,
+                        },
+                    },
+                };
+            });
+
+            AddStep("beatmap of the day active", () => metadataClient.DailyChallengeUpdated(new DailyChallengeInfo
+            {
+                RoomID = 1234
+            }));
+            AddAssert("no notification posted", () => notificationOverlay.AllNotifications.Count(), () => Is.Zero);
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneModCustomisationPanel.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneModCustomisationPanel.cs
index c2739e1bbdf8..04cb12963024 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneModCustomisationPanel.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneModCustomisationPanel.cs
@@ -7,6 +7,9 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets.Mods;
@@ -56,19 +59,19 @@ public void TestDisplay()
             {
                 SelectedMods.Value = new[] { new OsuModDoubleTime() };
                 panel.Enabled.Value = true;
-                panel.ExpandedState.Value = ModCustomisationPanel.ModCustomisationPanelState.Expanded;
+                panel.ExpandedState.Value = ModCustomisationPanel.ModCustomisationPanelState.ExpandedByMod;
             });
             AddStep("set DA", () =>
             {
                 SelectedMods.Value = new Mod[] { new OsuModDifficultyAdjust() };
                 panel.Enabled.Value = true;
-                panel.ExpandedState.Value = ModCustomisationPanel.ModCustomisationPanelState.Expanded;
+                panel.ExpandedState.Value = ModCustomisationPanel.ModCustomisationPanelState.ExpandedByMod;
             });
             AddStep("set FL+WU+DA+AD", () =>
             {
                 SelectedMods.Value = new Mod[] { new OsuModFlashlight(), new ModWindUp(), new OsuModDifficultyAdjust(), new OsuModApproachDifferent() };
                 panel.Enabled.Value = true;
-                panel.ExpandedState.Value = ModCustomisationPanel.ModCustomisationPanelState.Expanded;
+                panel.ExpandedState.Value = ModCustomisationPanel.ModCustomisationPanelState.ExpandedByMod;
             });
             AddStep("set empty", () =>
             {
@@ -118,7 +121,7 @@ public void TestHoverExpandsWithCustomisableMods()
         }
 
         [Test]
-        public void TestExpandedStatePersistsWhenClicked()
+        public void TestHoverExpandsAndCollapsesWhenHeaderTouched()
         {
             AddStep("add customisable mod", () =>
             {
@@ -126,23 +129,25 @@ public void TestExpandedStatePersistsWhenClicked()
                 panel.Enabled.Value = true;
             });
 
-            AddStep("hover header", () => InputManager.MoveMouseTo(header));
-            checkExpanded(true);
-
-            AddStep("click", () => InputManager.Click(MouseButton.Left));
-            checkExpanded(false);
-            AddStep("click", () => InputManager.Click(MouseButton.Left));
-            checkExpanded(true);
-
-            AddStep("move away", () => InputManager.MoveMouseTo(Vector2.One));
+            AddStep("touch header", () =>
+            {
+                var touch = new Touch(TouchSource.Touch1, header.ScreenSpaceDrawQuad.Centre);
+                InputManager.BeginTouch(touch);
+                Schedule(() => InputManager.EndTouch(touch));
+            });
             checkExpanded(true);
 
-            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            AddStep("touch away from header", () =>
+            {
+                var touch = new Touch(TouchSource.Touch1, header.ScreenSpaceDrawQuad.TopLeft - new Vector2(10));
+                InputManager.BeginTouch(touch);
+                Schedule(() => InputManager.EndTouch(touch));
+            });
             checkExpanded(false);
         }
 
         [Test]
-        public void TestHoverExpandsAndCollapsesWhenHeaderClicked()
+        public void TestDraggingKeepsPanelExpanded()
         {
             AddStep("add customisable mod", () =>
             {
@@ -153,7 +158,12 @@ public void TestHoverExpandsAndCollapsesWhenHeaderClicked()
             AddStep("hover header", () => InputManager.MoveMouseTo(header));
             checkExpanded(true);
 
-            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            AddStep("hover slider bar nub", () => InputManager.MoveMouseTo(panel.ChildrenOfType<OsuSliderBar<double>>().First().ChildrenOfType<Nub>().Single()));
+            AddStep("hold", () => InputManager.PressButton(MouseButton.Left));
+            AddStep("drag outside", () => InputManager.MoveMouseTo(Vector2.Zero));
+            checkExpanded(true);
+
+            AddStep("release", () => InputManager.ReleaseButton(MouseButton.Left));
             checkExpanded(false);
         }
 
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs
index f21c64f7fea7..280497e861d9 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs
@@ -241,12 +241,8 @@ public void TestCustomisationToggleState()
             AddStep("select difficulty adjust via panel", () => getPanelForMod(typeof(OsuModDifficultyAdjust)).TriggerClick());
             assertCustomisationToggleState(disabled: false, active: true);
 
-            AddStep("dismiss mod customisation via toggle", () =>
-            {
-                InputManager.MoveMouseTo(modSelectOverlay.ChildrenOfType<ModCustomisationHeader>().Single());
-                InputManager.Click(MouseButton.Left);
-            });
-            assertCustomisationToggleState(disabled: false, active: false);
+            AddStep("move mouse away", () => InputManager.MoveMouseTo(Vector2.Zero));
+            assertCustomisationToggleState(disabled: false, active: true);
 
             AddStep("reset mods", () => SelectedMods.SetDefault());
             AddStep("select difficulty adjust via panel", () => getPanelForMod(typeof(OsuModDifficultyAdjust)).TriggerClick());
@@ -664,7 +660,7 @@ public void TestTextSearchDoesNotBlockCustomisationPanelKeyboardInteractions()
             AddStep("select DT", () => SelectedMods.Value = new Mod[] { new OsuModDoubleTime() });
             AddAssert("DT selected", () => modSelectOverlay.ChildrenOfType<ModPanel>().Count(panel => panel.Active.Value), () => Is.EqualTo(1));
 
-            AddStep("open customisation area", () => modSelectOverlay.ChildrenOfType<ModCustomisationHeader>().Single().TriggerClick());
+            AddStep("open customisation area", () => InputManager.MoveMouseTo(modSelectOverlay.ChildrenOfType<ModCustomisationHeader>().Single()));
             assertCustomisationToggleState(disabled: false, active: true);
 
             AddStep("hover over mod settings slider", () =>
@@ -976,7 +972,7 @@ public void TestCustomisationPanelAbsorbsInput([Values] bool textSearchStartsAct
             createScreen();
 
             AddStep("select DT", () => SelectedMods.Value = new Mod[] { new OsuModDoubleTime() });
-            AddStep("open customisation panel", () => this.ChildrenOfType<ModCustomisationHeader>().Single().TriggerClick());
+            AddStep("open customisation panel", () => InputManager.MoveMouseTo(this.ChildrenOfType<ModCustomisationHeader>().Single()));
             AddAssert("search lost focus", () => !this.ChildrenOfType<ShearedSearchTextBox>().Single().HasFocus);
 
             AddStep("press tab", () => InputManager.Key(Key.Tab));
@@ -991,15 +987,13 @@ public void TestCustomisationPanelAbsorbsInput([Values] bool textSearchStartsAct
             AddStep("press backspace", () => InputManager.Key(Key.BackSpace));
             AddAssert("mods not deselected", () => SelectedMods.Value.Single() is OsuModDoubleTime);
 
-            AddStep("move mouse to scroll bar", () => InputManager.MoveMouseTo(modSelectOverlay.ChildrenOfType<ModSelectOverlay.ColumnScrollContainer>().Single().ScreenSpaceDrawQuad.BottomLeft + new Vector2(10f, -5f)));
+            AddStep("move mouse to customisation panel", () => InputManager.MoveMouseTo(modSelectOverlay.ChildrenOfType<ModCustomisationSection>().First()));
 
             AddStep("scroll down", () => InputManager.ScrollVerticalBy(-10f));
             AddAssert("column not scrolled", () => modSelectOverlay.ChildrenOfType<ModSelectOverlay.ColumnScrollContainer>().Single().IsScrolledToStart());
 
-            AddStep("press mouse", () => InputManager.PressButton(MouseButton.Left));
-            AddAssert("search still not focused", () => !this.ChildrenOfType<ShearedSearchTextBox>().Single().HasFocus);
-            AddStep("release mouse", () => InputManager.ReleaseButton(MouseButton.Left));
-            AddAssert("customisation panel closed by click",
+            AddStep("move mouse away", () => InputManager.MoveMouseTo(Vector2.Zero));
+            AddAssert("customisation panel closed",
                 () => this.ChildrenOfType<ModCustomisationPanel>().Single().ExpandedState.Value,
                 () => Is.EqualTo(ModCustomisationPanel.ModCustomisationPanelState.Collapsed));
 
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneSettingsColour.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneSettingsColour.cs
new file mode 100644
index 000000000000..8d28116950dd
--- /dev/null
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneSettingsColour.cs
@@ -0,0 +1,75 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays.Settings;
+using osuTK.Graphics;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public partial class TestSceneSettingsColour : OsuManualInputManagerTestScene
+    {
+        private SettingsColour? component;
+
+        [Test]
+        public void TestColour()
+        {
+            createContent();
+
+            AddRepeatStep("set random colour", () => component!.Current.Value = randomColour(), 4);
+        }
+
+        [Test]
+        public void TestUserInteractions()
+        {
+            createContent();
+
+            AddStep("click colour", () =>
+            {
+                InputManager.MoveMouseTo(component!);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("colour picker spawned", () => this.ChildrenOfType<OsuColourPicker>().Any());
+        }
+
+        private void createContent()
+        {
+            AddStep("create component", () =>
+            {
+                Child = new PopoverContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = new FillFlowContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Width = 500,
+                        AutoSizeAxes = Axes.Y,
+                        Children = new Drawable[]
+                        {
+                            component = new SettingsColour
+                            {
+                                LabelText = "a sample component",
+                            },
+                        },
+                    },
+                };
+            });
+        }
+
+        private Colour4 randomColour() => new Color4(
+            RNG.NextSingle(),
+            RNG.NextSingle(),
+            RNG.NextSingle(),
+            1);
+    }
+}
diff --git a/osu.Game.Tests/Visual/UserInterface/ThemeComparisonTestScene.cs b/osu.Game.Tests/Visual/UserInterface/ThemeComparisonTestScene.cs
index 4700ef72d96d..44133d89f8be 100644
--- a/osu.Game.Tests/Visual/UserInterface/ThemeComparisonTestScene.cs
+++ b/osu.Game.Tests/Visual/UserInterface/ThemeComparisonTestScene.cs
@@ -75,7 +75,7 @@ protected void CreateThemedContent(OverlayColourScheme colourScheme)
                     new Box
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Colour = colourProvider.Background4
+                        Colour = colourProvider.Background3
                     },
                     CreateContent()
                 }
diff --git a/osu.Game.Tournament/Screens/Setup/StablePathSelectScreen.cs b/osu.Game.Tournament/Screens/Setup/StablePathSelectScreen.cs
index 74404e06f8dd..91b03ed08552 100644
--- a/osu.Game.Tournament/Screens/Setup/StablePathSelectScreen.cs
+++ b/osu.Game.Tournament/Screens/Setup/StablePathSelectScreen.cs
@@ -27,6 +27,9 @@ public partial class StablePathSelectScreen : TournamentScreen
         [Resolved]
         private MatchIPCInfo ipc { get; set; } = null!;
 
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
         private OsuDirectorySelector directorySelector = null!;
         private DialogOverlay? overlay;
 
diff --git a/osu.Game/Audio/HitSampleInfo.cs b/osu.Game/Audio/HitSampleInfo.cs
index f9c93d72ffa4..ce5e2175328a 100644
--- a/osu.Game/Audio/HitSampleInfo.cs
+++ b/osu.Game/Audio/HitSampleInfo.cs
@@ -96,7 +96,7 @@ public virtual IEnumerable<string> LookupNames
         public virtual HitSampleInfo With(Optional<string> newName = default, Optional<string> newBank = default, Optional<string?> newSuffix = default, Optional<int> newVolume = default)
             => new HitSampleInfo(newName.GetOr(Name), newBank.GetOr(Bank), newSuffix.GetOr(Suffix), newVolume.GetOr(Volume));
 
-        public bool Equals(HitSampleInfo? other)
+        public virtual bool Equals(HitSampleInfo? other)
             => other != null && Name == other.Name && Bank == other.Bank && Suffix == other.Suffix;
 
         public override bool Equals(object? obj)
diff --git a/osu.Game/Beatmaps/BeatmapImporter.cs b/osu.Game/Beatmaps/BeatmapImporter.cs
index 8acaebd1a8bb..94144e46952f 100644
--- a/osu.Game/Beatmaps/BeatmapImporter.cs
+++ b/osu.Game/Beatmaps/BeatmapImporter.cs
@@ -198,8 +198,11 @@ protected override void PreImport(BeatmapSetInfo beatmapSet, Realm realm)
 
             if (beatmapSet.OnlineID > 0)
             {
+                // Required local for iOS. Will cause runtime crash if inlined.
+                int onlineId = beatmapSet.OnlineID;
+
                 // OnlineID should really be unique, but to avoid catastrophic failure let's iterate just to be sure.
-                foreach (var existingSetWithSameOnlineID in realm.All<BeatmapSetInfo>().Where(b => b.OnlineID == beatmapSet.OnlineID))
+                foreach (var existingSetWithSameOnlineID in realm.All<BeatmapSetInfo>().Where(b => b.OnlineID == onlineId))
                 {
                     existingSetWithSameOnlineID.DeletePending = true;
                     existingSetWithSameOnlineID.OnlineID = -1;
diff --git a/osu.Game/Beatmaps/BeatmapInfoExtensions.cs b/osu.Game/Beatmaps/BeatmapInfoExtensions.cs
index b00d0ba31609..a82a288239ba 100644
--- a/osu.Game/Beatmaps/BeatmapInfoExtensions.cs
+++ b/osu.Game/Beatmaps/BeatmapInfoExtensions.cs
@@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Localisation;
+using osu.Game.Online.API;
+using osu.Game.Rulesets;
 using osu.Game.Screens.Select;
 
 namespace osu.Game.Beatmaps
@@ -48,5 +50,16 @@ public static bool Match(this IBeatmapInfo beatmapInfo, params FilterCriteria.Op
         }
 
         private static string getVersionString(IBeatmapInfo beatmapInfo) => string.IsNullOrEmpty(beatmapInfo.DifficultyName) ? string.Empty : $"[{beatmapInfo.DifficultyName}]";
+
+        /// <summary>
+        /// Get the beatmap info page URL, or <c>null</c> if unavailable.
+        /// </summary>
+        public static string? GetOnlineURL(this IBeatmapInfo beatmapInfo, IAPIProvider api, IRulesetInfo? ruleset = null)
+        {
+            if (beatmapInfo.OnlineID <= 0 || beatmapInfo.BeatmapSet == null)
+                return null;
+
+            return $@"{api.WebsiteRootUrl}/beatmapsets/{beatmapInfo.BeatmapSet.OnlineID}#{ruleset?.ShortName ?? beatmapInfo.Ruleset.ShortName}/{beatmapInfo.OnlineID}";
+        }
     }
 }
diff --git a/osu.Game/Beatmaps/BeatmapSetInfoExtensions.cs b/osu.Game/Beatmaps/BeatmapSetInfoExtensions.cs
index 965544da409b..8a107ed4864c 100644
--- a/osu.Game/Beatmaps/BeatmapSetInfoExtensions.cs
+++ b/osu.Game/Beatmaps/BeatmapSetInfoExtensions.cs
@@ -6,6 +6,8 @@
 using osu.Game.Database;
 using osu.Game.Extensions;
 using osu.Game.Models;
+using osu.Game.Online.API;
+using osu.Game.Rulesets;
 
 namespace osu.Game.Beatmaps
 {
@@ -29,5 +31,19 @@ public static class BeatmapSetInfoExtensions
         /// <param name="filename">The name of the file to get the storage path of.</param>
         public static RealmNamedFileUsage? GetFile(this IHasRealmFiles model, string filename) =>
             model.Files.SingleOrDefault(f => string.Equals(f.Filename, filename, StringComparison.OrdinalIgnoreCase));
+
+        /// <summary>
+        /// Get the beatmapset info page URL, or <c>null</c> if unavailable.
+        /// </summary>
+        public static string? GetOnlineURL(this IBeatmapSetInfo beatmapSetInfo, IAPIProvider api, IRulesetInfo? ruleset = null)
+        {
+            if (beatmapSetInfo.OnlineID <= 0)
+                return null;
+
+            if (ruleset != null)
+                return $@"{api.WebsiteRootUrl}/beatmapsets/{beatmapSetInfo.OnlineID}#{ruleset.ShortName}";
+
+            return $@"{api.WebsiteRootUrl}/beatmapsets/{beatmapSetInfo.OnlineID}";
+        }
     }
 }
diff --git a/osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs b/osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs
index f8e72a1e341b..8666f0112917 100644
--- a/osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs
+++ b/osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs
@@ -74,6 +74,19 @@ public class ControlPointInfo : IDeepCloneable<ControlPointInfo>
         [NotNull]
         public TimingControlPoint TimingPointAt(double time) => BinarySearchWithFallback(TimingPoints, time, TimingPoints.Count > 0 ? TimingPoints[0] : TimingControlPoint.DEFAULT);
 
+        /// <summary>
+        /// Finds the first timing point that is active strictly after <paramref name="time"/>, or null if no such point exists.
+        /// </summary>
+        /// <param name="time">The time after which to find the timing control point.</param>
+        /// <returns>The timing control point.</returns>
+        [CanBeNull]
+        public TimingControlPoint TimingPointAfter(double time)
+        {
+            int index = BinarySearch(TimingPoints, time, EqualitySelection.Rightmost);
+            index = index < 0 ? ~index : index + 1;
+            return index < TimingPoints.Count ? TimingPoints[index] : null;
+        }
+
         /// <summary>
         /// Finds the maximum BPM represented by any timing control point.
         /// </summary>
@@ -156,7 +169,14 @@ public void RemoveGroup(ControlPointGroup group)
         public double GetClosestSnappedTime(double time, int beatDivisor, double? referenceTime = null)
         {
             var timingPoint = TimingPointAt(referenceTime ?? time);
-            return getClosestSnappedTime(timingPoint, time, beatDivisor);
+            double snappedTime = getClosestSnappedTime(timingPoint, time, beatDivisor);
+
+            if (referenceTime.HasValue)
+                return snappedTime;
+
+            // If there is a timing point right after the given time, we should check if it is closer than the snapped time and snap to it.
+            var timingPointAfter = TimingPointAfter(time);
+            return timingPointAfter is null || Math.Abs(time - snappedTime) < Math.Abs(time - timingPointAfter.Time) ? snappedTime : timingPointAfter.Time;
         }
 
         /// <summary>
@@ -230,17 +250,40 @@ public static T BinarySearch<T>(IReadOnlyList<T> list, double time)
         {
             ArgumentNullException.ThrowIfNull(list);
 
-            if (list.Count == 0)
-                return null;
+            int index = BinarySearch(list, time, EqualitySelection.Rightmost);
+
+            if (index < 0)
+                index = ~index - 1;
+
+            return index >= 0 ? list[index] : null;
+        }
+
+        /// <summary>
+        /// Binary searches one of the control point lists to find the active control point at <paramref name="time"/>.
+        /// </summary>
+        /// <param name="list">The list to search.</param>
+        /// <param name="time">The time to find the control point at.</param>
+        /// <param name="equalitySelection">Determines which index to return if there are multiple exact matches.</param>
+        /// <returns>The index of the control point at <paramref name="time"/>. Will return the complement of the index of the control point after <paramref name="time"/> if no exact match is found.</returns>
+        public static int BinarySearch<T>(IReadOnlyList<T> list, double time, EqualitySelection equalitySelection)
+            where T : class, IControlPoint
+        {
+            ArgumentNullException.ThrowIfNull(list);
+
+            int n = list.Count;
+
+            if (n == 0)
+                return -1;
 
             if (time < list[0].Time)
-                return null;
+                return -1;
 
-            if (time >= list[^1].Time)
-                return list[^1];
+            if (time > list[^1].Time)
+                return ~n;
 
             int l = 0;
-            int r = list.Count - 2;
+            int r = n - 1;
+            bool equalityFound = false;
 
             while (l <= r)
             {
@@ -251,11 +294,37 @@ public static T BinarySearch<T>(IReadOnlyList<T> list, double time)
                 else if (list[pivot].Time > time)
                     r = pivot - 1;
                 else
-                    return list[pivot];
+                {
+                    equalityFound = true;
+
+                    switch (equalitySelection)
+                    {
+                        case EqualitySelection.Leftmost:
+                            r = pivot - 1;
+                            break;
+
+                        case EqualitySelection.Rightmost:
+                            l = pivot + 1;
+                            break;
+
+                        default:
+                        case EqualitySelection.FirstFound:
+                            return pivot;
+                    }
+                }
             }
 
-            // l will be the first control point with Time > time, but we want the one before it
-            return list[l - 1];
+            if (!equalityFound) return ~l;
+
+            switch (equalitySelection)
+            {
+                case EqualitySelection.Leftmost:
+                    return l;
+
+                default:
+                case EqualitySelection.Rightmost:
+                    return l - 1;
+            }
         }
 
         /// <summary>
@@ -328,4 +397,11 @@ public ControlPointInfo DeepClone()
             return controlPointInfo;
         }
     }
+
+    public enum EqualitySelection
+    {
+        FirstFound,
+        Leftmost,
+        Rightmost
+    }
 }
diff --git a/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs b/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs
index 9418a389aaec..b068c87fbb10 100644
--- a/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs
@@ -16,6 +16,7 @@
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Screens.Edit;
 
 namespace osu.Game.Beatmaps.Formats
 {
@@ -336,7 +337,7 @@ private void handleEditor(string line)
                     break;
 
                 case @"BeatDivisor":
-                    beatmap.BeatmapInfo.BeatDivisor = Parsing.ParseInt(pair.Value);
+                    beatmap.BeatmapInfo.BeatDivisor = Math.Clamp(Parsing.ParseInt(pair.Value), BindableBeatDivisor.MINIMUM_DIVISOR, BindableBeatDivisor.MAXIMUM_DIVISOR);
                     break;
 
                 case @"GridSize":
diff --git a/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs b/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
index 8a8964ccd442..b0173b3ae3e1 100644
--- a/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
@@ -450,7 +450,7 @@ private void addPathData(TextWriter writer, IHasPath pathData, Vector2 position)
                     // Explicit segments have a new format in which the type is injected into the middle of the control point string.
                     // To preserve compatibility with osu-stable as much as possible, explicit segments with the same type are converted to use implicit segments by duplicating the control point.
                     // One exception are consecutive perfect curves, which aren't supported in osu!stable and can lead to decoding issues if encoded as implicit segments
-                    bool needsExplicitSegment = point.Type != lastType || point.Type == PathType.PERFECT_CURVE;
+                    bool needsExplicitSegment = point.Type != lastType || point.Type == PathType.PERFECT_CURVE || i == pathData.Path.ControlPoints.Count - 1;
 
                     // Another exception to this is when the last two control points of the last segment were duplicated. This is not a scenario supported by osu!stable.
                     // Lazer does not add implicit segments for the last two control points of _any_ explicit segment, so an explicit segment is forced in order to maintain consistency with the decoder.
diff --git a/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs b/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs
index 27bc80344930..eaa4d8ebfba9 100644
--- a/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs
+++ b/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Threading.Tasks;
 using Microsoft.Data.Sqlite;
@@ -78,8 +79,10 @@ private bool shouldFetchCache()
             // cached database exists on disk.
             && storage.Exists(cache_database_name);
 
-        public bool TryLookup(BeatmapInfo beatmapInfo, out OnlineBeatmapMetadata? onlineMetadata)
+        public bool TryLookup(BeatmapInfo beatmapInfo, [NotNullWhen(true)] out OnlineBeatmapMetadata? onlineMetadata)
         {
+            Debug.Assert(beatmapInfo.BeatmapSet != null);
+
             if (!Available)
             {
                 onlineMetadata = null;
@@ -94,43 +97,21 @@ public bool TryLookup(BeatmapInfo beatmapInfo, out OnlineBeatmapMetadata? online
                 return false;
             }
 
-            Debug.Assert(beatmapInfo.BeatmapSet != null);
-
             try
             {
-                using (var db = new SqliteConnection(string.Concat(@"Data Source=", storage.GetFullPath(@"online.db", true))))
+                using (var db = getConnection())
                 {
                     db.Open();
 
-                    using (var cmd = db.CreateCommand())
+                    switch (getCacheVersion(db))
                     {
-                        cmd.CommandText =
-                            @"SELECT beatmapset_id, beatmap_id, approved, user_id, checksum, last_update FROM osu_beatmaps WHERE checksum = @MD5Hash OR beatmap_id = @OnlineID OR filename = @Path";
-
-                        cmd.Parameters.Add(new SqliteParameter(@"@MD5Hash", beatmapInfo.MD5Hash));
-                        cmd.Parameters.Add(new SqliteParameter(@"@OnlineID", beatmapInfo.OnlineID));
-                        cmd.Parameters.Add(new SqliteParameter(@"@Path", beatmapInfo.Path));
-
-                        using (var reader = cmd.ExecuteReader())
-                        {
-                            if (reader.Read())
-                            {
-                                logForModel(beatmapInfo.BeatmapSet, $@"Cached local retrieval for {beatmapInfo}.");
-
-                                onlineMetadata = new OnlineBeatmapMetadata
-                                {
-                                    BeatmapSetID = reader.GetInt32(0),
-                                    BeatmapID = reader.GetInt32(1),
-                                    BeatmapStatus = (BeatmapOnlineStatus)reader.GetByte(2),
-                                    BeatmapSetStatus = (BeatmapOnlineStatus)reader.GetByte(2),
-                                    AuthorID = reader.GetInt32(3),
-                                    MD5Hash = reader.GetString(4),
-                                    LastUpdated = reader.GetDateTimeOffset(5),
-                                    // TODO: DateSubmitted and DateRanked are not provided by local cache.
-                                };
-                                return true;
-                            }
-                        }
+                        case 1:
+                            // will eventually become irrelevant due to the monthly recycling of local caches
+                            // can be removed 20250221
+                            return queryCacheVersion1(db, beatmapInfo, out onlineMetadata);
+
+                        case 2:
+                            return queryCacheVersion2(db, beatmapInfo, out onlineMetadata);
                     }
                 }
             }
@@ -145,6 +126,9 @@ public bool TryLookup(BeatmapInfo beatmapInfo, out OnlineBeatmapMetadata? online
             return false;
         }
 
+        private SqliteConnection getConnection() =>
+            new SqliteConnection(string.Concat(@"Data Source=", storage.GetFullPath(@"online.db", true)));
+
         private void prepareLocalCache()
         {
             bool isRefetch = storage.Exists(cache_database_name);
@@ -211,6 +195,124 @@ private void prepareLocalCache()
             });
         }
 
+        public int GetCacheVersion()
+        {
+            using (var connection = getConnection())
+            {
+                connection.Open();
+                return getCacheVersion(connection);
+            }
+        }
+
+        private int getCacheVersion(SqliteConnection connection)
+        {
+            using (var cmd = connection.CreateCommand())
+            {
+                cmd.CommandText = @"SELECT COUNT(1) FROM `sqlite_master` WHERE `type` = 'table' AND `name` = 'schema_version'";
+
+                using var reader = cmd.ExecuteReader();
+
+                if (!reader.Read())
+                    throw new InvalidOperationException("Error when attempting to check for existence of `schema_version` table.");
+
+                // No versioning table means that this is the very first version of the schema.
+                if (reader.GetInt32(0) == 0)
+                    return 1;
+            }
+
+            using (var cmd = connection.CreateCommand())
+            {
+                cmd.CommandText = @"SELECT `number` FROM `schema_version`";
+
+                using var reader = cmd.ExecuteReader();
+
+                if (!reader.Read())
+                    throw new InvalidOperationException("Error when attempting to query schema version.");
+
+                return reader.GetInt32(0);
+            }
+        }
+
+        private bool queryCacheVersion1(SqliteConnection db, BeatmapInfo beatmapInfo, out OnlineBeatmapMetadata? onlineMetadata)
+        {
+            Debug.Assert(beatmapInfo.BeatmapSet != null);
+
+            using var cmd = db.CreateCommand();
+
+            cmd.CommandText =
+                @"SELECT beatmapset_id, beatmap_id, approved, user_id, checksum, last_update FROM osu_beatmaps WHERE checksum = @MD5Hash OR beatmap_id = @OnlineID OR filename = @Path";
+
+            cmd.Parameters.Add(new SqliteParameter(@"@MD5Hash", beatmapInfo.MD5Hash));
+            cmd.Parameters.Add(new SqliteParameter(@"@OnlineID", beatmapInfo.OnlineID));
+            cmd.Parameters.Add(new SqliteParameter(@"@Path", beatmapInfo.Path));
+
+            using var reader = cmd.ExecuteReader();
+
+            if (reader.Read())
+            {
+                logForModel(beatmapInfo.BeatmapSet, $@"Cached local retrieval for {beatmapInfo} (cache version 1).");
+
+                onlineMetadata = new OnlineBeatmapMetadata
+                {
+                    BeatmapSetID = reader.GetInt32(0),
+                    BeatmapID = reader.GetInt32(1),
+                    BeatmapStatus = (BeatmapOnlineStatus)reader.GetByte(2),
+                    BeatmapSetStatus = (BeatmapOnlineStatus)reader.GetByte(2),
+                    AuthorID = reader.GetInt32(3),
+                    MD5Hash = reader.GetString(4),
+                    LastUpdated = reader.GetDateTimeOffset(5),
+                    // TODO: DateSubmitted and DateRanked are not provided by local cache in this version.
+                };
+                return true;
+            }
+
+            onlineMetadata = null;
+            return false;
+        }
+
+        private bool queryCacheVersion2(SqliteConnection db, BeatmapInfo beatmapInfo, out OnlineBeatmapMetadata? onlineMetadata)
+        {
+            Debug.Assert(beatmapInfo.BeatmapSet != null);
+
+            using var cmd = db.CreateCommand();
+
+            cmd.CommandText =
+                """
+                SELECT `b`.`beatmapset_id`, `b`.`beatmap_id`, `b`.`approved`, `b`.`user_id`, `b`.`checksum`, `b`.`last_update`, `s`.`submit_date`, `s`.`approved_date`
+                FROM `osu_beatmaps` AS `b`
+                JOIN `osu_beatmapsets` AS `s` ON `s`.`beatmapset_id` = `b`.`beatmapset_id`
+                WHERE `b`.`checksum` = @MD5Hash OR `b`.`beatmap_id` = @OnlineID OR `b`.`filename` = @Path
+                """;
+
+            cmd.Parameters.Add(new SqliteParameter(@"@MD5Hash", beatmapInfo.MD5Hash));
+            cmd.Parameters.Add(new SqliteParameter(@"@OnlineID", beatmapInfo.OnlineID));
+            cmd.Parameters.Add(new SqliteParameter(@"@Path", beatmapInfo.Path));
+
+            using var reader = cmd.ExecuteReader();
+
+            if (reader.Read())
+            {
+                logForModel(beatmapInfo.BeatmapSet, $@"Cached local retrieval for {beatmapInfo} (cache version 2).");
+
+                onlineMetadata = new OnlineBeatmapMetadata
+                {
+                    BeatmapSetID = reader.GetInt32(0),
+                    BeatmapID = reader.GetInt32(1),
+                    BeatmapStatus = (BeatmapOnlineStatus)reader.GetByte(2),
+                    BeatmapSetStatus = (BeatmapOnlineStatus)reader.GetByte(2),
+                    AuthorID = reader.GetInt32(3),
+                    MD5Hash = reader.GetString(4),
+                    LastUpdated = reader.GetDateTimeOffset(5),
+                    DateSubmitted = reader.GetDateTimeOffset(6),
+                    DateRanked = reader.GetDateTimeOffset(7),
+                };
+                return true;
+            }
+
+            onlineMetadata = null;
+            return false;
+        }
+
         private static void log(string message)
             => Logger.Log($@"[{nameof(LocalCachedBeatmapMetadataSource)}] {message}", LoggingTarget.Database);
 
diff --git a/osu.Game/Configuration/OsuConfigManager.cs b/osu.Game/Configuration/OsuConfigManager.cs
index d00856dd8057..8d6c244b350c 100644
--- a/osu.Game/Configuration/OsuConfigManager.cs
+++ b/osu.Game/Configuration/OsuConfigManager.cs
@@ -205,6 +205,8 @@ protected override void InitialiseDefaults()
 
             SetDefault(OsuSetting.EditorTimelineShowTimingChanges, true);
             SetDefault(OsuSetting.EditorTimelineShowTicks, true);
+
+            SetDefault(OsuSetting.AlwaysShowHoldForMenuButton, false);
         }
 
         protected override bool CheckLookupContainsPrivateInformation(OsuSetting lookup)
@@ -429,5 +431,6 @@ public enum OsuSetting
         HideCountryFlags,
         EditorTimelineShowTimingChanges,
         EditorTimelineShowTicks,
+        AlwaysShowHoldForMenuButton
     }
 }
diff --git a/osu.Game/Configuration/SessionStatics.cs b/osu.Game/Configuration/SessionStatics.cs
index 1548b781a704..225f20938039 100644
--- a/osu.Game/Configuration/SessionStatics.cs
+++ b/osu.Game/Configuration/SessionStatics.cs
@@ -80,5 +80,11 @@ public enum Static
         /// Stores the local user's last score (can be completed or aborted).
         /// </summary>
         LastLocalUserScore,
+
+        /// <summary>
+        /// Whether the intro animation for the daily challenge screen has been played once.
+        /// This is reset when a new challenge is up.
+        /// </summary>
+        DailyChallengeIntroPlayed,
     }
 }
diff --git a/osu.Game/Configuration/SettingSourceAttribute.cs b/osu.Game/Configuration/SettingSourceAttribute.cs
index 1e425c88a6c3..30cda4047ec8 100644
--- a/osu.Game/Configuration/SettingSourceAttribute.cs
+++ b/osu.Game/Configuration/SettingSourceAttribute.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using JetBrains.Annotations;
@@ -15,6 +14,7 @@
 using osu.Framework.Localisation;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
+using osu.Game.Utils;
 
 namespace osu.Game.Configuration
 {
@@ -186,6 +186,16 @@ public static IEnumerable<Drawable> CreateSettingsControls(this object obj)
 
                         break;
 
+                    case BindableColour4 bColour:
+                        yield return new SettingsColour
+                        {
+                            LabelText = attr.Label,
+                            TooltipText = attr.Description,
+                            Current = bColour
+                        };
+
+                        break;
+
                     case IBindable bindable:
                         var dropdownType = typeof(ModSettingsEnumDropdown<>).MakeGenericType(bindable.GetType().GetGenericArguments()[0]);
                         var dropdown = (Drawable)Activator.CreateInstance(dropdownType)!;
@@ -227,11 +237,11 @@ public static object GetUnderlyingSettingValue(this object setting)
                 case Bindable<bool> b:
                     return b.Value;
 
+                case BindableColour4 c:
+                    return c.Value.ToHex();
+
                 case IBindable u:
-                    // An unknown (e.g. enum) generic type.
-                    var valueMethod = u.GetType().GetProperty(nameof(IBindable<int>.Value));
-                    Debug.Assert(valueMethod != null);
-                    return valueMethod.GetValue(u)!;
+                    return BindableValueAccessor.GetValue(u);
 
                 default:
                     // fall back for non-bindable cases.
diff --git a/osu.Game/Database/BackgroundDataStoreProcessor.cs b/osu.Game/Database/BackgroundDataStoreProcessor.cs
index 16ff766ea4ed..0fa785e49425 100644
--- a/osu.Game/Database/BackgroundDataStoreProcessor.cs
+++ b/osu.Game/Database/BackgroundDataStoreProcessor.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -11,6 +12,7 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Logging;
+using osu.Framework.Platform;
 using osu.Game.Beatmaps;
 using osu.Game.Extensions;
 using osu.Game.Online.API;
@@ -61,6 +63,9 @@ public partial class BackgroundDataStoreProcessor : Component
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
+        [Resolved]
+        private Storage storage { get; set; } = null!;
+
         protected virtual int TimeToSleepDuringGameplay => 30000;
 
         protected override void LoadComplete()
@@ -78,6 +83,7 @@ protected override void LoadComplete()
                 processScoresWithMissingStatistics();
                 convertLegacyTotalScoreToStandardised();
                 upgradeScoreRanks();
+                backpopulateMissingSubmissionAndRankDates();
             }, TaskCreationOptions.LongRunning).ContinueWith(t =>
             {
                 if (t.Exception?.InnerException is ObjectDisposedException)
@@ -443,6 +449,104 @@ private void upgradeScoreRanks()
             completeNotification(notification, processedCount, scoreIds.Count, failedCount);
         }
 
+        private void backpopulateMissingSubmissionAndRankDates()
+        {
+            var localMetadataSource = new LocalCachedBeatmapMetadataSource(storage);
+
+            if (!localMetadataSource.Available)
+            {
+                Logger.Log("Cannot backpopulate missing submission/rank dates because the local metadata cache is missing.");
+                return;
+            }
+
+            try
+            {
+                if (localMetadataSource.GetCacheVersion() < 2)
+                {
+                    Logger.Log("Cannot backpopulate missing submission/rank dates because the local metadata cache is too old.");
+                    return;
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Error when trying to query version of local metadata cache: {ex}");
+                return;
+            }
+
+            Logger.Log("Querying for beatmap sets that contain missing submission/rank date...");
+
+            HashSet<Guid> beatmapSetIds = realmAccess.Run(r => new HashSet<Guid>(
+                r.All<BeatmapSetInfo>()
+                 .Where(b => b.StatusInt > 0 && (b.DateRanked == null || b.DateSubmitted == null))
+                 .AsEnumerable()
+                 .Select(b => b.ID)));
+
+            if (beatmapSetIds.Count == 0)
+                return;
+
+            Logger.Log($"Found {beatmapSetIds.Count} beatmap sets with missing submission/rank date.");
+
+            var notification = showProgressNotification(beatmapSetIds.Count, "Populating missing submission and rank dates", "beatmap sets now have correct submission and rank dates.");
+
+            int processedCount = 0;
+            int failedCount = 0;
+
+            foreach (var id in beatmapSetIds)
+            {
+                if (notification?.State == ProgressNotificationState.Cancelled)
+                    break;
+
+                updateNotificationProgress(notification, processedCount, beatmapSetIds.Count);
+
+                sleepIfRequired();
+
+                try
+                {
+                    // Can't use async overload because we're not on the update thread.
+                    // ReSharper disable once MethodHasAsyncOverload
+                    bool succeeded = realmAccess.Write(r =>
+                    {
+                        BeatmapSetInfo beatmapSet = r.Find<BeatmapSetInfo>(id)!;
+
+                        // we want any ranked representative of the set.
+                        // the reason for checking ranked status of the difficulty is that it can be locally modified,
+                        // at which point the lookup will fail - but there might still be another unmodified difficulty on which it will work.
+                        if (beatmapSet.Beatmaps.FirstOrDefault(b => b.Status >= BeatmapOnlineStatus.Ranked) is not BeatmapInfo beatmap)
+                            return false;
+
+                        bool lookupSucceeded = localMetadataSource.TryLookup(beatmap, out var result);
+
+                        if (lookupSucceeded)
+                        {
+                            Debug.Assert(result != null);
+                            beatmapSet.DateRanked = result.DateRanked;
+                            beatmapSet.DateSubmitted = result.DateSubmitted;
+                            return true;
+                        }
+
+                        Logger.Log($"Could not find {beatmapSet.GetDisplayString()} in local cache while backpopulating missing submission/rank date");
+                        return false;
+                    });
+
+                    if (succeeded)
+                        ++processedCount;
+                    else
+                        ++failedCount;
+                }
+                catch (ObjectDisposedException)
+                {
+                    throw;
+                }
+                catch (Exception e)
+                {
+                    Logger.Log($"Failed to update ranked/submitted dates for beatmap set {id}: {e}");
+                    ++failedCount;
+                }
+            }
+
+            completeNotification(notification, processedCount, beatmapSetIds.Count, failedCount);
+        }
+
         private void updateNotificationProgress(ProgressNotification? notification, int processedCount, int totalCount)
         {
             if (notification == null)
diff --git a/osu.Game/Database/DetachedBeatmapStore.cs b/osu.Game/Database/DetachedBeatmapStore.cs
new file mode 100644
index 000000000000..64aeeccd9a28
--- /dev/null
+++ b/osu.Game/Database/DetachedBeatmapStore.cs
@@ -0,0 +1,163 @@
+// 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.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
+using Realms;
+
+namespace osu.Game.Database
+{
+    public partial class DetachedBeatmapStore : Component
+    {
+        private readonly ManualResetEventSlim loaded = new ManualResetEventSlim();
+
+        private readonly BindableList<BeatmapSetInfo> detachedBeatmapSets = new BindableList<BeatmapSetInfo>();
+
+        private IDisposable? realmSubscription;
+
+        private readonly Queue<OperationArgs> pendingOperations = new Queue<OperationArgs>();
+
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
+        public IBindableList<BeatmapSetInfo> GetDetachedBeatmaps(CancellationToken? cancellationToken)
+        {
+            loaded.Wait(cancellationToken ?? CancellationToken.None);
+            return detachedBeatmapSets.GetBoundCopy();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            realmSubscription = realm.RegisterForNotifications(r => r.All<BeatmapSetInfo>().Where(s => !s.DeletePending && !s.Protected), beatmapSetsChanged);
+        }
+
+        private void beatmapSetsChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet? changes)
+        {
+            if (changes == null)
+            {
+                if (detachedBeatmapSets.Count > 0 && sender.Count == 0)
+                {
+                    // Usually we'd reset stuff here, but doing so triggers a silly flow which ends up deadlocking realm.
+                    // Additionally, user should not be at song select when realm is blocking all operations in the first place.
+                    //
+                    // Note that due to the catch-up logic below, once operations are restored we will still be in a roughly
+                    // correct state. The only things that this return will change is the carousel will not empty *during* the blocking
+                    // operation.
+                    return;
+                }
+
+                // Detaching beatmaps takes some time, so let's make sure it doesn't run on the update thread.
+                var frozenSets = sender.Freeze();
+
+                Task.Factory.StartNew(() =>
+                {
+                    try
+                    {
+                        realm.Run(_ =>
+                        {
+                            var detached = frozenSets.Detach();
+
+                            detachedBeatmapSets.Clear();
+                            detachedBeatmapSets.AddRange(detached);
+                        });
+                    }
+                    finally
+                    {
+                        loaded.Set();
+                    }
+                }, TaskCreationOptions.LongRunning).FireAndForget();
+
+                return;
+            }
+
+            foreach (int i in changes.DeletedIndices.OrderDescending())
+            {
+                pendingOperations.Enqueue(new OperationArgs
+                {
+                    Type = OperationType.Remove,
+                    Index = i,
+                });
+            }
+
+            foreach (int i in changes.InsertedIndices)
+            {
+                pendingOperations.Enqueue(new OperationArgs
+                {
+                    Type = OperationType.Insert,
+                    BeatmapSet = sender[i].Detach(),
+                    Index = i,
+                });
+            }
+
+            foreach (int i in changes.NewModifiedIndices)
+            {
+                pendingOperations.Enqueue(new OperationArgs
+                {
+                    Type = OperationType.Update,
+                    BeatmapSet = sender[i].Detach(),
+                    Index = i,
+                });
+            }
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // We can't start processing operations until we have finished detaching the initial list.
+            if (!loaded.IsSet)
+                return;
+
+            // If this ever leads to performance issues, we could dequeue a limited number of operations per update frame.
+            while (pendingOperations.TryDequeue(out var op))
+            {
+                switch (op.Type)
+                {
+                    case OperationType.Insert:
+                        detachedBeatmapSets.Insert(op.Index, op.BeatmapSet!);
+                        break;
+
+                    case OperationType.Update:
+                        detachedBeatmapSets.ReplaceRange(op.Index, 1, new[] { op.BeatmapSet! });
+                        break;
+
+                    case OperationType.Remove:
+                        detachedBeatmapSets.RemoveAt(op.Index);
+                        break;
+                }
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            loaded.Set();
+            loaded.Dispose();
+            realmSubscription?.Dispose();
+        }
+
+        private record OperationArgs
+        {
+            public OperationType Type;
+            public BeatmapSetInfo? BeatmapSet;
+            public int Index;
+        }
+
+        private enum OperationType
+        {
+            Insert,
+            Update,
+            Remove
+        }
+    }
+}
diff --git a/osu.Game/Database/RealmArchiveModelImporter.cs b/osu.Game/Database/RealmArchiveModelImporter.cs
index 38df2ac1dcf6..cf0625c51c99 100644
--- a/osu.Game/Database/RealmArchiveModelImporter.cs
+++ b/osu.Game/Database/RealmArchiveModelImporter.cs
@@ -195,6 +195,7 @@ public async Task<ExternalEditOperation<TModel>> BeginExternalEditing(TModel mod
 
                 Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
 
+                // Consider using hard links here to make this instant.
                 using (var inStream = Files.Storage.GetStream(sourcePath))
                 using (var outStream = File.Create(destinationPath))
                     await inStream.CopyToAsync(outStream).ConfigureAwait(false);
diff --git a/osu.Game/Graphics/UserInterface/ExternalLinkButton.cs b/osu.Game/Graphics/UserInterface/ExternalLinkButton.cs
index 7ba3d5516250..806b7a10b8b9 100644
--- a/osu.Game/Graphics/UserInterface/ExternalLinkButton.cs
+++ b/osu.Game/Graphics/UserInterface/ExternalLinkButton.cs
@@ -10,9 +10,6 @@
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
-using osu.Framework.Platform;
-using osu.Game.Overlays;
-using osu.Game.Overlays.OSD;
 using osuTK;
 using osuTK.Graphics;
 
@@ -25,13 +22,7 @@ public partial class ExternalLinkButton : CompositeDrawable, IHasTooltip, IHasCo
         private Color4 hoverColour;
 
         [Resolved]
-        private GameHost host { get; set; } = null!;
-
-        [Resolved]
-        private Clipboard clipboard { get; set; } = null!;
-
-        [Resolved]
-        private OnScreenDisplay? onScreenDisplay { get; set; }
+        private OsuGame? game { get; set; }
 
         private readonly SpriteIcon linkIcon;
 
@@ -71,7 +62,7 @@ protected override void OnHoverLost(HoverLostEvent e)
         protected override bool OnClick(ClickEvent e)
         {
             if (Link != null)
-                host.OpenUrlExternally(Link);
+                game?.OpenUrlExternally(Link);
             return true;
         }
 
@@ -85,8 +76,8 @@ public MenuItem[] ContextMenuItems
 
                 if (Link != null)
                 {
-                    items.Add(new OsuMenuItem("Open", MenuItemType.Highlighted, () => host.OpenUrlExternally(Link)));
-                    items.Add(new OsuMenuItem("Copy URL", MenuItemType.Standard, copyUrl));
+                    items.Add(new OsuMenuItem("Open", MenuItemType.Highlighted, () => game?.OpenUrlExternally(Link)));
+                    items.Add(new OsuMenuItem("Copy link", MenuItemType.Standard, copyUrl));
                 }
 
                 return items.ToArray();
@@ -95,11 +86,9 @@ public MenuItem[] ContextMenuItems
 
         private void copyUrl()
         {
-            if (Link != null)
-            {
-                clipboard.SetText(Link);
-                onScreenDisplay?.Display(new CopyUrlToast());
-            }
+            if (Link == null) return;
+
+            game?.CopyUrlToClipboard(Link);
         }
     }
 }
diff --git a/osu.Game/Graphics/UserInterface/OsuDropdown.cs b/osu.Game/Graphics/UserInterface/OsuDropdown.cs
index 71ae149cf613..dc42216c55a5 100644
--- a/osu.Game/Graphics/UserInterface/OsuDropdown.cs
+++ b/osu.Game/Graphics/UserInterface/OsuDropdown.cs
@@ -75,7 +75,7 @@ public OsuDropdownMenu()
             [BackgroundDependencyLoader(true)]
             private void load(OverlayColourProvider? colourProvider, OsuColour colours, AudioManager audio)
             {
-                BackgroundColour = colourProvider?.Background5 ?? Color4.Black.Opacity(0.5f);
+                BackgroundColour = colourProvider?.Background5 ?? Color4.Black;
                 HoverColour = colourProvider?.Light4 ?? colours.PinkDarker;
                 SelectionColour = colourProvider?.Background3 ?? colours.PinkDarker.Opacity(0.5f);
 
@@ -397,7 +397,7 @@ private void updateColour()
             {
                 bool hovered = Enabled.Value && IsHovered;
                 var hoveredColour = colourProvider?.Light4 ?? colours.PinkDarker;
-                var unhoveredColour = colourProvider?.Background5 ?? Color4.Black.Opacity(0.5f);
+                var unhoveredColour = colourProvider?.Background5 ?? Color4.Black;
 
                 Colour = Color4.White;
                 Alpha = Enabled.Value ? 1 : 0.3f;
diff --git a/osu.Game/Graphics/UserInterface/OsuSliderBar.cs b/osu.Game/Graphics/UserInterface/OsuSliderBar.cs
index 9cb6356cabd1..334fe343ae68 100644
--- a/osu.Game/Graphics/UserInterface/OsuSliderBar.cs
+++ b/osu.Game/Graphics/UserInterface/OsuSliderBar.cs
@@ -46,7 +46,7 @@ private void load(AudioManager audio)
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            CurrentNumber.BindValueChanged(current => TooltipText = getTooltipText(current.NewValue), true);
+            CurrentNumber.BindValueChanged(current => TooltipText = GetDisplayableValue(current.NewValue), true);
         }
 
         protected override void OnUserChange(T value)
@@ -55,7 +55,7 @@ protected override void OnUserChange(T value)
 
             playSample(value);
 
-            TooltipText = getTooltipText(value);
+            TooltipText = GetDisplayableValue(value);
         }
 
         private void playSample(T value)
@@ -83,7 +83,7 @@ private void playSample(T value)
             channel.Play();
         }
 
-        private LocalisableString getTooltipText(T value)
+        public LocalisableString GetDisplayableValue(T value)
         {
             if (CurrentNumber.IsInteger)
                 return int.CreateTruncating(value).ToString("N0");
diff --git a/osu.Game/Graphics/UserInterfaceV2/FileSelection/BackgroundLayer.cs b/osu.Game/Graphics/UserInterfaceV2/FileSelection/BackgroundLayer.cs
new file mode 100644
index 000000000000..cd3199c6f5fc
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FileSelection/BackgroundLayer.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 osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+
+namespace osu.Game.Graphics.UserInterfaceV2.FileSelection
+{
+    internal partial class BackgroundLayer : CompositeDrawable
+    {
+        private Box background = null!;
+
+        private readonly float defaultAlpha;
+
+        public BackgroundLayer(float defaultAlpha = 0f)
+        {
+            Depth = float.MaxValue;
+
+            this.defaultAlpha = defaultAlpha;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider overlayColourProvider)
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            Masking = true;
+            CornerRadius = 5;
+
+            InternalChildren = new Drawable[]
+            {
+                new HoverClickSounds(),
+                background = new Box
+                {
+                    Alpha = defaultAlpha,
+                    Colour = overlayColourProvider.Background3,
+                    RelativeSizeAxes = Axes.Both,
+                },
+            };
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            background.FadeTo(1, 200, Easing.OutQuint);
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            background.FadeTo(defaultAlpha, 500, Easing.OutQuint);
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorHiddenToggle.cs b/osu.Game/Graphics/UserInterfaceV2/FileSelection/HiddenFilesToggleCheckbox.cs
similarity index 72%
rename from osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorHiddenToggle.cs
rename to osu.Game/Graphics/UserInterfaceV2/FileSelection/HiddenFilesToggleCheckbox.cs
index 7665ed507f38..07d84a009567 100644
--- a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorHiddenToggle.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/FileSelection/HiddenFilesToggleCheckbox.cs
@@ -8,20 +8,23 @@
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Graphics.UserInterfaceV2
+namespace osu.Game.Graphics.UserInterfaceV2.FileSelection
 {
-    internal partial class OsuDirectorySelectorHiddenToggle : OsuCheckbox
+    internal partial class HiddenFilesToggleCheckbox : OsuCheckbox
     {
-        public OsuDirectorySelectorHiddenToggle()
+        public HiddenFilesToggleCheckbox()
         {
             RelativeSizeAxes = Axes.None;
             AutoSizeAxes = Axes.None;
-            Size = new Vector2(100, 50);
+            Size = new Vector2(140, OsuDirectorySelectorBreadcrumbDisplay.HEIGHT);
+            Margin = new MarginPadding { Right = OsuDirectorySelectorBreadcrumbDisplay.HORIZONTAL_PADDING, };
             Anchor = Anchor.CentreLeft;
             Origin = Anchor.CentreLeft;
             LabelTextFlowContainer.Anchor = Anchor.CentreLeft;
             LabelTextFlowContainer.Origin = Anchor.CentreLeft;
             LabelText = @"Show hidden";
+
+            Scale = new Vector2(0.8f);
         }
 
         [BackgroundDependencyLoader(true)]
diff --git a/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorBreadcrumbDisplay.cs b/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorBreadcrumbDisplay.cs
new file mode 100644
index 000000000000..aeeda82bfb42
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorBreadcrumbDisplay.cs
@@ -0,0 +1,106 @@
+// 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.IO;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+using osuTK;
+
+namespace osu.Game.Graphics.UserInterfaceV2.FileSelection
+{
+    internal partial class OsuDirectorySelectorBreadcrumbDisplay : DirectorySelectorBreadcrumbDisplay
+    {
+        public const float HEIGHT = 45;
+        public const float HORIZONTAL_PADDING = 20;
+
+        protected override Drawable CreateCaption() => Empty().With(d =>
+        {
+            d.Origin = Anchor.CentreLeft;
+            d.Anchor = Anchor.CentreLeft;
+            d.Alpha = 0;
+        });
+
+        protected override DirectorySelectorDirectory CreateRootDirectoryItem() => new OsuBreadcrumbDisplayComputer();
+
+        protected override DirectorySelectorDirectory CreateDirectoryItem(DirectoryInfo directory, string? displayName = null) => new OsuBreadcrumbDisplayDirectory(directory, displayName);
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
+        {
+            ((FillFlowContainer)InternalChild).Padding = new MarginPadding
+            {
+                Horizontal = HORIZONTAL_PADDING,
+                Vertical = 10,
+            };
+
+            AddInternal(new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Colour = colourProvider.Background4,
+                Depth = 1,
+            });
+        }
+
+        private partial class OsuBreadcrumbDisplayComputer : OsuBreadcrumbDisplayDirectory
+        {
+            protected override IconUsage? Icon => null;
+
+            public OsuBreadcrumbDisplayComputer()
+                : base(null, "Computer")
+            {
+            }
+        }
+
+        private partial class OsuBreadcrumbDisplayDirectory : DirectorySelectorDirectory
+        {
+            public OsuBreadcrumbDisplayDirectory(DirectoryInfo? directory, string? displayName = null)
+                : base(directory, displayName)
+            {
+            }
+
+            [Resolved]
+            private OverlayColourProvider colourProvider { get; set; } = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Anchor = Anchor.CentreLeft;
+                Origin = Anchor.CentreLeft;
+
+                Flow.AutoSizeAxes = Axes.X;
+                Flow.Height = 25;
+                Flow.Margin = new MarginPadding { Horizontal = 10, };
+
+                AddRangeInternal(new Drawable[]
+                {
+                    new BackgroundLayer(0.5f)
+                    {
+                        Depth = 1
+                    },
+                    new HoverClickSounds(),
+                });
+
+                Flow.Add(new SpriteIcon
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Icon = FontAwesome.Solid.ChevronRight,
+                    Size = new Vector2(FONT_SIZE / 2),
+                    Margin = new MarginPadding { Left = 5, },
+                });
+                Flow.Colour = colourProvider.Light3;
+            }
+
+            protected override SpriteText CreateSpriteText() => new OsuSpriteText().With(t => t.Font = OsuFont.Default.With(weight: FontWeight.SemiBold));
+
+            protected override IconUsage? Icon => Directory.Name.Contains(Path.DirectorySeparatorChar) ? FontAwesome.Solid.Database : null;
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorDirectory.cs b/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorDirectory.cs
new file mode 100644
index 000000000000..0da4e1929f39
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorDirectory.cs
@@ -0,0 +1,37 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.IO;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Graphics.UserInterfaceV2.FileSelection
+{
+    internal partial class OsuDirectorySelectorDirectory : DirectorySelectorDirectory
+    {
+        public OsuDirectorySelectorDirectory(DirectoryInfo directory, string? displayName = null)
+            : base(directory, displayName)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Flow.AutoSizeAxes = Axes.X;
+            Flow.Height = OsuDirectorySelector.ITEM_HEIGHT;
+
+            AddInternal(new BackgroundLayer());
+
+            Colour = colours.Orange1;
+        }
+
+        protected override SpriteText CreateSpriteText() => new OsuSpriteText().With(t => t.Font = OsuFont.Default.With(weight: FontWeight.Bold));
+
+        protected override IconUsage? Icon => Directory.Name.Contains(Path.DirectorySeparatorChar)
+            ? FontAwesome.Solid.Database
+            : FontAwesome.Regular.Folder;
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorParentDirectory.cs b/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorParentDirectory.cs
similarity index 64%
rename from osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorParentDirectory.cs
rename to osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorParentDirectory.cs
index c0ac9f21ca79..e5e1e0b7f317 100644
--- a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorParentDirectory.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/FileSelection/OsuDirectorySelectorParentDirectory.cs
@@ -2,9 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.IO;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Overlays;
 
-namespace osu.Game.Graphics.UserInterfaceV2
+namespace osu.Game.Graphics.UserInterfaceV2.FileSelection
 {
     internal partial class OsuDirectorySelectorParentDirectory : OsuDirectorySelectorDirectory
     {
@@ -14,5 +16,11 @@ public OsuDirectorySelectorParentDirectory(DirectoryInfo directory)
             : base(directory, "..")
         {
         }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
+        {
+            Colour = colourProvider.Content1;
+        }
     }
 }
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormCheckBox.cs b/osu.Game/Graphics/UserInterfaceV2/FormCheckBox.cs
new file mode 100644
index 000000000000..d4cd86010fc2
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FormCheckBox.cs
@@ -0,0 +1,161 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Localisation;
+using osu.Game.Overlays;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public partial class FormCheckBox : CompositeDrawable, IHasCurrentValue<bool>
+    {
+        public Bindable<bool> Current
+        {
+            get => current.Current;
+            set => current.Current = value;
+        }
+
+        private readonly BindableWithCurrent<bool> current = new BindableWithCurrent<bool>();
+
+        /// <summary>
+        /// Caption describing this slider bar, displayed on top of the controls.
+        /// </summary>
+        public LocalisableString Caption { get; init; }
+
+        /// <summary>
+        /// Hint text containing an extended description of this slider bar, displayed in a tooltip when hovering the caption.
+        /// </summary>
+        public LocalisableString HintText { get; init; }
+
+        private Box background = null!;
+        private FormFieldCaption caption = null!;
+        private OsuSpriteText text = null!;
+        private Nub checkbox = null!;
+
+        private Sample? sampleChecked;
+        private Sample? sampleUnchecked;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = 50;
+
+            Masking = true;
+            CornerRadius = 5;
+            CornerExponent = 2.5f;
+
+            InternalChildren = new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background5,
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding(9),
+                    Children = new Drawable[]
+                    {
+                        caption = new FormFieldCaption
+                        {
+                            Caption = Caption,
+                            TooltipText = HintText,
+                            Anchor = Anchor.TopLeft,
+                            Origin = Anchor.TopLeft,
+                        },
+                        text = new OsuSpriteText
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                        },
+                        checkbox = new Nub
+                        {
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreRight,
+                            Current = Current,
+                        },
+                    },
+                },
+            };
+
+            sampleChecked = audio.Samples.Get(@"UI/check-on");
+            sampleUnchecked = audio.Samples.Get(@"UI/check-off");
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            current.BindValueChanged(_ =>
+            {
+                updateState();
+                playSamples();
+                background.FlashColour(ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark2), 800, Easing.OutQuint);
+            });
+            current.BindDisabledChanged(_ => updateState(), true);
+        }
+
+        private void playSamples()
+        {
+            if (Current.Value)
+                sampleChecked?.Play();
+            else
+                sampleUnchecked?.Play();
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateState();
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            updateState();
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            if (!Current.Disabled)
+                Current.Value = !Current.Value;
+            return true;
+        }
+
+        private void updateState()
+        {
+            background.Colour = Current.Disabled ? colourProvider.Background4 : colourProvider.Background5;
+            caption.Colour = Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content2;
+            checkbox.Colour = Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content1;
+            text.Colour = Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content1;
+
+            text.Text = Current.Value ? CommonStrings.Enabled : CommonStrings.Disabled;
+
+            if (!Current.Disabled)
+            {
+                BorderThickness = IsHovered ? 2 : 0;
+
+                if (IsHovered)
+                    BorderColour = colourProvider.Light4;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormDropdown.cs b/osu.Game/Graphics/UserInterfaceV2/FormDropdown.cs
new file mode 100644
index 000000000000..d47b9ac73de1
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FormDropdown.cs
@@ -0,0 +1,251 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+using osuTK;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public partial class FormDropdown<T> : OsuDropdown<T>
+    {
+        /// <summary>
+        /// Caption describing this slider bar, displayed on top of the controls.
+        /// </summary>
+        public LocalisableString Caption { get; init; }
+
+        /// <summary>
+        /// Hint text containing an extended description of this slider bar, displayed in a tooltip when hovering the caption.
+        /// </summary>
+        public LocalisableString HintText { get; init; }
+
+        private FormDropdownHeader header = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.X;
+
+            header.Caption = Caption;
+            header.HintText = HintText;
+        }
+
+        protected override DropdownHeader CreateHeader() => header = new FormDropdownHeader
+        {
+            Dropdown = this,
+        };
+
+        protected override DropdownMenu CreateMenu() => new FormDropdownMenu();
+
+        private partial class FormDropdownHeader : DropdownHeader
+        {
+            public FormDropdown<T> Dropdown { get; set; } = null!;
+
+            protected override DropdownSearchBar CreateSearchBar() => SearchBar = new FormDropdownSearchBar();
+
+            private LocalisableString captionText;
+            private LocalisableString hintText;
+            private LocalisableString labelText;
+
+            public LocalisableString Caption
+            {
+                get => captionText;
+                set
+                {
+                    captionText = value;
+
+                    if (caption.IsNotNull())
+                        caption.Caption = value;
+                }
+            }
+
+            public LocalisableString HintText
+            {
+                get => hintText;
+                set
+                {
+                    hintText = value;
+
+                    if (caption.IsNotNull())
+                        caption.TooltipText = value;
+                }
+            }
+
+            protected override LocalisableString Label
+            {
+                get => labelText;
+                set
+                {
+                    labelText = value;
+
+                    if (label.IsNotNull())
+                        label.Text = labelText;
+                }
+            }
+
+            protected new FormDropdownSearchBar SearchBar { get; set; } = null!;
+
+            private FormFieldCaption caption = null!;
+            private OsuSpriteText label = null!;
+            private SpriteIcon chevron = null!;
+
+            [Resolved]
+            private OverlayColourProvider colourProvider { get; set; } = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                RelativeSizeAxes = Axes.X;
+                AutoSizeAxes = Axes.None;
+                Height = 50;
+
+                Masking = true;
+                CornerRadius = 5;
+
+                Foreground.AutoSizeAxes = Axes.None;
+                Foreground.RelativeSizeAxes = Axes.Both;
+                Foreground.Padding = new MarginPadding(9);
+                Foreground.Children = new Drawable[]
+                {
+                    caption = new FormFieldCaption
+                    {
+                        Anchor = Anchor.TopLeft,
+                        Origin = Anchor.TopLeft,
+                        Caption = Caption,
+                        TooltipText = HintText,
+                    },
+                    label = new OsuSpriteText
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft,
+                    },
+                    chevron = new SpriteIcon
+                    {
+                        Icon = FontAwesome.Solid.ChevronDown,
+                        Anchor = Anchor.CentreRight,
+                        Origin = Anchor.CentreRight,
+                        Size = new Vector2(16),
+                    },
+                };
+
+                AddInternal(new HoverClickSounds());
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                Dropdown.Current.BindDisabledChanged(_ => updateState());
+                SearchBar.SearchTerm.BindValueChanged(_ => updateState(), true);
+                Dropdown.Menu.StateChanged += _ =>
+                {
+                    updateState();
+                    updateChevron();
+                };
+                SearchBar.TextBox.OnCommit += (_, _) =>
+                {
+                    Background.FlashColour(ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark2), 800, Easing.OutQuint);
+                };
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                updateState();
+                return true;
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                base.OnHoverLost(e);
+                updateState();
+            }
+
+            private void updateState()
+            {
+                label.Alpha = string.IsNullOrEmpty(SearchBar.SearchTerm.Value) ? 1 : 0;
+
+                caption.Colour = Dropdown.Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content2;
+                label.Colour = Dropdown.Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content1;
+                chevron.Colour = Dropdown.Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content1;
+                DisabledColour = Colour4.White;
+
+                bool dropdownOpen = Dropdown.Menu.State == MenuState.Open;
+
+                if (!Dropdown.Current.Disabled)
+                {
+                    BorderThickness = IsHovered || dropdownOpen ? 2 : 0;
+                    BorderColour = dropdownOpen ? colourProvider.Highlight1 : colourProvider.Light4;
+
+                    if (dropdownOpen)
+                        Background.Colour = ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark3);
+                    else if (IsHovered)
+                        Background.Colour = ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark4);
+                    else
+                        Background.Colour = colourProvider.Background5;
+                }
+                else
+                {
+                    Background.Colour = colourProvider.Background4;
+                }
+            }
+
+            private void updateChevron()
+            {
+                bool open = Dropdown.Menu.State == MenuState.Open;
+                chevron.ScaleTo(open ? new Vector2(1f, -1f) : Vector2.One, 300, Easing.OutQuint);
+            }
+        }
+
+        private partial class FormDropdownSearchBar : DropdownSearchBar
+        {
+            public FormTextBox.InnerTextBox TextBox { get; private set; } = null!;
+
+            protected override void PopIn() => this.FadeIn();
+            protected override void PopOut() => this.FadeOut();
+
+            protected override TextBox CreateTextBox() => TextBox = new FormTextBox.InnerTextBox();
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                TextBox.Anchor = Anchor.BottomLeft;
+                TextBox.Origin = Anchor.BottomLeft;
+                TextBox.RelativeSizeAxes = Axes.X;
+                TextBox.Margin = new MarginPadding(9);
+            }
+        }
+
+        private partial class FormDropdownMenu : OsuDropdownMenu
+        {
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider)
+            {
+                ItemsContainer.Padding = new MarginPadding(9);
+                Margin = new MarginPadding { Top = 5 };
+
+                MaskingContainer.BorderThickness = 2;
+                MaskingContainer.BorderColour = colourProvider.Highlight1;
+            }
+        }
+    }
+
+    public partial class FormEnumDropdown<T> : FormDropdown<T>
+        where T : struct, Enum
+    {
+        public FormEnumDropdown()
+        {
+            Items = Enum.GetValues<T>();
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormFieldCaption.cs b/osu.Game/Graphics/UserInterfaceV2/FormFieldCaption.cs
new file mode 100644
index 000000000000..75c27618e9e4
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FormFieldCaption.cs
@@ -0,0 +1,68 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public partial class FormFieldCaption : CompositeDrawable, IHasTooltip
+    {
+        private LocalisableString caption;
+
+        public LocalisableString Caption
+        {
+            get => caption;
+            set
+            {
+                caption = value;
+
+                if (captionText.IsNotNull())
+                    captionText.Text = value;
+            }
+        }
+
+        private OsuSpriteText captionText = null!;
+
+        public LocalisableString TooltipText { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AutoSizeAxes = Axes.Both;
+
+            InternalChild = new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Both,
+                Direction = FillDirection.Horizontal,
+                Spacing = new Vector2(5),
+                Children = new Drawable[]
+                {
+                    captionText = new OsuSpriteText
+                    {
+                        Text = caption,
+                        Font = OsuFont.Default.With(size: 12, weight: FontWeight.SemiBold),
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                    },
+                    new SpriteIcon
+                    {
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                        Alpha = TooltipText == default ? 0 : 1,
+                        Size = new Vector2(10),
+                        Icon = FontAwesome.Solid.QuestionCircle,
+                        Margin = new MarginPadding { Top = 1, },
+                    }
+                },
+            };
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormFileSelector.cs b/osu.Game/Graphics/UserInterfaceV2/FormFileSelector.cs
new file mode 100644
index 000000000000..42bf9c7b9fb5
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FormFileSelector.cs
@@ -0,0 +1,280 @@
+// 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.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Framework.Platform;
+using osu.Game.Database;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public partial class FormFileSelector : CompositeDrawable, IHasCurrentValue<FileInfo?>, ICanAcceptFiles, IHasPopover
+    {
+        public Bindable<FileInfo?> Current
+        {
+            get => current.Current;
+            set => current.Current = value;
+        }
+
+        private readonly BindableWithCurrent<FileInfo?> current = new BindableWithCurrent<FileInfo?>();
+
+        public IEnumerable<string> HandledExtensions => handledExtensions;
+
+        private readonly string[] handledExtensions;
+
+        /// <summary>
+        /// The initial path to use when displaying the <see cref="FileChooserPopover"/>.
+        /// </summary>
+        /// <remarks>
+        /// Uses a <see langword="null"/> value before the first selection is made
+        /// to ensure that the first selection starts at <see cref="GameHost.InitialFileSelectorPath"/>.
+        /// </remarks>
+        private string? initialChooserPath;
+
+        private readonly Bindable<Visibility> popoverState = new Bindable<Visibility>();
+
+        /// <summary>
+        /// Caption describing this file selector, displayed on top of the controls.
+        /// </summary>
+        public LocalisableString Caption { get; init; }
+
+        /// <summary>
+        /// Hint text containing an extended description of this file selector, displayed in a tooltip when hovering the caption.
+        /// </summary>
+        public LocalisableString HintText { get; init; }
+
+        /// <summary>
+        /// Text displayed in the selector when no file is selected.
+        /// </summary>
+        public LocalisableString PlaceholderText { get; init; }
+
+        private Box background = null!;
+
+        private FormFieldCaption caption = null!;
+        private OsuSpriteText placeholderText = null!;
+        private OsuSpriteText filenameText = null!;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        [Resolved]
+        private OsuGameBase game { get; set; } = null!;
+
+        public FormFileSelector(params string[] handledExtensions)
+        {
+            this.handledExtensions = handledExtensions;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = 50;
+
+            Masking = true;
+            CornerRadius = 5;
+
+            InternalChildren = new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background5,
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding(9),
+                    Children = new Drawable[]
+                    {
+                        caption = new FormFieldCaption
+                        {
+                            Anchor = Anchor.TopLeft,
+                            Origin = Anchor.TopLeft,
+                            Caption = Caption,
+                            TooltipText = HintText,
+                        },
+                        placeholderText = new OsuSpriteText
+                        {
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            RelativeSizeAxes = Axes.X,
+                            Width = 1,
+                            Text = PlaceholderText,
+                            Colour = colourProvider.Foreground1,
+                        },
+                        filenameText = new OsuSpriteText
+                        {
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            RelativeSizeAxes = Axes.X,
+                            Width = 1,
+                        },
+                        new SpriteIcon
+                        {
+                            Anchor = Anchor.BottomRight,
+                            Origin = Anchor.BottomRight,
+                            Icon = FontAwesome.Solid.FolderOpen,
+                            Size = new Vector2(16),
+                            Colour = colourProvider.Light1,
+                        }
+                    },
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            popoverState.BindValueChanged(_ => updateState());
+            current.BindValueChanged(_ =>
+            {
+                updateState();
+                onFileSelected();
+            });
+            current.BindDisabledChanged(_ => updateState(), true);
+            game.RegisterImportHandler(this);
+        }
+
+        private void onFileSelected()
+        {
+            if (Current.Value != null)
+                this.HidePopover();
+
+            initialChooserPath = Current.Value?.DirectoryName;
+            placeholderText.Alpha = Current.Value == null ? 1 : 0;
+            filenameText.Text = Current.Value?.Name ?? string.Empty;
+            background.FlashColour(ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark2), 800, Easing.OutQuint);
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            this.ShowPopover();
+            return true;
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateState();
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            updateState();
+        }
+
+        private void updateState()
+        {
+            caption.Colour = Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content2;
+            filenameText.Colour = Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content1;
+
+            if (!Current.Disabled)
+            {
+                BorderThickness = IsHovered || popoverState.Value == Visibility.Visible ? 2 : 0;
+                BorderColour = popoverState.Value == Visibility.Visible ? colourProvider.Highlight1 : colourProvider.Light4;
+
+                if (popoverState.Value == Visibility.Visible)
+                    background.Colour = ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark3);
+                else if (IsHovered)
+                    background.Colour = ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark4);
+                else
+                    background.Colour = colourProvider.Background5;
+            }
+            else
+            {
+                background.Colour = colourProvider.Background4;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (game.IsNotNull())
+                game.UnregisterImportHandler(this);
+        }
+
+        Task ICanAcceptFiles.Import(params string[] paths)
+        {
+            Schedule(() => Current.Value = new FileInfo(paths.First()));
+            return Task.CompletedTask;
+        }
+
+        Task ICanAcceptFiles.Import(ImportTask[] tasks, ImportParameters parameters) => throw new NotImplementedException();
+
+        public Popover GetPopover()
+        {
+            var popover = new FileChooserPopover(handledExtensions, Current, initialChooserPath);
+            popoverState.UnbindBindings();
+            popoverState.BindTo(popover.State);
+            return popover;
+        }
+
+        private partial class FileChooserPopover : OsuPopover
+        {
+            protected override string PopInSampleName => "UI/overlay-big-pop-in";
+            protected override string PopOutSampleName => "UI/overlay-big-pop-out";
+
+            public FileChooserPopover(string[] handledExtensions, Bindable<FileInfo?> currentFile, string? chooserPath)
+                : base(false)
+            {
+                Child = new Container
+                {
+                    Size = new Vector2(600, 400),
+                    // simplest solution to avoid underlying text to bleed through the bottom border
+                    // https://github.com/ppy/osu/pull/30005#issuecomment-2378884430
+                    Padding = new MarginPadding { Bottom = 1 },
+                    Child = new OsuFileSelector(chooserPath, handledExtensions)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        CurrentFile = { BindTarget = currentFile }
+                    },
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider)
+            {
+                Add(new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    BorderThickness = 2,
+                    CornerRadius = 10,
+                    BorderColour = colourProvider.Highlight1,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = Color4.Transparent,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                    }
+                });
+            }
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormNumberBox.cs b/osu.Game/Graphics/UserInterfaceV2/FormNumberBox.cs
new file mode 100644
index 000000000000..66f1a45210d0
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FormNumberBox.cs
@@ -0,0 +1,23 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public partial class FormNumberBox : FormTextBox
+    {
+        public bool AllowDecimals { get; init; }
+
+        internal override InnerTextBox CreateTextBox() => new InnerNumberBox
+        {
+            AllowDecimals = AllowDecimals,
+        };
+
+        internal partial class InnerNumberBox : InnerTextBox
+        {
+            public bool AllowDecimals { get; init; }
+
+            protected override bool CanAddCharacter(char character)
+                => char.IsAsciiDigit(character) || (AllowDecimals && character == '.');
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormSliderBar.cs b/osu.Game/Graphics/UserInterfaceV2/FormSliderBar.cs
new file mode 100644
index 000000000000..ac3730598fb0
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FormSliderBar.cs
@@ -0,0 +1,374 @@
+// 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.Globalization;
+using System.Numerics;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public partial class FormSliderBar<T> : CompositeDrawable, IHasCurrentValue<T>
+        where T : struct, INumber<T>, IMinMaxValue<T>
+    {
+        public Bindable<T> Current
+        {
+            get => current.Current;
+            set => current.Current = value;
+        }
+
+        private bool instantaneous = true;
+
+        /// <summary>
+        /// Whether changes to the slider should instantaneously transfer to the text box (and vice versa).
+        /// If <see langword="false"/>, the transfer will happen on text box commit (explicit, or implicit via focus loss), or on slider drag end.
+        /// </summary>
+        public bool Instantaneous
+        {
+            get => instantaneous;
+            set
+            {
+                instantaneous = value;
+
+                if (slider.IsNotNull())
+                    slider.TransferValueOnCommit = !instantaneous;
+            }
+        }
+
+        private CompositeDrawable? tabbableContentContainer;
+
+        public CompositeDrawable? TabbableContentContainer
+        {
+            set
+            {
+                tabbableContentContainer = value;
+
+                if (textBox.IsNotNull())
+                    textBox.TabbableContentContainer = tabbableContentContainer;
+            }
+        }
+
+        private readonly BindableNumberWithCurrent<T> current = new BindableNumberWithCurrent<T>();
+
+        /// <summary>
+        /// Caption describing this slider bar, displayed on top of the controls.
+        /// </summary>
+        public LocalisableString Caption { get; init; }
+
+        /// <summary>
+        /// Hint text containing an extended description of this slider bar, displayed in a tooltip when hovering the caption.
+        /// </summary>
+        public LocalisableString HintText { get; init; }
+
+        private Box background = null!;
+        private Box flashLayer = null!;
+        private FormTextBox.InnerTextBox textBox = null!;
+        private Slider slider = null!;
+        private FormFieldCaption caption = null!;
+        private IFocusManager focusManager = null!;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = 50;
+
+            Masking = true;
+            CornerRadius = 5;
+
+            InternalChildren = new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background5,
+                },
+                flashLayer = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Colour4.Transparent,
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding(9),
+                    Children = new Drawable[]
+                    {
+                        caption = new FormFieldCaption
+                        {
+                            Anchor = Anchor.TopLeft,
+                            Origin = Anchor.TopLeft,
+                            Caption = Caption,
+                            TooltipText = HintText,
+                        },
+                        textBox = new FormNumberBox.InnerNumberBox
+                        {
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            RelativeSizeAxes = Axes.X,
+                            Width = 0.5f,
+                            CommitOnFocusLost = true,
+                            SelectAllOnFocus = true,
+                            AllowDecimals = true,
+                            OnInputError = () =>
+                            {
+                                flashLayer.Colour = ColourInfo.GradientVertical(colours.Red3.Opacity(0), colours.Red3);
+                                flashLayer.FadeOutFromOne(200, Easing.OutQuint);
+                            },
+                            TabbableContentContainer = tabbableContentContainer,
+                        },
+                        slider = new Slider
+                        {
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreRight,
+                            RelativeSizeAxes = Axes.X,
+                            Width = 0.5f,
+                            Current = Current,
+                            TransferValueOnCommit = !instantaneous,
+                        }
+                    },
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            focusManager = GetContainingFocusManager()!;
+
+            textBox.Focused.BindValueChanged(_ => updateState());
+            textBox.OnCommit += textCommitted;
+            textBox.Current.BindValueChanged(textChanged);
+
+            slider.IsDragging.BindValueChanged(_ => updateState());
+
+            current.BindValueChanged(_ =>
+            {
+                updateState();
+                updateTextBoxFromSlider();
+            }, true);
+        }
+
+        private bool updatingFromTextBox;
+
+        private void textChanged(ValueChangedEvent<string> change)
+        {
+            if (!instantaneous) return;
+
+            tryUpdateSliderFromTextBox();
+        }
+
+        private void textCommitted(TextBox t, bool isNew)
+        {
+            tryUpdateSliderFromTextBox();
+
+            // If the attempted update above failed, restore text box to match the slider.
+            Current.TriggerChange();
+
+            flashLayer.Colour = ColourInfo.GradientVertical(colourProvider.Dark2.Opacity(0), colourProvider.Dark2);
+            flashLayer.FadeOutFromOne(800, Easing.OutQuint);
+        }
+
+        private void tryUpdateSliderFromTextBox()
+        {
+            updatingFromTextBox = true;
+
+            try
+            {
+                switch (Current)
+                {
+                    case Bindable<int> bindableInt:
+                        bindableInt.Value = int.Parse(textBox.Current.Value);
+                        break;
+
+                    case Bindable<double> bindableDouble:
+                        bindableDouble.Value = double.Parse(textBox.Current.Value);
+                        break;
+
+                    default:
+                        Current.Parse(textBox.Current.Value, CultureInfo.CurrentCulture);
+                        break;
+                }
+            }
+            catch
+            {
+                // ignore parsing failures.
+                // sane state will eventually be restored by a commit (either explicit, or implicit via focus loss).
+            }
+
+            updatingFromTextBox = false;
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateState();
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            updateState();
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            focusManager.ChangeFocus(textBox);
+            return true;
+        }
+
+        private void updateState()
+        {
+            textBox.Alpha = 1;
+
+            background.Colour = Current.Disabled ? colourProvider.Background4 : colourProvider.Background5;
+            caption.Colour = Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content2;
+            textBox.Colour = Current.Disabled ? colourProvider.Foreground1 : colourProvider.Content1;
+
+            BorderThickness = IsHovered || textBox.Focused.Value || slider.IsDragging.Value ? 2 : 0;
+            BorderColour = textBox.Focused.Value ? colourProvider.Highlight1 : colourProvider.Light4;
+
+            if (textBox.Focused.Value)
+                background.Colour = ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark3);
+            else if (IsHovered || slider.IsDragging.Value)
+                background.Colour = ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark4);
+            else
+                background.Colour = colourProvider.Background5;
+        }
+
+        private void updateTextBoxFromSlider()
+        {
+            if (updatingFromTextBox) return;
+
+            textBox.Text = slider.GetDisplayableValue(Current.Value).ToString();
+        }
+
+        private partial class Slider : OsuSliderBar<T>
+        {
+            public BindableBool IsDragging { get; set; } = new BindableBool();
+
+            private Box leftBox = null!;
+            private Box rightBox = null!;
+            private Circle nub = null!;
+            private const float nub_width = 10;
+
+            [Resolved]
+            private OverlayColourProvider colourProvider { get; set; } = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Height = 40;
+                RelativeSizeAxes = Axes.X;
+                RangePadding = nub_width / 2;
+                Children = new Drawable[]
+                {
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        CornerRadius = 5,
+                        Children = new Drawable[]
+                        {
+                            leftBox = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                            },
+                            rightBox = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Anchor = Anchor.CentreRight,
+                                Origin = Anchor.CentreRight,
+                            },
+                        },
+                    },
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding { Horizontal = RangePadding, },
+                        Child = nub = new Circle
+                        {
+                            Width = nub_width,
+                            RelativeSizeAxes = Axes.Y,
+                            RelativePositionAxes = Axes.X,
+                            Origin = Anchor.TopCentre,
+                        }
+                    },
+                    new HoverClickSounds()
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                updateState();
+            }
+
+            protected override void UpdateAfterChildren()
+            {
+                base.UpdateAfterChildren();
+                leftBox.Width = Math.Clamp(RangePadding + nub.DrawPosition.X, 0, Math.Max(0, DrawWidth)) / DrawWidth;
+                rightBox.Width = Math.Clamp(DrawWidth - nub.DrawPosition.X - RangePadding, 0, Math.Max(0, DrawWidth)) / DrawWidth;
+            }
+
+            protected override bool OnDragStart(DragStartEvent e)
+            {
+                bool dragging = base.OnDragStart(e);
+                IsDragging.Value = dragging;
+                updateState();
+                return dragging;
+            }
+
+            protected override void OnDragEnd(DragEndEvent e)
+            {
+                base.OnDragEnd(e);
+                IsDragging.Value = false;
+                updateState();
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                updateState();
+                return base.OnHover(e);
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                updateState();
+                base.OnHoverLost(e);
+            }
+
+            private void updateState()
+            {
+                rightBox.Colour = colourProvider.Background6;
+                leftBox.Colour = IsHovered || IsDragged ? colourProvider.Highlight1.Opacity(0.5f) : colourProvider.Dark2;
+                nub.Colour = IsHovered || IsDragged ? colourProvider.Highlight1 : colourProvider.Light4;
+            }
+
+            protected override void UpdateValue(float value)
+            {
+                nub.MoveToX(value, 200, Easing.OutPow10);
+            }
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormTextBox.cs b/osu.Game/Graphics/UserInterfaceV2/FormTextBox.cs
new file mode 100644
index 000000000000..9bbb5cba99e3
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FormTextBox.cs
@@ -0,0 +1,250 @@
+// 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.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+
+namespace osu.Game.Graphics.UserInterfaceV2
+{
+    public partial class FormTextBox : CompositeDrawable, IHasCurrentValue<string>
+    {
+        public Bindable<string> Current
+        {
+            get => current.Current;
+            set => current.Current = value;
+        }
+
+        private bool readOnly;
+
+        public bool ReadOnly
+        {
+            get => readOnly;
+            set
+            {
+                readOnly = value;
+
+                if (textBox.IsNotNull())
+                    updateState();
+            }
+        }
+
+        private CompositeDrawable? tabbableContentContainer;
+
+        public CompositeDrawable? TabbableContentContainer
+        {
+            set
+            {
+                tabbableContentContainer = value;
+
+                if (textBox.IsNotNull())
+                    textBox.TabbableContentContainer = tabbableContentContainer;
+            }
+        }
+
+        public event TextBox.OnCommitHandler? OnCommit;
+
+        private readonly BindableWithCurrent<string> current = new BindableWithCurrent<string>();
+
+        /// <summary>
+        /// Caption describing this slider bar, displayed on top of the controls.
+        /// </summary>
+        public LocalisableString Caption { get; init; }
+
+        /// <summary>
+        /// Hint text containing an extended description of this slider bar, displayed in a tooltip when hovering the caption.
+        /// </summary>
+        public LocalisableString HintText { get; init; }
+
+        /// <summary>
+        /// Text displayed in the text box when its contents are empty.
+        /// </summary>
+        public LocalisableString PlaceholderText { get; init; }
+
+        private Box background = null!;
+        private Box flashLayer = null!;
+        private InnerTextBox textBox = null!;
+        private FormFieldCaption caption = null!;
+        private IFocusManager focusManager = null!;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = 50;
+
+            Masking = true;
+            CornerRadius = 5;
+            CornerExponent = 2.5f;
+
+            InternalChildren = new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background5,
+                },
+                flashLayer = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Colour4.Transparent,
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding(9),
+                    Children = new Drawable[]
+                    {
+                        caption = new FormFieldCaption
+                        {
+                            Anchor = Anchor.TopLeft,
+                            Origin = Anchor.TopLeft,
+                            Caption = Caption,
+                            TooltipText = HintText,
+                        },
+                        textBox = CreateTextBox().With(t =>
+                        {
+                            t.Anchor = Anchor.BottomRight;
+                            t.Origin = Anchor.BottomRight;
+                            t.RelativeSizeAxes = Axes.X;
+                            t.Width = 1;
+                            t.PlaceholderText = PlaceholderText;
+                            t.Current = Current;
+                            t.CommitOnFocusLost = true;
+                            t.OnCommit += (textBox, newText) =>
+                            {
+                                OnCommit?.Invoke(textBox, newText);
+
+                                if (!current.Disabled && !ReadOnly)
+                                {
+                                    flashLayer.Colour = ColourInfo.GradientVertical(colourProvider.Dark2.Opacity(0), colourProvider.Dark2);
+                                    flashLayer.FadeOutFromOne(800, Easing.OutQuint);
+                                }
+                            };
+                            t.OnInputError = () =>
+                            {
+                                flashLayer.Colour = ColourInfo.GradientVertical(colours.Red3.Opacity(0), colours.Red3);
+                                flashLayer.FadeOutFromOne(200, Easing.OutQuint);
+                            };
+                            t.TabbableContentContainer = tabbableContentContainer;
+                        }),
+                    },
+                },
+            };
+        }
+
+        internal virtual InnerTextBox CreateTextBox() => new InnerTextBox();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            focusManager = GetContainingFocusManager()!;
+            textBox.Focused.BindValueChanged(_ => updateState());
+            current.BindDisabledChanged(_ => updateState(), true);
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateState();
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+            updateState();
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            focusManager.ChangeFocus(textBox);
+            return true;
+        }
+
+        private void updateState()
+        {
+            bool disabled = Current.Disabled || ReadOnly;
+
+            textBox.ReadOnly = disabled;
+            textBox.Alpha = 1;
+
+            caption.Colour = disabled ? colourProvider.Foreground1 : colourProvider.Content2;
+            textBox.Colour = disabled ? colourProvider.Foreground1 : colourProvider.Content1;
+
+            if (!disabled)
+            {
+                BorderThickness = IsHovered || textBox.Focused.Value ? 2 : 0;
+                BorderColour = textBox.Focused.Value ? colourProvider.Highlight1 : colourProvider.Light4;
+
+                if (textBox.Focused.Value)
+                    background.Colour = ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark3);
+                else if (IsHovered)
+                    background.Colour = ColourInfo.GradientVertical(colourProvider.Background5, colourProvider.Dark4);
+                else
+                    background.Colour = colourProvider.Background5;
+            }
+            else
+            {
+                background.Colour = colourProvider.Background4;
+            }
+        }
+
+        internal partial class InnerTextBox : OsuTextBox
+        {
+            public BindableBool Focused { get; } = new BindableBool();
+
+            public Action? OnInputError { get; set; }
+
+            protected override float LeftRightPadding => 0;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Height = 16;
+                TextContainer.Height = 1;
+                Masking = false;
+                BackgroundUnfocused = BackgroundFocused = BackgroundCommit = Colour4.Transparent;
+            }
+
+            protected override SpriteText CreatePlaceholder() => base.CreatePlaceholder().With(t => t.Margin = default);
+
+            protected override void OnFocus(FocusEvent e)
+            {
+                base.OnFocus(e);
+
+                Focused.Value = true;
+            }
+
+            protected override void OnFocusLost(FocusLostEvent e)
+            {
+                base.OnFocusLost(e);
+
+                Focused.Value = false;
+            }
+
+            protected override void NotifyInputError()
+            {
+                PlayFeedbackSample(FeedbackSampleType.TextInvalid);
+                // base call intentionally suppressed
+                OnInputError?.Invoke();
+            }
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelector.cs b/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelector.cs
index 21f926ba4246..65ffdcaa5bbc 100644
--- a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelector.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelector.cs
@@ -1,41 +1,73 @@
 // 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.IO;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterfaceV2.FileSelection;
+using osu.Game.Overlays;
 
 namespace osu.Game.Graphics.UserInterfaceV2
 {
     public partial class OsuDirectorySelector : DirectorySelector
     {
-        public const float ITEM_HEIGHT = 20;
+        public const float ITEM_HEIGHT = 16;
+
+        private Box hiddenToggleBackground = null!;
 
-        public OsuDirectorySelector(string initialPath = null)
+        public OsuDirectorySelector(string? initialPath = null)
             : base(initialPath)
         {
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OverlayColourProvider colourProvider)
         {
-            Padding = new MarginPadding(10);
+            AddInternal(new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Colour = colourProvider.Background5,
+                Depth = float.MaxValue,
+            });
+
+            hiddenToggleBackground.Colour = colourProvider.Background4;
         }
 
-        protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer();
+        protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer
+        {
+            Padding = new MarginPadding
+            {
+                Horizontal = 20,
+                Vertical = 15,
+            }
+        };
 
         protected override DirectorySelectorBreadcrumbDisplay CreateBreadcrumb() => new OsuDirectorySelectorBreadcrumbDisplay();
 
-        protected override Drawable CreateHiddenToggleButton() => new OsuDirectorySelectorHiddenToggle { Current = { BindTarget = ShowHiddenItems } };
+        protected override Drawable CreateHiddenToggleButton() => new Container
+        {
+            RelativeSizeAxes = Axes.Y,
+            AutoSizeAxes = Axes.X,
+            Children = new Drawable[]
+            {
+                hiddenToggleBackground = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new HiddenFilesToggleCheckbox
+                {
+                    Current = { BindTarget = ShowHiddenItems },
+                },
+            }
+        };
 
         protected override DirectorySelectorDirectory CreateParentDirectoryItem(DirectoryInfo directory) => new OsuDirectorySelectorParentDirectory(directory);
 
-        protected override DirectorySelectorDirectory CreateDirectoryItem(DirectoryInfo directory, string displayName = null) => new OsuDirectorySelectorDirectory(directory, displayName);
+        protected override DirectorySelectorDirectory CreateDirectoryItem(DirectoryInfo directory, string? displayName = null) => new OsuDirectorySelectorDirectory(directory, displayName);
 
         protected override void NotifySelectionError() => this.FlashColour(Colour4.Red, 300);
     }
diff --git a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorBreadcrumbDisplay.cs b/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorBreadcrumbDisplay.cs
deleted file mode 100644
index 0917b9db97f0..000000000000
--- a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorBreadcrumbDisplay.cs
+++ /dev/null
@@ -1,65 +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.
-
-#nullable disable
-
-using System.IO;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.UserInterface;
-using osu.Game.Graphics.Sprites;
-using osuTK;
-
-namespace osu.Game.Graphics.UserInterfaceV2
-{
-    internal partial class OsuDirectorySelectorBreadcrumbDisplay : DirectorySelectorBreadcrumbDisplay
-    {
-        protected override Drawable CreateCaption() => new OsuSpriteText
-        {
-            Text = "Current Directory: ",
-            Font = OsuFont.Default.With(size: OsuDirectorySelector.ITEM_HEIGHT),
-        };
-
-        protected override DirectorySelectorDirectory CreateRootDirectoryItem() => new OsuBreadcrumbDisplayComputer();
-
-        protected override DirectorySelectorDirectory CreateDirectoryItem(DirectoryInfo directory, string displayName = null) => new OsuBreadcrumbDisplayDirectory(directory, displayName);
-
-        public OsuDirectorySelectorBreadcrumbDisplay()
-        {
-            Padding = new MarginPadding(15);
-        }
-
-        private partial class OsuBreadcrumbDisplayComputer : OsuBreadcrumbDisplayDirectory
-        {
-            protected override IconUsage? Icon => null;
-
-            public OsuBreadcrumbDisplayComputer()
-                : base(null, "Computer")
-            {
-            }
-        }
-
-        private partial class OsuBreadcrumbDisplayDirectory : OsuDirectorySelectorDirectory
-        {
-            public OsuBreadcrumbDisplayDirectory(DirectoryInfo directory, string displayName = null)
-                : base(directory, displayName)
-            {
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                Flow.Add(new SpriteIcon
-                {
-                    Anchor = Anchor.CentreLeft,
-                    Origin = Anchor.CentreLeft,
-                    Icon = FontAwesome.Solid.ChevronRight,
-                    Size = new Vector2(FONT_SIZE / 2)
-                });
-            }
-
-            protected override IconUsage? Icon => Directory.Name.Contains(Path.DirectorySeparatorChar) ? base.Icon : null;
-        }
-    }
-}
diff --git a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorDirectory.cs b/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorDirectory.cs
deleted file mode 100644
index 932017b03eb9..000000000000
--- a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorDirectory.cs
+++ /dev/null
@@ -1,66 +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.
-
-#nullable disable
-
-using System.IO;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.UserInterface;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Overlays;
-
-namespace osu.Game.Graphics.UserInterfaceV2
-{
-    internal partial class OsuDirectorySelectorDirectory : DirectorySelectorDirectory
-    {
-        public OsuDirectorySelectorDirectory(DirectoryInfo directory, string displayName = null)
-            : base(directory, displayName)
-        {
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Flow.AutoSizeAxes = Axes.X;
-            Flow.Height = OsuDirectorySelector.ITEM_HEIGHT;
-
-            AddRangeInternal(new Drawable[]
-            {
-                new Background
-                {
-                    Depth = 1
-                },
-                new HoverClickSounds()
-            });
-        }
-
-        protected override SpriteText CreateSpriteText() => new OsuSpriteText();
-
-        protected override IconUsage? Icon => Directory.Name.Contains(Path.DirectorySeparatorChar)
-            ? FontAwesome.Solid.Database
-            : FontAwesome.Regular.Folder;
-
-        internal partial class Background : CompositeDrawable
-        {
-            [BackgroundDependencyLoader(true)]
-            private void load(OverlayColourProvider overlayColourProvider, OsuColour colours)
-            {
-                RelativeSizeAxes = Axes.Both;
-
-                Masking = true;
-                CornerRadius = 5;
-
-                InternalChild = new Box
-                {
-                    Colour = overlayColourProvider?.Background5 ?? colours.GreySeaFoamDarker,
-                    RelativeSizeAxes = Axes.Both,
-                };
-            }
-        }
-    }
-}
diff --git a/osu.Game/Graphics/UserInterfaceV2/OsuFileSelector.cs b/osu.Game/Graphics/UserInterfaceV2/OsuFileSelector.cs
index 7097102335ad..c7b559d9ed13 100644
--- a/osu.Game/Graphics/UserInterfaceV2/OsuFileSelector.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/OsuFileSelector.cs
@@ -1,43 +1,74 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.IO;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2.FileSelection;
+using osu.Game.Overlays;
 
 namespace osu.Game.Graphics.UserInterfaceV2
 {
     public partial class OsuFileSelector : FileSelector
     {
-        public OsuFileSelector(string initialPath = null, string[] validFileExtensions = null)
+        private Box hiddenToggleBackground = null!;
+
+        public OsuFileSelector(string? initialPath = null, string[]? validFileExtensions = null)
             : base(initialPath, validFileExtensions)
         {
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OverlayColourProvider colourProvider)
         {
-            Padding = new MarginPadding(10);
+            AddInternal(new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Colour = colourProvider.Background5,
+                Depth = float.MaxValue,
+            });
+
+            hiddenToggleBackground.Colour = colourProvider.Background4;
         }
 
-        protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer();
+        protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer
+        {
+            Padding = new MarginPadding
+            {
+                Horizontal = 20,
+                Vertical = 15,
+            }
+        };
 
         protected override DirectorySelectorBreadcrumbDisplay CreateBreadcrumb() => new OsuDirectorySelectorBreadcrumbDisplay();
 
-        protected override Drawable CreateHiddenToggleButton() => new OsuDirectorySelectorHiddenToggle { Current = { BindTarget = ShowHiddenItems } };
+        protected override Drawable CreateHiddenToggleButton() => new Container
+        {
+            RelativeSizeAxes = Axes.Y,
+            AutoSizeAxes = Axes.X,
+            Children = new Drawable[]
+            {
+                hiddenToggleBackground = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new HiddenFilesToggleCheckbox
+                {
+                    Current = { BindTarget = ShowHiddenItems },
+                },
+            }
+        };
 
         protected override DirectorySelectorDirectory CreateParentDirectoryItem(DirectoryInfo directory) => new OsuDirectorySelectorParentDirectory(directory);
 
-        protected override DirectorySelectorDirectory CreateDirectoryItem(DirectoryInfo directory, string displayName = null) => new OsuDirectorySelectorDirectory(directory, displayName);
+        protected override DirectorySelectorDirectory CreateDirectoryItem(DirectoryInfo directory, string? displayName = null) => new OsuDirectorySelectorDirectory(directory, displayName);
 
         protected override DirectoryListingFile CreateFileItem(FileInfo file) => new OsuDirectoryListingFile(file);
 
@@ -51,19 +82,14 @@ public OsuDirectoryListingFile(FileInfo file)
             }
 
             [BackgroundDependencyLoader]
-            private void load()
+            private void load(OverlayColourProvider colourProvider)
             {
                 Flow.AutoSizeAxes = Axes.X;
                 Flow.Height = OsuDirectorySelector.ITEM_HEIGHT;
 
-                AddRangeInternal(new Drawable[]
-                {
-                    new OsuDirectorySelectorDirectory.Background
-                    {
-                        Depth = 1
-                    },
-                    new HoverClickSounds()
-                });
+                AddInternal(new BackgroundLayer());
+
+                Colour = colourProvider.Light3;
             }
 
             protected override IconUsage? Icon
@@ -91,7 +117,7 @@ protected override IconUsage? Icon
                 }
             }
 
-            protected override SpriteText CreateSpriteText() => new OsuSpriteText();
+            protected override SpriteText CreateSpriteText() => new OsuSpriteText().With(t => t.Font = OsuFont.Default.With(weight: FontWeight.SemiBold));
         }
     }
 }
diff --git a/osu.Game/Input/Bindings/GlobalActionContainer.cs b/osu.Game/Input/Bindings/GlobalActionContainer.cs
index ef0c60cd2060..aca0984e0fd4 100644
--- a/osu.Game/Input/Bindings/GlobalActionContainer.cs
+++ b/osu.Game/Input/Bindings/GlobalActionContainer.cs
@@ -147,6 +147,10 @@ public static IEnumerable<GlobalAction> GetGlobalActionsFor(GlobalActionCategory
             new KeyBinding(new[] { InputKey.Control, InputKey.Shift, InputKey.MouseWheelLeft }, GlobalAction.EditorCycleNextBeatSnapDivisor),
             new KeyBinding(new[] { InputKey.Control, InputKey.R }, GlobalAction.EditorToggleRotateControl),
             new KeyBinding(new[] { InputKey.Control, InputKey.E }, GlobalAction.EditorToggleScaleControl),
+            new KeyBinding(new[] { InputKey.Control, InputKey.Left }, GlobalAction.EditorSeekToPreviousHitObject),
+            new KeyBinding(new[] { InputKey.Control, InputKey.Right }, GlobalAction.EditorSeekToNextHitObject),
+            new KeyBinding(new[] { InputKey.Control, InputKey.Shift, InputKey.Left }, GlobalAction.EditorSeekToPreviousSamplePoint),
+            new KeyBinding(new[] { InputKey.Control, InputKey.Shift, InputKey.Right }, GlobalAction.EditorSeekToNextSamplePoint),
         };
 
         private static IEnumerable<KeyBinding> editorTestPlayKeyBindings => new[]
@@ -456,6 +460,18 @@ public enum GlobalAction
 
         [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorTestPlayQuickExitToCurrentTime))]
         EditorTestPlayQuickExitToCurrentTime,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorSeekToPreviousHitObject))]
+        EditorSeekToPreviousHitObject,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorSeekToNextHitObject))]
+        EditorSeekToNextHitObject,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorSeekToPreviousSamplePoint))]
+        EditorSeekToPreviousSamplePoint,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorSeekToNextSamplePoint))]
+        EditorSeekToNextSamplePoint,
     }
 
     public enum GlobalActionCategory
diff --git a/osu.Game/Localisation/GameplaySettingsStrings.cs b/osu.Game/Localisation/GameplaySettingsStrings.cs
index 8ee76fdd5519..6de61f7ebeae 100644
--- a/osu.Game/Localisation/GameplaySettingsStrings.cs
+++ b/osu.Game/Localisation/GameplaySettingsStrings.cs
@@ -84,6 +84,11 @@ public static class GameplaySettingsStrings
         /// </summary>
         public static LocalisableString AlwaysShowGameplayLeaderboard => new TranslatableString(getKey(@"gameplay_leaderboard"), @"Always show gameplay leaderboard");
 
+        /// <summary>
+        /// "Always show hold for menu button"
+        /// </summary>
+        public static LocalisableString AlwaysShowHoldForMenuButton => new TranslatableString(getKey(@"always_show_hold_for_menu_button"), @"Always show hold for menu button");
+
         /// <summary>
         /// "Always play first combo break sound"
         /// </summary>
diff --git a/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs b/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
index 450585f79abf..206db1a16674 100644
--- a/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
+++ b/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
@@ -404,6 +404,26 @@ public static class GlobalActionKeyBindingStrings
         /// </summary>
         public static LocalisableString DecreaseModSpeed => new TranslatableString(getKey(@"decrease_mod_speed"), @"Decrease mod speed");
 
+        /// <summary>
+        /// "Seek to previous hit object"
+        /// </summary>
+        public static LocalisableString EditorSeekToPreviousHitObject => new TranslatableString(getKey(@"editor_seek_to_previous_hit_object"), @"Seek to previous hit object");
+
+        /// <summary>
+        /// "Seek to next hit object"
+        /// </summary>
+        public static LocalisableString EditorSeekToNextHitObject => new TranslatableString(getKey(@"editor_seek_to_next_hit_object"), @"Seek to next hit object");
+
+        /// <summary>
+        /// "Seek to previous sample point"
+        /// </summary>
+        public static LocalisableString EditorSeekToPreviousSamplePoint => new TranslatableString(getKey(@"editor_seek_to_previous_sample_point"), @"Seek to previous sample point");
+
+        /// <summary>
+        /// "Seek to next sample point"
+        /// </summary>
+        public static LocalisableString EditorSeekToNextSamplePoint => new TranslatableString(getKey(@"editor_seek_to_next_sample_point"), @"Seek to next sample point");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/MaintenanceSettingsStrings.cs b/osu.Game/Localisation/MaintenanceSettingsStrings.cs
index 2e5f1d29df68..03e15e839356 100644
--- a/osu.Game/Localisation/MaintenanceSettingsStrings.cs
+++ b/osu.Game/Localisation/MaintenanceSettingsStrings.cs
@@ -34,11 +34,6 @@ public static class MaintenanceSettingsStrings
         /// </summary>
         public static LocalisableString ProhibitedInteractDuringMigration => new TranslatableString(getKey(@"prohibited_interact_during_migration"), @"Please avoid interacting with the game!");
 
-        /// <summary>
-        /// "Some files couldn't be cleaned up during migration. Clicking this notification will open the folder so you can manually clean things up."
-        /// </summary>
-        public static LocalisableString FailedCleanupNotification => new TranslatableString(getKey(@"failed_cleanup_notification"), @"Some files couldn't be cleaned up during migration. Clicking this notification will open the folder so you can manually clean things up.");
-
         /// <summary>
         /// "Please select a new location"
         /// </summary>
diff --git a/osu.Game/Localisation/NotificationsStrings.cs b/osu.Game/Localisation/NotificationsStrings.cs
index 698fe230b294..d8f768f2d85e 100644
--- a/osu.Game/Localisation/NotificationsStrings.cs
+++ b/osu.Game/Localisation/NotificationsStrings.cs
@@ -135,11 +135,6 @@ public static class NotificationsStrings
         /// </summary>
         public static LocalisableString DownloadingUpdate => new TranslatableString(getKey(@"downloading_update"), @"Downloading update...");
 
-        /// <summary>
-        /// "Installing update..."
-        /// </summary>
-        public static LocalisableString InstallingUpdate => new TranslatableString(getKey(@"installing_update"), @"Installing update...");
-
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs b/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs
index d5c8d5ccece5..33fda23cb07b 100644
--- a/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs
+++ b/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs
@@ -59,6 +59,26 @@ public static class SkinnableComponentStrings
         /// </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."
+        /// </summary>
+        public static LocalisableString TextColourDescription => new TranslatableString(getKey(@"text_colour_description"), @"The colour of the text.");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/ToastStrings.cs b/osu.Game/Localisation/ToastStrings.cs
index 942540cfc524..49e8d00371f4 100644
--- a/osu.Game/Localisation/ToastStrings.cs
+++ b/osu.Game/Localisation/ToastStrings.cs
@@ -45,9 +45,9 @@ public static class ToastStrings
         public static LocalisableString SkinSaved => new TranslatableString(getKey(@"skin_saved"), @"Skin saved");
 
         /// <summary>
-        /// "URL copied"
+        /// "Link copied to clipboard"
         /// </summary>
-        public static LocalisableString UrlCopied => new TranslatableString(getKey(@"url_copied"), @"URL copied");
+        public static LocalisableString UrlCopied => new TranslatableString(getKey(@"url_copied"), @"Link copied to clipboard");
 
         /// <summary>
         /// "Speed changed to {0:N2}x"
diff --git a/osu.Game/Online/API/APIAccess.cs b/osu.Game/Online/API/APIAccess.cs
index 716d1e44669d..a9ccbf9b1889 100644
--- a/osu.Game/Online/API/APIAccess.cs
+++ b/osu.Game/Online/API/APIAccess.cs
@@ -159,7 +159,7 @@ private WebSocketNotificationsClientConnector setUpNotificationsClient()
 
         private void onTokenChanged(ValueChangedEvent<OAuthToken> e) => config.SetValue(OsuSetting.Token, config.Get<bool>(OsuSetting.SavePassword) ? authentication.TokenString : string.Empty);
 
-        internal new void Schedule(Action action) => base.Schedule(action);
+        void IAPIProvider.Schedule(Action action) => base.Schedule(action);
 
         public string AccessToken => authentication.RequestAccessToken();
 
@@ -385,7 +385,8 @@ public void Perform(APIRequest request)
         {
             try
             {
-                request.Perform(this);
+                request.AttachAPI(this);
+                request.Perform();
             }
             catch (Exception e)
             {
@@ -483,7 +484,8 @@ private bool handleRequest(APIRequest req)
         {
             try
             {
-                req.Perform(this);
+                req.AttachAPI(this);
+                req.Perform();
 
                 if (req.CompletionState != APIRequestCompletionState.Completed)
                     return false;
@@ -568,6 +570,8 @@ public void Queue(APIRequest request)
         {
             lock (queue)
             {
+                request.AttachAPI(this);
+
                 if (state.Value == APIState.Offline)
                 {
                     request.Fail(new WebException(@"User not logged in"));
diff --git a/osu.Game/Online/API/APIDownloadRequest.cs b/osu.Game/Online/API/APIDownloadRequest.cs
index c48372278abe..f8db52139d7c 100644
--- a/osu.Game/Online/API/APIDownloadRequest.cs
+++ b/osu.Game/Online/API/APIDownloadRequest.cs
@@ -4,6 +4,7 @@
 #nullable disable
 
 using System;
+using System.Diagnostics;
 using System.IO;
 using osu.Framework.IO.Network;
 
@@ -34,7 +35,11 @@ protected override WebRequest CreateWebRequest()
             return request;
         }
 
-        private void request_Progress(long current, long total) => API.Schedule(() => Progressed?.Invoke(current, total));
+        private void request_Progress(long current, long total)
+        {
+            Debug.Assert(API != null);
+            API.Schedule(() => Progressed?.Invoke(current, total));
+        }
 
         protected void TriggerSuccess(string filename)
         {
diff --git a/osu.Game/Online/API/APIRequest.cs b/osu.Game/Online/API/APIRequest.cs
index 6b6b22204397..5cbe9040badf 100644
--- a/osu.Game/Online/API/APIRequest.cs
+++ b/osu.Game/Online/API/APIRequest.cs
@@ -1,11 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
+using System.Diagnostics;
 using System.Globalization;
-using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.IO.Network;
@@ -26,18 +24,17 @@ public abstract class APIRequest<T> : APIRequest where T : class
         /// <summary>
         /// The deserialised response object. May be null if the request or deserialisation failed.
         /// </summary>
-        [CanBeNull]
-        public T Response { get; private set; }
+        public T? Response { get; private set; }
 
         /// <summary>
         /// Invoked on successful completion of an API request.
         /// This will be scheduled to the API's internal scheduler (run on update thread automatically).
         /// </summary>
-        public new event APISuccessHandler<T> Success;
+        public new event APISuccessHandler<T>? Success;
 
         protected APIRequest()
         {
-            base.Success += () => Success?.Invoke(Response);
+            base.Success += () => Success?.Invoke(Response!);
         }
 
         protected override void PostProcess()
@@ -49,6 +46,9 @@ protected override void PostProcess()
                 Response = ((OsuJsonWebRequest<T>)WebRequest).ResponseObject;
                 Logger.Log($"{GetType().ReadableName()} finished with response size of {WebRequest.ResponseStream.Length:#,0} bytes", LoggingTarget.Network);
             }
+
+            if (Response == null)
+                TriggerFailure(new ArgumentNullException(nameof(Response)));
         }
 
         internal void TriggerSuccess(T result)
@@ -71,27 +71,28 @@ public abstract class APIRequest
 
         protected virtual WebRequest CreateWebRequest() => new OsuWebRequest(Uri);
 
-        protected virtual string Uri => $@"{API.APIEndpointUrl}/api/v2/{Target}";
+        protected virtual string Uri => $@"{API!.APIEndpointUrl}/api/v2/{Target}";
+
+        protected IAPIProvider? API;
 
-        protected APIAccess API;
-        protected WebRequest WebRequest;
+        protected WebRequest? WebRequest;
 
         /// <summary>
         /// The currently logged in user. Note that this will only be populated during <see cref="Perform"/>.
         /// </summary>
-        protected APIUser User { get; private set; }
+        protected APIUser? User { get; private set; }
 
         /// <summary>
         /// Invoked on successful completion of an API request.
         /// This will be scheduled to the API's internal scheduler (run on update thread automatically).
         /// </summary>
-        public event APISuccessHandler Success;
+        public event APISuccessHandler? Success;
 
         /// <summary>
         /// Invoked on failure to complete an API request.
         /// This will be scheduled to the API's internal scheduler (run on update thread automatically).
         /// </summary>
-        public event APIFailureHandler Failure;
+        public event APIFailureHandler? Failure;
 
         private readonly object completionStateLock = new object();
 
@@ -101,16 +102,29 @@ public abstract class APIRequest
         /// </summary>
         public APIRequestCompletionState CompletionState { get; private set; }
 
-        public void Perform(IAPIProvider api)
+        /// <summary>
+        /// Should be called before <see cref="Perform"/> to give API context.
+        /// </summary>
+        /// <remarks>
+        /// This allows scheduling of operations back to the correct thread (which may be required before <see cref="Perform"/> is called).
+        /// </remarks>
+        public void AttachAPI(IAPIProvider apiAccess)
+        {
+            if (API != null && API != apiAccess)
+                throw new InvalidOperationException("Attached API cannot be changed after initial set.");
+
+            API = apiAccess;
+        }
+
+        public void Perform()
         {
-            if (!(api is APIAccess apiAccess))
+            if (API == null)
             {
                 Fail(new NotSupportedException($"A {nameof(APIAccess)} is required to perform requests."));
                 return;
             }
 
-            API = apiAccess;
-            User = apiAccess.LocalUser.Value;
+            User = API.LocalUser.Value;
 
             if (isFailing) return;
 
@@ -141,6 +155,8 @@ public void Perform(IAPIProvider api)
 
             PostProcess();
 
+            if (isFailing) return;
+
             TriggerSuccess();
         }
 
@@ -153,6 +169,8 @@ protected virtual void PostProcess()
 
         internal void TriggerSuccess()
         {
+            Debug.Assert(API != null);
+
             lock (completionStateLock)
             {
                 if (CompletionState != APIRequestCompletionState.Waiting)
@@ -161,14 +179,13 @@ internal void TriggerSuccess()
                 CompletionState = APIRequestCompletionState.Completed;
             }
 
-            if (API == null)
-                Success?.Invoke();
-            else
-                API.Schedule(() => Success?.Invoke());
+            API.Schedule(() => Success?.Invoke());
         }
 
         internal void TriggerFailure(Exception e)
         {
+            Debug.Assert(API != null);
+
             lock (completionStateLock)
             {
                 if (CompletionState != APIRequestCompletionState.Waiting)
@@ -177,10 +194,7 @@ internal void TriggerFailure(Exception e)
                 CompletionState = APIRequestCompletionState.Failed;
             }
 
-            if (API == null)
-                Failure?.Invoke(e);
-            else
-                API.Schedule(() => Failure?.Invoke(e));
+            API.Schedule(() => Failure?.Invoke(e));
         }
 
         public void Cancel() => Fail(new OperationCanceledException(@"Request cancelled"));
@@ -197,7 +211,7 @@ public void Fail(Exception e)
                 // in the case of a cancellation we don't care about whether there's an error in the response.
                 if (!(e is OperationCanceledException))
                 {
-                    string responseString = WebRequest?.GetResponseString();
+                    string? responseString = WebRequest?.GetResponseString();
 
                     // naive check whether there's an error in the response to avoid unnecessary JSON deserialisation.
                     if (!string.IsNullOrEmpty(responseString) && responseString.Contains(@"""error"""))
@@ -235,7 +249,7 @@ private bool isFailing
         private class DisplayableError
         {
             [JsonProperty("error")]
-            public string ErrorMessage { get; set; }
+            public string ErrorMessage { get; set; } = string.Empty;
         }
     }
 
diff --git a/osu.Game/Online/API/DummyAPIAccess.cs b/osu.Game/Online/API/DummyAPIAccess.cs
index 0af76537cd76..7ac5c45fada0 100644
--- a/osu.Game/Online/API/DummyAPIAccess.cs
+++ b/osu.Game/Online/API/DummyAPIAccess.cs
@@ -82,6 +82,8 @@ public DummyAPIAccess()
 
         public virtual void Queue(APIRequest request)
         {
+            request.AttachAPI(this);
+
             Schedule(() =>
             {
                 if (HandleRequest?.Invoke(request) != true)
@@ -98,10 +100,17 @@ public virtual void Queue(APIRequest request)
             });
         }
 
-        public void Perform(APIRequest request) => HandleRequest?.Invoke(request);
+        void IAPIProvider.Schedule(Action action) => base.Schedule(action);
+
+        public void Perform(APIRequest request)
+        {
+            request.AttachAPI(this);
+            HandleRequest?.Invoke(request);
+        }
 
         public Task PerformAsync(APIRequest request)
         {
+            request.AttachAPI(this);
             HandleRequest?.Invoke(request);
             return Task.CompletedTask;
         }
@@ -155,6 +164,8 @@ public void AuthenticateSecondFactor(string code)
             state.Value = APIState.Connecting;
             LastLoginError = null;
 
+            request.AttachAPI(this);
+
             // if no handler installed / handler can't handle verification, just assume that the server would verify for simplicity.
             if (HandleRequest?.Invoke(request) != true)
                 onSuccessfulLogin();
diff --git a/osu.Game/Online/API/IAPIProvider.cs b/osu.Game/Online/API/IAPIProvider.cs
index d8194dc32b19..eccfb3654659 100644
--- a/osu.Game/Online/API/IAPIProvider.cs
+++ b/osu.Game/Online/API/IAPIProvider.cs
@@ -134,6 +134,11 @@ public interface IAPIProvider
         /// </summary>
         void UpdateStatistics(UserStatistics newStatistics);
 
+        /// <summary>
+        /// Schedule a callback to run on the update thread.
+        /// </summary>
+        internal void Schedule(Action action);
+
         /// <summary>
         /// Constructs a new <see cref="IHubClientConnector"/>. May be null if not supported.
         /// </summary>
diff --git a/osu.Game/Online/API/Requests/JoinChannelRequest.cs b/osu.Game/Online/API/Requests/JoinChannelRequest.cs
index 33eab7e3551e..0109e653d90d 100644
--- a/osu.Game/Online/API/Requests/JoinChannelRequest.cs
+++ b/osu.Game/Online/API/Requests/JoinChannelRequest.cs
@@ -23,6 +23,6 @@ protected override WebRequest CreateWebRequest()
             return req;
         }
 
-        protected override string Target => $@"chat/channels/{channel.Id}/users/{User.Id}";
+        protected override string Target => $@"chat/channels/{channel.Id}/users/{User!.Id}";
     }
 }
diff --git a/osu.Game/Online/API/Requests/LeaveChannelRequest.cs b/osu.Game/Online/API/Requests/LeaveChannelRequest.cs
index 7dfc9a0aed36..36cfd79c6074 100644
--- a/osu.Game/Online/API/Requests/LeaveChannelRequest.cs
+++ b/osu.Game/Online/API/Requests/LeaveChannelRequest.cs
@@ -23,6 +23,6 @@ protected override WebRequest CreateWebRequest()
             return req;
         }
 
-        protected override string Target => $@"chat/channels/{channel.Id}/users/{User.Id}";
+        protected override string Target => $@"chat/channels/{channel.Id}/users/{User!.Id}";
     }
 }
diff --git a/osu.Game/Online/BeatmapDownloadTracker.cs b/osu.Game/Online/BeatmapDownloadTracker.cs
index 3db602c35352..6a2163c3a298 100644
--- a/osu.Game/Online/BeatmapDownloadTracker.cs
+++ b/osu.Game/Online/BeatmapDownloadTracker.cs
@@ -40,7 +40,10 @@ protected override void LoadComplete()
             // Used to interact with manager classes that don't support interface types. Will eventually be replaced.
             var beatmapSetInfo = new BeatmapSetInfo { OnlineID = TrackedItem.OnlineID };
 
-            realmSubscription = realm.RegisterForNotifications(r => r.All<BeatmapSetInfo>().Where(s => s.OnlineID == TrackedItem.OnlineID && !s.DeletePending), (items, _) =>
+            // Required local for iOS. Will cause runtime crash if inlined.
+            int onlineId = TrackedItem.OnlineID;
+
+            realmSubscription = realm.RegisterForNotifications(r => r.All<BeatmapSetInfo>().Where(s => s.OnlineID == onlineId && !s.DeletePending), (items, _) =>
             {
                 if (items.Any())
                     Schedule(() => UpdateState(DownloadState.LocallyAvailable));
diff --git a/osu.Game/Online/Chat/ExternalLinkOpener.cs b/osu.Game/Online/Chat/ExternalLinkOpener.cs
index 82ad4215c216..90fec5fafd7f 100644
--- a/osu.Game/Online/Chat/ExternalLinkOpener.cs
+++ b/osu.Game/Online/Chat/ExternalLinkOpener.cs
@@ -60,7 +60,7 @@ public ExternalLinkDialog(string url, Action openExternalLinkAction, Action copy
                     },
                     new PopupDialogCancelButton
                     {
-                        Text = @"Copy URL to the clipboard",
+                        Text = @"Copy link",
                         Action = copyExternalLinkAction
                     },
                     new PopupDialogCancelButton
diff --git a/osu.Game/Online/Chat/WebSocketChatClient.cs b/osu.Game/Online/Chat/WebSocketChatClient.cs
index 37774a1f5da4..a74f0222f28e 100644
--- a/osu.Game/Online/Chat/WebSocketChatClient.cs
+++ b/osu.Game/Online/Chat/WebSocketChatClient.cs
@@ -80,7 +80,7 @@ public void RequestPresence()
 
             fetchReq.Success += updates =>
             {
-                if (updates?.Presence != null)
+                if (updates.Presence != null)
                 {
                     foreach (var channel in updates.Presence)
                         joinChannel(channel);
diff --git a/osu.Game/Online/Rooms/JoinRoomRequest.cs b/osu.Game/Online/Rooms/JoinRoomRequest.cs
index 8645f2a2c095..9a73104b608f 100644
--- a/osu.Game/Online/Rooms/JoinRoomRequest.cs
+++ b/osu.Game/Online/Rooms/JoinRoomRequest.cs
@@ -27,6 +27,6 @@ protected override WebRequest CreateWebRequest()
             return req;
         }
 
-        protected override string Target => $@"rooms/{Room.RoomID.Value}/users/{User.Id}";
+        protected override string Target => $@"rooms/{Room.RoomID.Value}/users/{User!.Id}";
     }
 }
diff --git a/osu.Game/Online/Rooms/PartRoomRequest.cs b/osu.Game/Online/Rooms/PartRoomRequest.cs
index 09ba6f65c3b5..2416833a1e8a 100644
--- a/osu.Game/Online/Rooms/PartRoomRequest.cs
+++ b/osu.Game/Online/Rooms/PartRoomRequest.cs
@@ -23,6 +23,6 @@ protected override WebRequest CreateWebRequest()
             return req;
         }
 
-        protected override string Target => $"rooms/{room.RoomID.Value}/users/{User.Id}";
+        protected override string Target => $"rooms/{room.RoomID.Value}/users/{User!.Id}";
     }
 }
diff --git a/osu.Game/Online/ScoreDownloadTracker.cs b/osu.Game/Online/ScoreDownloadTracker.cs
index dfdac24d1950..5f6ba15d0564 100644
--- a/osu.Game/Online/ScoreDownloadTracker.cs
+++ b/osu.Game/Online/ScoreDownloadTracker.cs
@@ -46,10 +46,15 @@ protected override void LoadComplete()
             Downloader.DownloadBegan += downloadBegan;
             Downloader.DownloadFailed += downloadFailed;
 
+            // Required local for iOS. Will cause runtime crash if inlined.
+            long onlineId = TrackedItem.OnlineID;
+            long legacyOnlineId = TrackedItem.LegacyOnlineID;
+            string hash = TrackedItem.Hash;
+
             realmSubscription = realm.RegisterForNotifications(r => r.All<ScoreInfo>().Where(s =>
-                ((s.OnlineID > 0 && s.OnlineID == TrackedItem.OnlineID)
-                 || (s.LegacyOnlineID > 0 && s.LegacyOnlineID == TrackedItem.LegacyOnlineID)
-                 || (!string.IsNullOrEmpty(s.Hash) && s.Hash == TrackedItem.Hash))
+                ((s.OnlineID > 0 && s.OnlineID == onlineId)
+                 || (s.LegacyOnlineID > 0 && s.LegacyOnlineID == legacyOnlineId)
+                 || (!string.IsNullOrEmpty(s.Hash) && s.Hash == hash))
                 && !s.DeletePending), (items, _) =>
             {
                 if (items.Any())
diff --git a/osu.Game/OsuGame.cs b/osu.Game/OsuGame.cs
index 7e4d2ccf39b1..44ba78762add 100644
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@@ -54,6 +54,7 @@
 using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Music;
 using osu.Game.Overlays.Notifications;
+using osu.Game.Overlays.OSD;
 using osu.Game.Overlays.SkinEditor;
 using osu.Game.Overlays.Toolbar;
 using osu.Game.Overlays.Volume;
@@ -142,6 +143,8 @@ public partial class OsuGame : OsuGameBase, IKeyBindingHandler<GlobalAction>, IL
 
         private Container overlayOffsetContainer;
 
+        private OnScreenDisplay onScreenDisplay;
+
         [Resolved]
         private FrameworkConfigManager frameworkConfig { get; set; }
 
@@ -442,10 +445,11 @@ public void HandleLink(LinkDetails link) => Schedule(() =>
                     break;
 
                 case LinkAction.SearchBeatmapSet:
-                    if (link.Argument is RomanisableString romanisable)
-                        SearchBeatmapSet(romanisable.GetPreferred(Localisation.CurrentParameters.Value.PreferOriginalScript));
+                    if (link.Argument is LocalisableString localisable)
+                        SearchBeatmapSet(Localisation.GetLocalisedString(localisable));
                     else
                         SearchBeatmapSet(argString);
+
                     break;
 
                 case LinkAction.FilterBeatmapSetGenre:
@@ -497,6 +501,12 @@ public void HandleLink(LinkDetails link) => Schedule(() =>
             }
         });
 
+        public void CopyUrlToClipboard(string url) => waitForReady(() => onScreenDisplay, _ =>
+        {
+            dependencies.Get<Clipboard>().SetText(url);
+            onScreenDisplay.Display(new CopyUrlToast());
+        });
+
         public void OpenUrlExternally(string url, bool forceBypassExternalUrlWarning = false) => waitForReady(() => externalLinkOpener, _ =>
         {
             bool isTrustedDomain;
@@ -1078,7 +1088,7 @@ protected override void LoadComplete()
 
             loadComponentSingleFile(volume = new VolumeOverlay(), leftFloatingOverlayContent.Add, true);
 
-            var onScreenDisplay = new OnScreenDisplay();
+            onScreenDisplay = new OnScreenDisplay();
 
             onScreenDisplay.BeginTracking(this, frameworkConfig);
             onScreenDisplay.BeginTracking(this, LocalConfig);
@@ -1132,6 +1142,7 @@ protected override void LoadComplete()
             loadComponentSingleFile(new MedalOverlay(), topMostOverlayContent.Add);
 
             loadComponentSingleFile(new BackgroundDataStoreProcessor(), Add);
+            loadComponentSingleFile(new DetachedBeatmapStore(), Add, true);
 
             Add(difficultyRecommender);
             Add(externalLinkOpener = new ExternalLinkOpener());
diff --git a/osu.Game/OsuGameBase.cs b/osu.Game/OsuGameBase.cs
index 5e4ec5a61d93..ce0c288934ee 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -515,6 +515,12 @@ public virtual void AttemptExit()
         /// <returns>Whether a restart operation was queued.</returns>
         public virtual bool RestartAppWhenExited() => false;
 
+        /// <summary>
+        /// Perform migration of user data to a specified path.
+        /// </summary>
+        /// <param name="path">The path to migrate to.</param>
+        /// <returns>Whether migration succeeded to completion. If <c>false</c>, some files were left behind.</returns>
+        /// <exception cref="TimeoutException"></exception>
         public bool Migrate(string path)
         {
             Logger.Log($@"Migrating osu! data from ""{Storage.GetFullPath(string.Empty)}"" to ""{path}""...");
@@ -542,10 +548,10 @@ public bool Migrate(string path)
                 if (!readyToRun.Wait(30000) || !success)
                     throw new TimeoutException("Attempting to block for migration took too long.");
 
-                bool? cleanupSucceded = (Storage as OsuStorage)?.Migrate(Host.GetStorage(path));
+                bool? cleanupSucceeded = (Storage as OsuStorage)?.Migrate(Host.GetStorage(path));
 
                 Logger.Log(@"Migration complete!");
-                return cleanupSucceded != false;
+                return cleanupSucceeded != false;
             }
             finally
             {
@@ -686,7 +692,7 @@ private bool onExceptionThrown(Exception ex)
             if (Interlocked.Decrement(ref allowableExceptions) < 0)
             {
                 Logger.Log("Too many unhandled exceptions, crashing out.");
-                RulesetStore.TryDisableCustomRulesetsCausing(ex);
+                RulesetStore?.TryDisableCustomRulesetsCausing(ex);
                 return false;
             }
 
diff --git a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
index 7ff8352054a7..a50043f0f084 100644
--- a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
+++ b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
@@ -200,7 +200,8 @@ public BeatmapSetHeaderContent()
 
         private void updateExternalLink()
         {
-            if (externalLink != null) externalLink.Link = $@"{api.WebsiteRootUrl}/beatmapsets/{BeatmapSet.Value?.OnlineID}#{Picker.Beatmap.Value?.Ruleset.ShortName}/{Picker.Beatmap.Value?.OnlineID}";
+            if (externalLink != null)
+                externalLink.Link = Picker.Beatmap.Value?.GetOnlineURL(api) ?? BeatmapSet.Value?.GetOnlineURL(api);
         }
 
         [BackgroundDependencyLoader]
@@ -241,7 +242,7 @@ private void load(OverlayColourProvider colourProvider)
                     title.Clear();
                     artist.Clear();
 
-                    title.AddLink(titleText, LinkAction.SearchBeatmapSet, titleText);
+                    title.AddLink(titleText, LinkAction.SearchBeatmapSet, LocalisableString.Interpolate($@"title=""""{titleText}"""""));
 
                     title.AddArbitraryDrawable(Empty().With(d => d.Width = 5));
                     title.AddArbitraryDrawable(externalLink = new ExternalLinkButton());
@@ -258,7 +259,7 @@ private void load(OverlayColourProvider colourProvider)
                         title.AddArbitraryDrawable(new SpotlightBeatmapBadge());
                     }
 
-                    artist.AddLink(artistText, LinkAction.SearchBeatmapSet, artistText);
+                    artist.AddLink(artistText, LinkAction.SearchBeatmapSet, LocalisableString.Interpolate($@"artist=""""{artistText}"""""));
 
                     if (setInfo.NewValue.TrackId != null)
                     {
diff --git a/osu.Game/Overlays/Comments/DrawableComment.cs b/osu.Game/Overlays/Comments/DrawableComment.cs
index afd4b96c6882..296f90872e55 100644
--- a/osu.Game/Overlays/Comments/DrawableComment.cs
+++ b/osu.Game/Overlays/Comments/DrawableComment.cs
@@ -47,7 +47,7 @@ public partial class DrawableComment : CompositeDrawable
 
         public readonly BindableList<DrawableComment> Replies = new BindableList<DrawableComment>();
 
-        private readonly BindableBool childrenExpanded = new BindableBool(true);
+        private readonly BindableBool childrenExpanded;
 
         private int currentPage;
 
@@ -92,6 +92,8 @@ public DrawableComment(Comment comment, IReadOnlyList<CommentableMeta> meta)
         {
             Comment = comment;
             Meta = meta;
+
+            childrenExpanded = new BindableBool(!comment.Pinned);
         }
 
         [BackgroundDependencyLoader]
diff --git a/osu.Game/Overlays/FirstRunSetup/ScreenImportFromStable.cs b/osu.Game/Overlays/FirstRunSetup/ScreenImportFromStable.cs
index 983cb0bbb45a..5eb38b6e11ed 100644
--- a/osu.Game/Overlays/FirstRunSetup/ScreenImportFromStable.cs
+++ b/osu.Game/Overlays/FirstRunSetup/ScreenImportFromStable.cs
@@ -314,6 +314,7 @@ protected override void Dispose(bool isDisposing)
             private partial class DirectoryChooserPopover : OsuPopover
             {
                 public DirectoryChooserPopover(Bindable<DirectoryInfo?> currentDirectory)
+                    : base(false)
                 {
                     Child = new Container
                     {
@@ -325,6 +326,13 @@ public DirectoryChooserPopover(Bindable<DirectoryInfo?> currentDirectory)
                         },
                     };
                 }
+
+                [BackgroundDependencyLoader]
+                private void load(OverlayColourProvider colourProvider)
+                {
+                    Body.BorderColour = colourProvider.Highlight1;
+                    Body.BorderThickness = 2;
+                }
             }
         }
     }
diff --git a/osu.Game/Overlays/MedalAnimation.cs b/osu.Game/Overlays/MedalAnimation.cs
index 25776d50db6f..daceeedf47c1 100644
--- a/osu.Game/Overlays/MedalAnimation.cs
+++ b/osu.Game/Overlays/MedalAnimation.cs
@@ -30,7 +30,8 @@ public partial class MedalAnimation : VisibilityContainer
 
         private const float border_width = 5;
 
-        private readonly Medal medal;
+        public readonly Medal Medal;
+
         private readonly Box background;
         private readonly Container backgroundStrip, particleContainer;
         private readonly BackgroundStrip leftStrip, rightStrip;
@@ -44,7 +45,7 @@ public partial class MedalAnimation : VisibilityContainer
 
         public MedalAnimation(Medal medal)
         {
-            this.medal = medal;
+            Medal = medal;
             RelativeSizeAxes = Axes.Both;
 
             Child = content = new Container
@@ -168,7 +169,7 @@ protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            LoadComponentAsync(drawableMedal = new DrawableMedal(medal)
+            LoadComponentAsync(drawableMedal = new DrawableMedal(Medal)
             {
                 Anchor = Anchor.TopCentre,
                 Origin = Anchor.TopCentre,
diff --git a/osu.Game/Overlays/MedalOverlay.cs b/osu.Game/Overlays/MedalOverlay.cs
index 072d7db6c7c1..19f61cb91029 100644
--- a/osu.Game/Overlays/MedalOverlay.cs
+++ b/osu.Game/Overlays/MedalOverlay.cs
@@ -8,6 +8,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Events;
+using osu.Framework.Logging;
 using osu.Game.Graphics.Containers;
 using osu.Game.Input.Bindings;
 using osu.Game.Online.API;
@@ -81,7 +82,10 @@ private void handleMedalMessages(SocketMessage obj)
             };
 
             var medalAnimation = new MedalAnimation(medal);
+
             queuedMedals.Enqueue(medalAnimation);
+            Logger.Log($"Queueing medal unlock for \"{medal.Name}\" ({queuedMedals.Count} to display)");
+
             if (OverlayActivationMode.Value == OverlayActivation.All)
                 Scheduler.AddOnce(Show);
         }
@@ -95,10 +99,12 @@ protected override void Update()
 
             if (!queuedMedals.TryDequeue(out lastAnimation))
             {
+                Logger.Log("All queued medals have been displayed!");
                 Hide();
                 return;
             }
 
+            Logger.Log($"Preparing to display \"{lastAnimation.Medal.Name}\"");
             LoadComponentAsync(lastAnimation, medalContainer.Add);
         }
 
diff --git a/osu.Game/Overlays/Mods/ModCustomisationHeader.cs b/osu.Game/Overlays/Mods/ModCustomisationHeader.cs
index abd48a0dcb27..54fbd37dbe62 100644
--- a/osu.Game/Overlays/Mods/ModCustomisationHeader.cs
+++ b/osu.Game/Overlays/Mods/ModCustomisationHeader.cs
@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
@@ -20,18 +19,17 @@
 
 namespace osu.Game.Overlays.Mods
 {
-    public partial class ModCustomisationHeader : OsuHoverContainer
+    public partial class ModCustomisationHeader : OsuClickableContainer
     {
         private Box background = null!;
+        private Box hoverBackground = null!;
         private Box backgroundFlash = null!;
         private SpriteIcon icon = null!;
 
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
-        protected override IEnumerable<Drawable> EffectTargets => new[] { background };
-
-        public readonly Bindable<ModCustomisationPanelState> ExpandedState = new Bindable<ModCustomisationPanelState>(ModCustomisationPanelState.Collapsed);
+        public readonly Bindable<ModCustomisationPanelState> ExpandedState = new Bindable<ModCustomisationPanelState>();
 
         private readonly ModCustomisationPanel panel;
 
@@ -53,6 +51,13 @@ private void load()
                 {
                     RelativeSizeAxes = Axes.Both,
                 },
+                hoverBackground = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = OsuColour.Gray(50),
+                    Blending = BlendingParameters.Additive,
+                    Alpha = 0,
+                },
                 backgroundFlash = new Box
                 {
                     RelativeSizeAxes = Axes.Both,
@@ -84,9 +89,6 @@ private void load()
                     }
                 }
             };
-
-            IdleColour = colourProvider.Dark3;
-            HoverColour = colourProvider.Light4;
         }
 
         protected override void LoadComplete()
@@ -109,45 +111,37 @@ protected override void LoadComplete()
             ExpandedState.BindValueChanged(v =>
             {
                 icon.ScaleTo(v.NewValue > ModCustomisationPanelState.Collapsed ? new Vector2(1, -1) : Vector2.One, 300, Easing.OutQuint);
-            }, true);
-        }
 
-        protected override bool OnClick(ClickEvent e)
-        {
-            if (Enabled.Value)
-            {
-                ExpandedState.Value = ExpandedState.Value switch
+                switch (v.NewValue)
                 {
-                    ModCustomisationPanelState.Collapsed => ModCustomisationPanelState.Expanded,
-                    _ => ModCustomisationPanelState.Collapsed
-                };
-            }
-
-            return base.OnClick(e);
+                    case ModCustomisationPanelState.Collapsed:
+                        background.FadeColour(colourProvider.Dark3, 500, Easing.OutQuint);
+                        break;
+
+                    case ModCustomisationPanelState.Expanded:
+                    case ModCustomisationPanelState.ExpandedByMod:
+                        background.FadeColour(colourProvider.Light4, 500, Easing.OutQuint);
+                        break;
+                }
+            }, true);
         }
 
-        private bool touchedThisFrame;
-
-        protected override bool OnTouchDown(TouchDownEvent e)
+        protected override bool OnHover(HoverEvent e)
         {
-            if (Enabled.Value)
-            {
-                touchedThisFrame = true;
-                Schedule(() => touchedThisFrame = false);
-            }
+            if (!Enabled.Value)
+                return base.OnHover(e);
+
+            if (panel.ExpandedState.Value == ModCustomisationPanelState.Collapsed)
+                panel.ExpandedState.Value = ModCustomisationPanelState.Expanded;
 
-            return base.OnTouchDown(e);
+            hoverBackground.FadeTo(0.4f, 200, Easing.OutQuint);
+            return base.OnHover(e);
         }
 
-        protected override bool OnHover(HoverEvent e)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
-            if (Enabled.Value)
-            {
-                if (!touchedThisFrame && panel.ExpandedState.Value == ModCustomisationPanelState.Collapsed)
-                    panel.ExpandedState.Value = ModCustomisationPanelState.ExpandedByHover;
-            }
-
-            return base.OnHover(e);
+            hoverBackground.FadeOut(200, Easing.OutQuint);
+            base.OnHoverLost(e);
         }
     }
 }
diff --git a/osu.Game/Overlays/Mods/ModCustomisationPanel.cs b/osu.Game/Overlays/Mods/ModCustomisationPanel.cs
index 75cd5d6c91ea..03a1b3d0dd5a 100644
--- a/osu.Game/Overlays/Mods/ModCustomisationPanel.cs
+++ b/osu.Game/Overlays/Mods/ModCustomisationPanel.cs
@@ -11,6 +11,7 @@
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Configuration;
@@ -214,23 +215,32 @@ public FocusGrabbingContainer(ModCustomisationPanel panel)
                 this.panel = panel;
             }
 
-            protected override void OnHoverLost(HoverLostEvent e)
+            private InputManager inputManager = null!;
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                inputManager = GetContainingInputManager()!;
+            }
+
+            protected override void Update()
             {
-                if (ExpandedState.Value is ModCustomisationPanelState.ExpandedByHover
-                    && !ReceivePositionalInputAt(e.ScreenSpaceMousePosition))
+                base.Update();
+
+                if (ExpandedState.Value == ModCustomisationPanelState.Expanded
+                    && !ReceivePositionalInputAt(inputManager.CurrentState.Mouse.Position)
+                    && inputManager.DraggedDrawable == null)
                 {
                     ExpandedState.Value = ModCustomisationPanelState.Collapsed;
                 }
-
-                base.OnHoverLost(e);
             }
         }
 
         public enum ModCustomisationPanelState
         {
             Collapsed = 0,
-            ExpandedByHover = 1,
-            Expanded = 2,
+            Expanded = 1,
+            ExpandedByMod = 2,
         }
     }
 }
diff --git a/osu.Game/Overlays/Mods/ModSelectOverlay.cs b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
index 74890df5d937..cdc0fbbd964e 100644
--- a/osu.Game/Overlays/Mods/ModSelectOverlay.cs
+++ b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
@@ -368,7 +368,7 @@ private void updateCustomisation()
                 customisationPanel.Enabled.Value = true;
 
                 if (anyModPendingConfiguration)
-                    customisationPanel.ExpandedState.Value = ModCustomisationPanel.ModCustomisationPanelState.Expanded;
+                    customisationPanel.ExpandedState.Value = ModCustomisationPanel.ModCustomisationPanelState.ExpandedByMod;
             }
             else
             {
diff --git a/osu.Game/Overlays/MusicController.cs b/osu.Game/Overlays/MusicController.cs
index 27c7cd0f49af..63efdd5381b6 100644
--- a/osu.Game/Overlays/MusicController.cs
+++ b/osu.Game/Overlays/MusicController.cs
@@ -115,7 +115,7 @@ public void SeekTo(double position)
             seekDelegate?.Cancel();
             seekDelegate = Schedule(() =>
             {
-                if (beatmap.Disabled || !AllowTrackControl.Value)
+                if (!AllowTrackControl.Value)
                     return;
 
                 CurrentTrack.Seek(position);
diff --git a/osu.Game/Overlays/NotificationOverlayToastTray.cs b/osu.Game/Overlays/NotificationOverlayToastTray.cs
index d2899f29b8fa..df07b4f13825 100644
--- a/osu.Game/Overlays/NotificationOverlayToastTray.cs
+++ b/osu.Game/Overlays/NotificationOverlayToastTray.cs
@@ -153,8 +153,22 @@ protected override void Update()
         {
             base.Update();
 
-            float height = toastFlow.Count > 0 ? toastFlow.DrawHeight + 120 : 0;
-            float alpha = toastFlow.Count > 0 ? MathHelper.Clamp(toastFlow.DrawHeight / 41, 0, 1) * toastFlow.Children.Max(n => n.Alpha) : 0;
+            float height = 0;
+            float alpha = 0;
+
+            if (toastFlow.Count > 0)
+            {
+                float maxNotificationAlpha = 0;
+
+                foreach (var t in toastFlow)
+                {
+                    if (t.Alpha > maxNotificationAlpha)
+                        maxNotificationAlpha = t.Alpha;
+                }
+
+                height = toastFlow.DrawHeight + 120;
+                alpha = MathHelper.Clamp(toastFlow.DrawHeight / 41, 0, 1) * maxNotificationAlpha;
+            }
 
             toastContentBackground.Height = (float)Interpolation.DampContinuously(toastContentBackground.Height, height, 10, Clock.ElapsedFrameTime);
             toastContentBackground.Alpha = (float)Interpolation.DampContinuously(toastContentBackground.Alpha, alpha, 10, Clock.ElapsedFrameTime);
diff --git a/osu.Game/Overlays/Profile/Header/Components/DailyChallengeStatsDisplay.cs b/osu.Game/Overlays/Profile/Header/Components/DailyChallengeStatsDisplay.cs
index 82d3cfafd711..3e86b2268f9c 100644
--- a/osu.Game/Overlays/Profile/Header/Components/DailyChallengeStatsDisplay.cs
+++ b/osu.Game/Overlays/Profile/Header/Components/DailyChallengeStatsDisplay.cs
@@ -11,9 +11,8 @@
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Scoring;
 using osu.Game.Localisation;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Overlays.Profile.Header.Components
 {
@@ -98,7 +97,7 @@ protected override void LoadComplete()
 
         private void updateDisplay()
         {
-            if (User.Value == null || User.Value.Ruleset.OnlineID != 0)
+            if (User.Value == null)
             {
                 Hide();
                 return;
@@ -106,14 +105,18 @@ private void updateDisplay()
 
             APIUserDailyChallengeStatistics stats = User.Value.User.DailyChallengeStatistics;
 
+            if (stats.PlayCount == 0)
+            {
+                Hide();
+                return;
+            }
+
             dailyPlayCount.Text = DailyChallengeStatsDisplayStrings.UnitDay(stats.PlayCount.ToLocalisableString("N0"));
-            dailyPlayCount.Colour = colours.ForRankingTier(tierForPlayCount(stats.PlayCount));
+            dailyPlayCount.Colour = colours.ForRankingTier(DailyChallengeStatsTooltip.TierForPlayCount(stats.PlayCount));
 
             TooltipContent = new DailyChallengeTooltipData(colourProvider, stats);
 
             Show();
-
-            static RankingTier tierForPlayCount(int playCount) => DailyChallengeStatsTooltip.TierForDaily(playCount / 3);
         }
 
         public ITooltip<DailyChallengeTooltipData> GetCustomTooltip() => new DailyChallengeStatsTooltip();
diff --git a/osu.Game/Overlays/Profile/Header/Components/DailyChallengeStatsTooltip.cs b/osu.Game/Overlays/Profile/Header/Components/DailyChallengeStatsTooltip.cs
index 64a8d67c5bcf..24e531bd87a1 100644
--- a/osu.Game/Overlays/Profile/Header/Components/DailyChallengeStatsTooltip.cs
+++ b/osu.Game/Overlays/Profile/Header/Components/DailyChallengeStatsTooltip.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.Extensions.Color4Extensions;
 using osu.Framework.Extensions.LocalisationExtensions;
@@ -26,6 +27,7 @@ public partial class DailyChallengeStatsTooltip : VisibilityContainer, ITooltip<
     {
         private StreakPiece currentDaily = null!;
         private StreakPiece currentWeekly = null!;
+        private StreakPiece totalParticipation = null!;
         private StatisticsPiece bestDaily = null!;
         private StatisticsPiece bestWeekly = null!;
         private StatisticsPiece topTen = null!;
@@ -80,6 +82,7 @@ private void load()
                                     Spacing = new Vector2(30f),
                                     Children = new[]
                                     {
+                                        totalParticipation = new StreakPiece(UsersStrings.ShowDailyChallengePlaycount),
                                         currentDaily = new StreakPiece(UsersStrings.ShowDailyChallengeDailyStreakCurrent),
                                         currentWeekly = new StreakPiece(UsersStrings.ShowDailyChallengeWeeklyStreakCurrent),
                                     }
@@ -113,6 +116,9 @@ public void SetContent(DailyChallengeTooltipData content)
             background.Colour = colourProvider.Background4;
             topBackground.Colour = colourProvider.Background5;
 
+            totalParticipation.Value = DailyChallengeStatsDisplayStrings.UnitDay(statistics.PlayCount.ToLocalisableString(@"N0"));
+            totalParticipation.ValueColour = colours.ForRankingTier(TierForPlayCount(statistics.PlayCount));
+
             currentDaily.Value = DailyChallengeStatsDisplayStrings.UnitDay(content.Statistics.DailyStreakCurrent.ToLocalisableString(@"N0"));
             currentDaily.ValueColour = colours.ForRankingTier(TierForDaily(statistics.DailyStreakCurrent));
 
@@ -132,7 +138,13 @@ public void SetContent(DailyChallengeTooltipData content)
             topFifty.ValueColour = colourProvider.Content2;
         }
 
-        // reference: https://github.com/ppy/osu-web/blob/8206e0e91eeea80ccf92f0586561346dd40e085e/resources/js/profile-page/daily-challenge.tsx#L13-L43
+        // reference: https://github.com/ppy/osu-web/blob/adf1e94754ba9625b85eba795f4a310caf169eec/resources/js/profile-page/daily-challenge.tsx#L13-L47
+
+        // Rounding up is needed here to ensure the overlay shows the same colour as osu-web for the play count.
+        // This is because, for example, 31 / 3 > 10 in JavaScript because floats are used, while here it would
+        // get truncated to 10 with an integer division and show a lower tier.
+        public static RankingTier TierForPlayCount(int playCount) => TierForDaily((int)Math.Ceiling(playCount / 3.0d));
+
         public static RankingTier TierForDaily(int daily)
         {
             if (daily > 360)
diff --git a/osu.Game/Overlays/Settings/Sections/Gameplay/HUDSettings.cs b/osu.Game/Overlays/Settings/Sections/Gameplay/HUDSettings.cs
index 3e67b2f10331..f4dd319152c0 100644
--- a/osu.Game/Overlays/Settings/Sections/Gameplay/HUDSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Gameplay/HUDSettings.cs
@@ -41,6 +41,11 @@ private void load(OsuConfigManager config)
                     Current = config.GetBindable<bool>(OsuSetting.GameplayLeaderboard),
                 },
                 new SettingsCheckbox
+                {
+                    LabelText = GameplaySettingsStrings.AlwaysShowHoldForMenuButton,
+                    Current = config.GetBindable<bool>(OsuSetting.AlwaysShowHoldForMenuButton),
+                },
+                new SettingsCheckbox
                 {
                     ClassicDefault = false,
                     LabelText = GameplaySettingsStrings.ShowHealthDisplayWhenCantFail,
diff --git a/osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs b/osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs
index e87ca32bf6c8..f6f8d3b336d0 100644
--- a/osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs
+++ b/osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs
@@ -48,8 +48,11 @@ public abstract partial class DirectorySelectScreen : OsuScreen
         /// </summary>
         protected virtual DirectoryInfo InitialPath => null;
 
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
+
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load()
         {
             InternalChild = new Container
             {
@@ -64,7 +67,7 @@ private void load(OsuColour colours)
                     new Box
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Colour = colours.GreySeaFoamDark
+                        Colour = colourProvider.Background4,
                     },
                     new GridContainer
                     {
diff --git a/osu.Game/Overlays/Settings/Sections/Maintenance/MigrationRunScreen.cs b/osu.Game/Overlays/Settings/Sections/Maintenance/MigrationRunScreen.cs
index 5b24460ac2c8..3bba480aaa0a 100644
--- a/osu.Game/Overlays/Settings/Sections/Maintenance/MigrationRunScreen.cs
+++ b/osu.Game/Overlays/Settings/Sections/Maintenance/MigrationRunScreen.cs
@@ -6,17 +6,14 @@
 using System.IO;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
-using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
-using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;
-using osu.Game.Overlays.Notifications;
 using osu.Game.Screens;
 using osuTK;
 
@@ -29,15 +26,6 @@ public partial class MigrationRunScreen : OsuScreen
         [Resolved(canBeNull: true)]
         private OsuGame game { get; set; }
 
-        [Resolved]
-        private INotificationOverlay notifications { get; set; }
-
-        [Resolved]
-        private Storage storage { get; set; }
-
-        [Resolved]
-        private GameHost host { get; set; }
-
         public override bool AllowBackButton => false;
 
         public override bool AllowExternalScreenChange => false;
@@ -99,8 +87,6 @@ protected override void LoadComplete()
 
             Beatmap.Value = Beatmap.Default;
 
-            var originalStorage = new NativeStorage(storage.GetFullPath(string.Empty), host);
-
             migrationTask = Task.Run(PerformMigration)
                                 .ContinueWith(task =>
                                 {
@@ -108,18 +94,6 @@ protected override void LoadComplete()
                                     {
                                         Logger.Error(task.Exception, $"Error during migration: {task.Exception?.Message}");
                                     }
-                                    else if (!task.GetResultSafely())
-                                    {
-                                        notifications.Post(new SimpleNotification
-                                        {
-                                            Text = MaintenanceSettingsStrings.FailedCleanupNotification,
-                                            Activated = () =>
-                                            {
-                                                originalStorage.PresentExternally();
-                                                return true;
-                                            }
-                                        });
-                                    }
 
                                     Schedule(this.Exit);
                                 });
diff --git a/osu.Game/Overlays/Settings/SettingsColour.cs b/osu.Game/Overlays/Settings/SettingsColour.cs
new file mode 100644
index 000000000000..7a091f1a54d6
--- /dev/null
+++ b/osu.Game/Overlays/Settings/SettingsColour.cs
@@ -0,0 +1,80 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterfaceV2;
+
+namespace osu.Game.Overlays.Settings
+{
+    public partial class SettingsColour : SettingsItem<Colour4>
+    {
+        protected override Drawable CreateControl() => new ColourControl();
+
+        public partial class ColourControl : OsuClickableContainer, IHasPopover, IHasCurrentValue<Colour4>
+        {
+            private readonly BindableWithCurrent<Colour4> current = new BindableWithCurrent<Colour4>(Colour4.White);
+
+            public Bindable<Colour4> Current
+            {
+                get => current.Current;
+                set => current.Current = value;
+            }
+
+            private readonly Box fill;
+            private readonly OsuSpriteText colourHexCode;
+
+            public ColourControl()
+            {
+                RelativeSizeAxes = Axes.X;
+                Height = 40;
+                CornerRadius = 20;
+                Masking = true;
+                Action = this.ShowPopover;
+
+                Children = new Drawable[]
+                {
+                    fill = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both
+                    },
+                    colourHexCode = new OsuSpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Font = OsuFont.Default.With(size: 20)
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                Current.BindValueChanged(_ => updateColour(), true);
+            }
+
+            private void updateColour()
+            {
+                fill.Colour = Current.Value;
+                colourHexCode.Text = Current.Value.ToHex();
+                colourHexCode.Colour = OsuColour.ForegroundTextColourFor(Current.Value);
+            }
+
+            public Popover GetPopover() => new OsuPopover(false)
+            {
+                Child = new OsuColourPicker
+                {
+                    Current = { BindTarget = Current }
+                }
+            };
+        }
+    }
+}
diff --git a/osu.Game/Overlays/SkinEditor/SkinComponentToolbox.cs b/osu.Game/Overlays/SkinEditor/SkinComponentToolbox.cs
index a476fc1a6d00..85becc1a2306 100644
--- a/osu.Game/Overlays/SkinEditor/SkinComponentToolbox.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinComponentToolbox.cs
@@ -24,7 +24,7 @@ public partial class SkinComponentToolbox : EditorSidebarSection
     {
         public Action<Type>? RequestPlacement;
 
-        private readonly SkinComponentsContainer target;
+        private readonly SkinnableContainer target;
 
         private readonly RulesetInfo? ruleset;
 
@@ -35,7 +35,7 @@ public partial class SkinComponentToolbox : EditorSidebarSection
         /// </summary>
         /// <param name="target">The target. This is mainly used as a dependency source to find candidate components.</param>
         /// <param name="ruleset">A ruleset to filter components by. If null, only components which are not ruleset-specific will be included.</param>
-        public SkinComponentToolbox(SkinComponentsContainer target, RulesetInfo? ruleset)
+        public SkinComponentToolbox(SkinnableContainer target, RulesetInfo? ruleset)
             : base(ruleset == null ? SkinEditorStrings.Components : LocalisableString.Interpolate($"{SkinEditorStrings.Components} ({ruleset.Name})"))
         {
             this.target = target;
diff --git a/osu.Game/Overlays/SkinEditor/SkinEditor.cs b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
index 484af34603ff..6f7781ee9c07 100644
--- a/osu.Game/Overlays/SkinEditor/SkinEditor.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
@@ -33,6 +33,7 @@
 using osu.Game.Screens.Edit.Components;
 using osu.Game.Screens.Edit.Components.Menus;
 using osu.Game.Skinning;
+using osu.Framework.Graphics.Cursor;
 
 namespace osu.Game.Overlays.SkinEditor
 {
@@ -72,7 +73,7 @@ public partial class SkinEditor : VisibilityContainer, ICanAcceptFiles, IKeyBind
         [Cached]
         private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
 
-        private readonly Bindable<SkinComponentsContainerLookup?> selectedTarget = new Bindable<SkinComponentsContainerLookup?>();
+        private readonly Bindable<GlobalSkinnableContainerLookup?> selectedTarget = new Bindable<GlobalSkinnableContainerLookup?>();
 
         private bool hasBegunMutating;
 
@@ -118,107 +119,111 @@ private void load(EditorClipboard clipboard)
             InternalChild = new OsuContextMenuContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Child = new GridContainer
+                Child = new PopoverContainer
                 {
                     RelativeSizeAxes = Axes.Both,
-                    RowDimensions = new[]
+                    Child = new GridContainer
                     {
-                        new Dimension(GridSizeMode.AutoSize),
-                        new Dimension(GridSizeMode.AutoSize),
-                        new Dimension(),
-                    },
+                        RelativeSizeAxes = Axes.Both,
+                        RowDimensions = new[]
+                        {
+                            new Dimension(GridSizeMode.AutoSize),
+                            new Dimension(GridSizeMode.AutoSize),
+                            new Dimension(),
+                        },
 
-                    Content = new[]
-                    {
-                        new Drawable[]
+                        Content = new[]
                         {
-                            new Container
+                            new Drawable[]
                             {
-                                Name = @"Menu container",
-                                RelativeSizeAxes = Axes.X,
-                                Depth = float.MinValue,
-                                Height = MENU_HEIGHT,
-                                Children = new Drawable[]
+                                new Container
                                 {
-                                    new EditorMenuBar
+                                    Name = @"Menu container",
+                                    RelativeSizeAxes = Axes.X,
+                                    Depth = float.MinValue,
+                                    Height = MENU_HEIGHT,
+                                    Children = new Drawable[]
                                     {
-                                        Anchor = Anchor.CentreLeft,
-                                        Origin = Anchor.CentreLeft,
-                                        RelativeSizeAxes = Axes.Both,
-                                        Items = new[]
+                                        new EditorMenuBar
                                         {
-                                            new MenuItem(CommonStrings.MenuBarFile)
+                                            Anchor = Anchor.CentreLeft,
+                                            Origin = Anchor.CentreLeft,
+                                            RelativeSizeAxes = Axes.Both,
+                                            Items = new[]
                                             {
-                                                Items = new OsuMenuItem[]
+                                                new MenuItem(CommonStrings.MenuBarFile)
                                                 {
-                                                    new EditorMenuItem(Web.CommonStrings.ButtonsSave, MenuItemType.Standard, () => Save()),
-                                                    new EditorMenuItem(CommonStrings.Export, MenuItemType.Standard, () => skins.ExportCurrentSkin()) { Action = { Disabled = !RuntimeInfo.IsDesktop } },
-                                                    new OsuMenuItemSpacer(),
-                                                    new EditorMenuItem(CommonStrings.RevertToDefault, MenuItemType.Destructive, () => dialogOverlay?.Push(new RevertConfirmDialog(revert))),
-                                                    new OsuMenuItemSpacer(),
-                                                    new EditorMenuItem(CommonStrings.Exit, MenuItemType.Standard, () => skinEditorOverlay?.Hide()),
+                                                    Items = new OsuMenuItem[]
+                                                    {
+                                                        new EditorMenuItem(Web.CommonStrings.ButtonsSave, MenuItemType.Standard, () => Save()),
+                                                        new EditorMenuItem(CommonStrings.Export, MenuItemType.Standard, () => skins.ExportCurrentSkin()) { Action = { Disabled = !RuntimeInfo.IsDesktop } },
+                                                        new OsuMenuItemSpacer(),
+                                                        new EditorMenuItem(CommonStrings.RevertToDefault, MenuItemType.Destructive, () => dialogOverlay?.Push(new RevertConfirmDialog(revert))),
+                                                        new OsuMenuItemSpacer(),
+                                                        new EditorMenuItem(CommonStrings.Exit, MenuItemType.Standard, () => skinEditorOverlay?.Hide()),
+                                                    },
                                                 },
-                                            },
-                                            new MenuItem(CommonStrings.MenuBarEdit)
-                                            {
-                                                Items = new OsuMenuItem[]
+                                                new MenuItem(CommonStrings.MenuBarEdit)
                                                 {
-                                                    undoMenuItem = new EditorMenuItem(CommonStrings.Undo, MenuItemType.Standard, Undo),
-                                                    redoMenuItem = new EditorMenuItem(CommonStrings.Redo, MenuItemType.Standard, Redo),
-                                                    new OsuMenuItemSpacer(),
-                                                    cutMenuItem = new EditorMenuItem(CommonStrings.Cut, MenuItemType.Standard, Cut),
-                                                    copyMenuItem = new EditorMenuItem(CommonStrings.Copy, MenuItemType.Standard, Copy),
-                                                    pasteMenuItem = new EditorMenuItem(CommonStrings.Paste, MenuItemType.Standard, Paste),
-                                                    cloneMenuItem = new EditorMenuItem(CommonStrings.Clone, MenuItemType.Standard, Clone),
-                                                }
-                                            },
-                                        }
-                                    },
-                                    headerText = new OsuTextFlowContainer
-                                    {
-                                        TextAnchor = Anchor.TopRight,
-                                        Padding = new MarginPadding(5),
-                                        Anchor = Anchor.TopRight,
-                                        Origin = Anchor.TopRight,
-                                        AutoSizeAxes = Axes.X,
-                                        RelativeSizeAxes = Axes.Y,
+                                                    Items = new OsuMenuItem[]
+                                                    {
+                                                        undoMenuItem = new EditorMenuItem(CommonStrings.Undo, MenuItemType.Standard, Undo),
+                                                        redoMenuItem = new EditorMenuItem(CommonStrings.Redo, MenuItemType.Standard, Redo),
+                                                        new OsuMenuItemSpacer(),
+                                                        cutMenuItem = new EditorMenuItem(CommonStrings.Cut, MenuItemType.Standard, Cut),
+                                                        copyMenuItem = new EditorMenuItem(CommonStrings.Copy, MenuItemType.Standard, Copy),
+                                                        pasteMenuItem = new EditorMenuItem(CommonStrings.Paste, MenuItemType.Standard, Paste),
+                                                        cloneMenuItem = new EditorMenuItem(CommonStrings.Clone, MenuItemType.Standard, Clone),
+                                                    }
+                                                },
+                                            }
+                                        },
+                                        headerText = new OsuTextFlowContainer
+                                        {
+                                            TextAnchor = Anchor.TopRight,
+                                            Padding = new MarginPadding(5),
+                                            Anchor = Anchor.TopRight,
+                                            Origin = Anchor.TopRight,
+                                            AutoSizeAxes = Axes.X,
+                                            RelativeSizeAxes = Axes.Y,
+                                        },
                                     },
                                 },
                             },
-                        },
-                        new Drawable[]
-                        {
-                            new SkinEditorSceneLibrary
+                            new Drawable[]
                             {
-                                RelativeSizeAxes = Axes.X,
-                            },
-                        },
-                        new Drawable[]
-                        {
-                            new GridContainer
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                ColumnDimensions = new[]
+                                new SkinEditorSceneLibrary
                                 {
-                                    new Dimension(GridSizeMode.AutoSize),
-                                    new Dimension(),
-                                    new Dimension(GridSizeMode.AutoSize),
+                                    RelativeSizeAxes = Axes.X,
                                 },
-                                Content = new[]
+                            },
+                            new Drawable[]
+                            {
+                                new GridContainer
                                 {
-                                    new Drawable[]
+                                    RelativeSizeAxes = Axes.Both,
+                                    ColumnDimensions = new[]
+                                    {
+                                        new Dimension(GridSizeMode.AutoSize),
+                                        new Dimension(),
+                                        new Dimension(GridSizeMode.AutoSize),
+                                    },
+                                    Content = new[]
                                     {
-                                        componentsSidebar = new EditorSidebar(),
-                                        content = new Container
+                                        new Drawable[]
                                         {
-                                            Depth = float.MaxValue,
-                                            RelativeSizeAxes = Axes.Both,
-                                        },
-                                        settingsSidebar = new EditorSidebar(),
+                                            componentsSidebar = new EditorSidebar(),
+                                            content = new Container
+                                            {
+                                                Depth = float.MaxValue,
+                                                RelativeSizeAxes = Axes.Both,
+                                            },
+                                            settingsSidebar = new EditorSidebar(),
+                                        }
                                     }
                                 }
-                            }
-                        },
+                            },
+                        }
                     }
                 }
             };
@@ -330,7 +335,7 @@ void loadBlueprintContainer()
             }
         }
 
-        private void targetChanged(ValueChangedEvent<SkinComponentsContainerLookup?> target)
+        private void targetChanged(ValueChangedEvent<GlobalSkinnableContainerLookup?> target)
         {
             foreach (var toolbox in componentsSidebar.OfType<SkinComponentToolbox>())
                 toolbox.Expire();
@@ -360,7 +365,7 @@ private void targetChanged(ValueChangedEvent<SkinComponentsContainerLookup?> tar
                 {
                     Children = new Drawable[]
                     {
-                        new SettingsDropdown<SkinComponentsContainerLookup?>
+                        new SettingsDropdown<GlobalSkinnableContainerLookup?>
                         {
                             Items = availableTargets.Select(t => t.Lookup).Distinct(),
                             Current = selectedTarget,
@@ -421,6 +426,9 @@ private void skinChanged()
             if (targetContainer != null)
                 changeHandler = new SkinEditorChangeHandler(targetContainer);
             hasBegunMutating = true;
+
+            // Reload sidebar components.
+            selectedTarget.TriggerChange();
         }
 
         /// <summary>
@@ -469,18 +477,18 @@ private void populateSettings()
                 settingsSidebar.Add(new SkinSettingsToolbox(component));
         }
 
-        private IEnumerable<SkinComponentsContainer> availableTargets => targetScreen.ChildrenOfType<SkinComponentsContainer>();
+        private IEnumerable<SkinnableContainer> availableTargets => targetScreen.ChildrenOfType<SkinnableContainer>();
 
-        private SkinComponentsContainer? getFirstTarget() => availableTargets.FirstOrDefault();
+        private SkinnableContainer? getFirstTarget() => availableTargets.FirstOrDefault();
 
-        private SkinComponentsContainer? getTarget(SkinComponentsContainerLookup? target)
+        private SkinnableContainer? getTarget(GlobalSkinnableContainerLookup? target)
         {
             return availableTargets.FirstOrDefault(c => c.Lookup.Equals(target));
         }
 
         private void revert()
         {
-            SkinComponentsContainer[] targetContainers = availableTargets.ToArray();
+            SkinnableContainer[] targetContainers = availableTargets.ToArray();
 
             foreach (var t in targetContainers)
             {
@@ -552,7 +560,7 @@ private void save(Skin skin, bool userTriggered = true)
             if (targetScreen?.IsLoaded != true)
                 return;
 
-            SkinComponentsContainer[] targetContainers = availableTargets.ToArray();
+            SkinnableContainer[] targetContainers = availableTargets.ToArray();
 
             if (!targetContainers.All(c => c.ComponentsLoaded))
                 return;
@@ -597,7 +605,7 @@ public void DeleteItems(ISerialisableDrawable[] items)
 
         public void BringSelectionToFront()
         {
-            if (getTarget(selectedTarget.Value) is not SkinComponentsContainer target)
+            if (getTarget(selectedTarget.Value) is not SkinnableContainer target)
                 return;
 
             changeHandler?.BeginChange();
@@ -621,7 +629,7 @@ public void BringSelectionToFront()
 
         public void SendSelectionToBack()
         {
-            if (getTarget(selectedTarget.Value) is not SkinComponentsContainer target)
+            if (getTarget(selectedTarget.Value) is not SkinnableContainer target)
                 return;
 
             changeHandler?.BeginChange();
diff --git a/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs b/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
index 36b38543d11c..9fd28a1cad6a 100644
--- a/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
@@ -46,7 +46,6 @@ private void updateState()
 
         private Drawable[]? objectsInRotation;
 
-        private Vector2? defaultOrigin;
         private Dictionary<Drawable, float>? originalRotations;
         private Dictionary<Drawable, Vector2>? originalPositions;
 
@@ -60,7 +59,7 @@ public override void Begin()
             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 => d.ScreenSpaceDrawQuad.GetVertices().ToArray())).Centre;
 
             base.Begin();
         }
@@ -70,7 +69,7 @@ public override void Update(float rotation, Vector2? origin = null)
             if (objectsInRotation == null)
                 throw new InvalidOperationException($"Cannot {nameof(Update)} a rotate operation without calling {nameof(Begin)} first!");
 
-            Debug.Assert(originalRotations != null && originalPositions != null && defaultOrigin != null);
+            Debug.Assert(originalRotations != null && originalPositions != null && DefaultOrigin != null);
 
             if (objectsInRotation.Length == 1 && origin == null)
             {
@@ -79,7 +78,7 @@ public override void Update(float rotation, Vector2? origin = null)
                 return;
             }
 
-            var actualOrigin = origin ?? defaultOrigin.Value;
+            var actualOrigin = origin ?? DefaultOrigin.Value;
 
             foreach (var drawableItem in objectsInRotation)
             {
@@ -100,7 +99,7 @@ public override void Commit()
             objectsInRotation = null;
             originalPositions = null;
             originalRotations = null;
-            defaultOrigin = null;
+            DefaultOrigin = null;
 
             base.Commit();
         }
diff --git a/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs b/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs
index 4bfa7fba81f1..691576921255 100644
--- a/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs
@@ -67,13 +67,13 @@ public override void Begin()
 
             objectsInScale = selectedItems.Cast<Drawable>().ToDictionary(d => d, d => new OriginalDrawableState(d));
             OriginalSurroundingQuad = ToLocalSpace(GeometryUtils.GetSurroundingQuad(objectsInScale.SelectMany(d => d.Key.ScreenSpaceDrawQuad.GetVertices().ToArray())));
-            defaultOrigin = OriginalSurroundingQuad.Value.Centre;
+            defaultOrigin = ToLocalSpace(GeometryUtils.MinimumEnclosingCircle(objectsInScale.SelectMany(d => d.Key.ScreenSpaceDrawQuad.GetVertices().ToArray())).Item1);
 
             isFlippedX = false;
             isFlippedY = false;
         }
 
-        public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+        public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
         {
             if (objectsInScale == null)
                 throw new InvalidOperationException($"Cannot {nameof(Update)} a scale operation without calling {nameof(Begin)} first!");
diff --git a/osu.Game/Overlays/Toolbar/TransientUserStatisticsUpdateDisplay.cs b/osu.Game/Overlays/Toolbar/TransientUserStatisticsUpdateDisplay.cs
index c6f373d55f89..07c2e727740d 100644
--- a/osu.Game/Overlays/Toolbar/TransientUserStatisticsUpdateDisplay.cs
+++ b/osu.Game/Overlays/Toolbar/TransientUserStatisticsUpdateDisplay.cs
@@ -24,7 +24,7 @@ public partial class TransientUserStatisticsUpdateDisplay : CompositeDrawable
         public Bindable<UserStatisticsUpdate?> LatestUpdate { get; } = new Bindable<UserStatisticsUpdate?>();
 
         private Statistic<int> globalRank = null!;
-        private Statistic<decimal> pp = null!;
+        private Statistic<int> pp = null!;
 
         [BackgroundDependencyLoader]
         private void load(UserStatisticsWatcher? userStatisticsWatcher)
@@ -43,7 +43,7 @@ private void load(UserStatisticsWatcher? userStatisticsWatcher)
                 Children = new Drawable[]
                 {
                     globalRank = new Statistic<int>(UsersStrings.ShowRankGlobalSimple, @"#", Comparer<int>.Create((before, after) => before - after)),
-                    pp = new Statistic<decimal>(RankingsStrings.StatPerformance, string.Empty, Comparer<decimal>.Create((before, after) => Math.Sign(after - before))),
+                    pp = new Statistic<int>(RankingsStrings.StatPerformance, string.Empty, Comparer<int>.Create((before, after) => Math.Sign(after - before))),
                 }
             };
 
@@ -83,7 +83,7 @@ protected override void LoadComplete()
                 }
 
                 if (update.After.PP != null)
-                    pp.Display(update.Before.PP ?? update.After.PP.Value, Math.Abs((update.After.PP - update.Before.PP) ?? 0M), update.After.PP.Value);
+                    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);
 
                 this.Delay(5000).FadeOut(500, Easing.OutQuint);
             });
diff --git a/osu.Game/Overlays/Volume/VolumeControlReceptor.cs b/osu.Game/Overlays/Volume/VolumeControlReceptor.cs
index 4ddbc9dd4876..2e8d86d4c7fd 100644
--- a/osu.Game/Overlays/Volume/VolumeControlReceptor.cs
+++ b/osu.Game/Overlays/Volume/VolumeControlReceptor.cs
@@ -23,15 +23,15 @@ public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
             {
                 case GlobalAction.DecreaseVolume:
                 case GlobalAction.IncreaseVolume:
-                    ActionRequested?.Invoke(e.Action);
-                    return true;
+                    return ActionRequested?.Invoke(e.Action) == true;
 
                 case GlobalAction.ToggleMute:
                 case GlobalAction.NextVolumeMeter:
                 case GlobalAction.PreviousVolumeMeter:
                     if (!e.Repeat)
-                        ActionRequested?.Invoke(e.Action);
-                    return true;
+                        return ActionRequested?.Invoke(e.Action) == true;
+
+                    return false;
             }
 
             return false;
diff --git a/osu.Game/Overlays/VolumeOverlay.cs b/osu.Game/Overlays/VolumeOverlay.cs
index 0d801ff118ed..bb2ad6069522 100644
--- a/osu.Game/Overlays/VolumeOverlay.cs
+++ b/osu.Game/Overlays/VolumeOverlay.cs
@@ -110,14 +110,18 @@ public bool Adjust(GlobalAction action, float amount = 1, bool isPrecise = false
                     return true;
 
                 case GlobalAction.NextVolumeMeter:
-                    if (State.Value == Visibility.Visible)
-                        volumeMeters.SelectNext();
+                    if (State.Value != Visibility.Visible)
+                        return false;
+
+                    volumeMeters.SelectNext();
                     Show();
                     return true;
 
                 case GlobalAction.PreviousVolumeMeter:
-                    if (State.Value == Visibility.Visible)
-                        volumeMeters.SelectPrevious();
+                    if (State.Value != Visibility.Visible)
+                        return false;
+
+                    volumeMeters.SelectPrevious();
                     Show();
                     return true;
 
diff --git a/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs b/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs
index b9850a94a36e..7ed692ad3d20 100644
--- a/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs
+++ b/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs
@@ -195,22 +195,7 @@ public IEnumerable<TernaryButton> CreateTernaryButtons() => new[]
             new TernaryButton(DistanceSnapToggle, "Distance Snap", () => new SpriteIcon { Icon = OsuIcon.EditorDistanceSnap })
         };
 
-        protected override bool OnKeyDown(KeyDownEvent e)
-        {
-            if (e.Repeat)
-                return false;
-
-            handleToggleViaKey(e);
-            return base.OnKeyDown(e);
-        }
-
-        protected override void OnKeyUp(KeyUpEvent e)
-        {
-            handleToggleViaKey(e);
-            base.OnKeyUp(e);
-        }
-
-        private void handleToggleViaKey(KeyboardEvent key)
+        public void HandleToggleViaKey(KeyboardEvent key)
         {
             bool altPressed = key.AltPressed;
 
@@ -295,22 +280,36 @@ public virtual double DistanceToDuration(HitObject referenceObject, float distan
         public virtual double FindSnappedDuration(HitObject referenceObject, float distance)
             => beatSnapProvider.SnapTime(referenceObject.StartTime + DistanceToDuration(referenceObject, distance), referenceObject.StartTime) - referenceObject.StartTime;
 
-        public virtual float FindSnappedDistance(HitObject referenceObject, float distance)
+        public virtual float FindSnappedDistance(HitObject referenceObject, float distance, DistanceSnapTarget target)
         {
-            double startTime = referenceObject.StartTime;
+            double referenceTime;
+
+            switch (target)
+            {
+                case DistanceSnapTarget.Start:
+                    referenceTime = referenceObject.StartTime;
+                    break;
+
+                case DistanceSnapTarget.End:
+                    referenceTime = referenceObject.GetEndTime();
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(target), target, $"Unknown {nameof(DistanceSnapTarget)} value");
+            }
 
-            double actualDuration = startTime + DistanceToDuration(referenceObject, distance);
+            double actualDuration = referenceTime + DistanceToDuration(referenceObject, distance);
 
-            double snappedEndTime = beatSnapProvider.SnapTime(actualDuration, startTime);
+            double snappedTime = beatSnapProvider.SnapTime(actualDuration, referenceTime);
 
-            double beatLength = beatSnapProvider.GetBeatLengthAtTime(startTime);
+            double beatLength = beatSnapProvider.GetBeatLengthAtTime(referenceTime);
 
             // we don't want to exceed the actual duration and snap to a point in the future.
             // as we are snapping to beat length via SnapTime (which will round-to-nearest), check for snapping in the forward direction and reverse it.
-            if (snappedEndTime > actualDuration + 1)
-                snappedEndTime -= beatLength;
+            if (snappedTime > actualDuration + 1)
+                snappedTime -= beatLength;
 
-            return DurationToDistance(referenceObject, snappedEndTime - startTime);
+            return DurationToDistance(referenceObject, snappedTime - referenceTime);
         }
 
         #endregion
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index 085740d3eb1c..5effcc6f79de 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -364,7 +364,7 @@ protected override void Update()
         /// <remarks>
         /// A "select" tool is automatically added as the first tool.
         /// </remarks>
-        protected abstract IReadOnlyList<HitObjectCompositionTool> CompositionTools { get; }
+        protected abstract IReadOnlyList<CompositionTool> CompositionTools { get; }
 
         /// <summary>
         /// A collection of states which will be displayed to the user in the toolbox.
@@ -519,7 +519,7 @@ private void selectionChanged(object sender, NotifyCollectionChangedEventArgs ch
 
         private void setSelectTool() => toolboxCollection.Items.First().Select();
 
-        private void toolSelected(HitObjectCompositionTool tool)
+        private void toolSelected(CompositionTool tool)
         {
             BlueprintContainer.CurrentTool = tool;
 
diff --git a/osu.Game/Rulesets/Edit/HitObjectCompositionToolButton.cs b/osu.Game/Rulesets/Edit/HitObjectCompositionToolButton.cs
index ba566ff5c08e..641d60dbd344 100644
--- a/osu.Game/Rulesets/Edit/HitObjectCompositionToolButton.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectCompositionToolButton.cs
@@ -9,9 +9,9 @@ namespace osu.Game.Rulesets.Edit
 {
     public class HitObjectCompositionToolButton : RadioButton
     {
-        public HitObjectCompositionTool Tool { get; }
+        public CompositionTool Tool { get; }
 
-        public HitObjectCompositionToolButton(HitObjectCompositionTool tool, Action? action)
+        public HitObjectCompositionToolButton(CompositionTool tool, Action? action)
             : base(tool.Name, action, tool.CreateIcon)
         {
             Tool = tool;
diff --git a/osu.Game/Rulesets/Edit/HitObjectPlacementBlueprint.cs b/osu.Game/Rulesets/Edit/HitObjectPlacementBlueprint.cs
new file mode 100644
index 000000000000..760c7b09364b
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/HitObjectPlacementBlueprint.cs
@@ -0,0 +1,131 @@
+// 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.Threading;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Game.Audio;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Compose;
+
+namespace osu.Game.Rulesets.Edit
+{
+    /// <summary>
+    /// A blueprint which governs the creation of a new <see cref="HitObject"/> to actualisation.
+    /// </summary>
+    public abstract partial class HitObjectPlacementBlueprint : PlacementBlueprint
+    {
+        /// <summary>
+        /// Whether the sample bank should be taken from the previous hit object.
+        /// </summary>
+        public bool AutomaticBankAssignment { get; set; }
+
+        /// <summary>
+        /// Whether the sample addition bank should be taken from the previous hit objects.
+        /// </summary>
+        public bool AutomaticAdditionBankAssignment { get; set; }
+
+        /// <summary>
+        /// The <see cref="HitObject"/> that is being placed.
+        /// </summary>
+        public readonly HitObject HitObject;
+
+        [Resolved]
+        protected EditorClock EditorClock { get; private set; } = null!;
+
+        [Resolved]
+        private EditorBeatmap beatmap { get; set; } = null!;
+
+        private Bindable<double> startTimeBindable = null!;
+
+        private HitObject? getPreviousHitObject() => beatmap.HitObjects.TakeWhile(h => h.StartTime <= startTimeBindable.Value).LastOrDefault();
+
+        [Resolved]
+        private IPlacementHandler placementHandler { get; set; } = null!;
+
+        protected HitObjectPlacementBlueprint(HitObject hitObject)
+        {
+            HitObject = hitObject;
+
+            // adding the default hit sample should be the case regardless of the ruleset.
+            HitObject.Samples.Add(new HitSampleInfo(HitSampleInfo.HIT_NORMAL));
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            startTimeBindable = HitObject.StartTimeBindable.GetBoundCopy();
+            startTimeBindable.BindValueChanged(_ => ApplyDefaultsToHitObject(), true);
+        }
+
+        protected override void BeginPlacement(bool commitStart = false)
+        {
+            base.BeginPlacement(commitStart);
+
+            placementHandler.BeginPlacement(HitObject);
+        }
+
+        public override void EndPlacement(bool commit)
+        {
+            base.EndPlacement(commit);
+
+            placementHandler.EndPlacement(HitObject, IsValidForPlacement && commit);
+        }
+
+        /// <summary>
+        /// Updates the time and position of this <see cref="PlacementBlueprint"/> based on the provided snap information.
+        /// </summary>
+        /// <param name="result">The snap result information.</param>
+        public override void UpdateTimeAndPosition(SnapResult result)
+        {
+            if (PlacementActive == PlacementState.Waiting)
+            {
+                HitObject.StartTime = result.Time ?? EditorClock.CurrentTime;
+
+                if (HitObject is IHasComboInformation comboInformation)
+                    comboInformation.UpdateComboInformation(getPreviousHitObject() as IHasComboInformation);
+            }
+
+            var lastHitObject = getPreviousHitObject();
+            var lastHitNormal = lastHitObject?.Samples?.FirstOrDefault(o => o.Name == HitSampleInfo.HIT_NORMAL);
+
+            if (AutomaticAdditionBankAssignment)
+            {
+                // Inherit the addition bank from the previous hit object
+                // If there is no previous addition, inherit from the normal sample
+                var lastAddition = lastHitObject?.Samples?.FirstOrDefault(o => o.Name != HitSampleInfo.HIT_NORMAL) ?? lastHitNormal;
+
+                if (lastAddition != null)
+                    HitObject.Samples = HitObject.Samples.Select(s => s.Name != HitSampleInfo.HIT_NORMAL ? s.With(newBank: lastAddition.Bank) : s).ToList();
+            }
+
+            if (lastHitNormal != null)
+            {
+                if (AutomaticBankAssignment)
+                    // Inherit the bank from the previous hit object
+                    HitObject.Samples = HitObject.Samples.Select(s => s.Name == HitSampleInfo.HIT_NORMAL ? s.With(newBank: lastHitNormal.Bank) : s).ToList();
+
+                // Inherit the volume from the previous hit object
+                HitObject.Samples = HitObject.Samples.Select(s => s.With(newVolume: lastHitNormal.Volume)).ToList();
+            }
+
+            if (HitObject is IHasRepeats hasRepeats)
+            {
+                // Make sure all the node samples are identical to the hit object's samples
+                for (int i = 0; i < hasRepeats.NodeSamples.Count; i++)
+                    hasRepeats.NodeSamples[i] = HitObject.Samples.Select(o => o.With()).ToList();
+            }
+        }
+
+        /// <summary>
+        /// Invokes <see cref="Objects.HitObject.ApplyDefaults(ControlPointInfo,IBeatmapDifficultyInfo,CancellationToken)"/>,
+        /// refreshing <see cref="Objects.HitObject.NestedHitObjects"/> and parameters for the <see cref="HitObject"/>.
+        /// </summary>
+        protected void ApplyDefaultsToHitObject() => HitObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.Difficulty);
+    }
+}
diff --git a/osu.Game/Rulesets/Edit/IDistanceSnapProvider.cs b/osu.Game/Rulesets/Edit/IDistanceSnapProvider.cs
index 380038eadf06..17fae9e8b215 100644
--- a/osu.Game/Rulesets/Edit/IDistanceSnapProvider.cs
+++ b/osu.Game/Rulesets/Edit/IDistanceSnapProvider.cs
@@ -58,10 +58,17 @@ public interface IDistanceSnapProvider
         /// </summary>
         /// <param name="referenceObject">An object to be used as a reference point for this operation.</param>
         /// <param name="distance">The distance to convert.</param>
+        /// <param name="target">Whether the distance measured should be from the start or the end of <paramref name="referenceObject"/>.</param>
         /// <returns>
         /// A value that represents <paramref name="distance"/> snapped to the closest beat of the timing point.
         /// The distance will always be less than or equal to the provided <paramref name="distance"/>.
         /// </returns>
-        float FindSnappedDistance(HitObject referenceObject, float distance);
+        float FindSnappedDistance(HitObject referenceObject, float distance, DistanceSnapTarget target);
+    }
+
+    public enum DistanceSnapTarget
+    {
+        Start,
+        End,
     }
 }
diff --git a/osu.Game/Rulesets/Edit/PlacementBlueprint.cs b/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
index d01b7a64b721..d2a54e8e03a2 100644
--- a/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
+++ b/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
@@ -1,29 +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.Linq;
-using System.Threading;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
-using osu.Game.Audio;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Screens.Edit;
-using osu.Game.Screens.Edit.Compose;
 using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Rulesets.Edit
 {
     /// <summary>
-    /// A blueprint which governs the creation of a new <see cref="HitObject"/> to actualisation.
+    /// A blueprint which governs the placement of something.
     /// </summary>
     public abstract partial class PlacementBlueprint : CompositeDrawable, IKeyBindingHandler<GlobalAction>
     {
@@ -32,34 +22,6 @@ public abstract partial class PlacementBlueprint : CompositeDrawable, IKeyBindin
         /// </summary>
         public PlacementState PlacementActive { get; private set; }
 
-        /// <summary>
-        /// Whether the sample bank should be taken from the previous hit object.
-        /// </summary>
-        public bool AutomaticBankAssignment { get; set; }
-
-        /// <summary>
-        /// Whether the sample addition bank should be taken from the previous hit objects.
-        /// </summary>
-        public bool AutomaticAdditionBankAssignment { get; set; }
-
-        /// <summary>
-        /// The <see cref="HitObject"/> that is being placed.
-        /// </summary>
-        public readonly HitObject HitObject;
-
-        [Resolved]
-        protected EditorClock EditorClock { get; private set; } = null!;
-
-        [Resolved]
-        private EditorBeatmap beatmap { get; set; } = null!;
-
-        private Bindable<double> startTimeBindable = null!;
-
-        private HitObject? getPreviousHitObject() => beatmap.HitObjects.TakeWhile(h => h.StartTime <= startTimeBindable.Value).LastOrDefault();
-
-        [Resolved]
-        private IPlacementHandler placementHandler { get; set; } = null!;
-
         /// <summary>
         /// Whether this blueprint is currently in a state that can be committed.
         /// </summary>
@@ -69,13 +31,8 @@ public abstract partial class PlacementBlueprint : CompositeDrawable, IKeyBindin
         /// </remarks>
         protected virtual bool IsValidForPlacement => true;
 
-        protected PlacementBlueprint(HitObject hitObject)
+        protected PlacementBlueprint()
         {
-            HitObject = hitObject;
-
-            // adding the default hit sample should be the case regardless of the ruleset.
-            HitObject.Samples.Add(new HitSampleInfo(HitSampleInfo.HIT_NORMAL));
-
             RelativeSizeAxes = Axes.Both;
 
             // This is required to allow the blueprint's position to be updated via OnMouseMove/Handle
@@ -83,30 +40,22 @@ protected PlacementBlueprint(HitObject hitObject)
             AlwaysPresent = true;
         }
 
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            startTimeBindable = HitObject.StartTimeBindable.GetBoundCopy();
-            startTimeBindable.BindValueChanged(_ => ApplyDefaultsToHitObject(), true);
-        }
-
         /// <summary>
-        /// Signals that the placement of <see cref="HitObject"/> has started.
+        /// Signals that the placement has started.
         /// </summary>
-        /// <param name="commitStart">Whether this call is committing a value for HitObject.StartTime and continuing with further adjustments.</param>
-        protected void BeginPlacement(bool commitStart = false)
+        /// <param name="commitStart">Whether this call is committing a value and continuing with further adjustments.</param>
+        protected virtual void BeginPlacement(bool commitStart = false)
         {
-            placementHandler.BeginPlacement(HitObject);
             if (commitStart)
                 PlacementActive = PlacementState.Active;
         }
 
         /// <summary>
         /// Signals that the placement of <see cref="HitObject"/> has finished.
-        /// This will destroy this <see cref="PlacementBlueprint"/>, and add the HitObject.StartTime to the <see cref="Beatmap"/>.
+        /// This will destroy this <see cref="PlacementBlueprint"/>, and commit the changes.
         /// </summary>
-        /// <param name="commit">Whether the object should be committed. Note that a commit may fail if <see cref="IsValidForPlacement"/> is <c>false</c>.</param>
-        public void EndPlacement(bool commit)
+        /// <param name="commit">Whether the changes should be committed. Note that a commit may fail if <see cref="IsValidForPlacement"/> is <c>false</c>.</param>
+        public virtual void EndPlacement(bool commit)
         {
             switch (PlacementActive)
             {
@@ -119,10 +68,17 @@ public void EndPlacement(bool commit)
                     break;
             }
 
-            placementHandler.EndPlacement(HitObject, IsValidForPlacement && commit);
             PlacementActive = PlacementState.Finished;
         }
 
+        /// <summary>
+        /// Updates the time and position of this <see cref="PlacementBlueprint"/> based on the provided snap information.
+        /// </summary>
+        /// <param name="result">The snap result information.</param>
+        public virtual void UpdateTimeAndPosition(SnapResult result)
+        {
+        }
+
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
             if (PlacementActive == PlacementState.Waiting)
@@ -130,10 +86,6 @@ public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
 
             switch (e.Action)
             {
-                case GlobalAction.Select:
-                    EndPlacement(true);
-                    return true;
-
                 case GlobalAction.Back:
                     EndPlacement(false);
                     return true;
@@ -147,57 +99,6 @@ public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
         {
         }
 
-        /// <summary>
-        /// Updates the time and position of this <see cref="PlacementBlueprint"/> based on the provided snap information.
-        /// </summary>
-        /// <param name="result">The snap result information.</param>
-        public virtual void UpdateTimeAndPosition(SnapResult result)
-        {
-            if (PlacementActive == PlacementState.Waiting)
-            {
-                HitObject.StartTime = result.Time ?? EditorClock.CurrentTime;
-
-                if (HitObject is IHasComboInformation comboInformation)
-                    comboInformation.UpdateComboInformation(getPreviousHitObject() as IHasComboInformation);
-            }
-
-            var lastHitObject = getPreviousHitObject();
-            var lastHitNormal = lastHitObject?.Samples?.FirstOrDefault(o => o.Name == HitSampleInfo.HIT_NORMAL);
-
-            if (AutomaticAdditionBankAssignment)
-            {
-                // Inherit the addition bank from the previous hit object
-                // If there is no previous addition, inherit from the normal sample
-                var lastAddition = lastHitObject?.Samples?.FirstOrDefault(o => o.Name != HitSampleInfo.HIT_NORMAL) ?? lastHitNormal;
-
-                if (lastAddition != null)
-                    HitObject.Samples = HitObject.Samples.Select(s => s.Name != HitSampleInfo.HIT_NORMAL ? s.With(newBank: lastAddition.Bank) : s).ToList();
-            }
-
-            if (lastHitNormal != null)
-            {
-                if (AutomaticBankAssignment)
-                    // Inherit the bank from the previous hit object
-                    HitObject.Samples = HitObject.Samples.Select(s => s.Name == HitSampleInfo.HIT_NORMAL ? s.With(newBank: lastHitNormal.Bank) : s).ToList();
-
-                // Inherit the volume from the previous hit object
-                HitObject.Samples = HitObject.Samples.Select(s => s.With(newVolume: lastHitNormal.Volume)).ToList();
-            }
-
-            if (HitObject is IHasRepeats hasRepeats)
-            {
-                // Make sure all the node samples are identical to the hit object's samples
-                for (int i = 0; i < hasRepeats.NodeSamples.Count; i++)
-                    hasRepeats.NodeSamples[i] = HitObject.Samples.Select(o => o.With()).ToList();
-            }
-        }
-
-        /// <summary>
-        /// Invokes <see cref="Objects.HitObject.ApplyDefaults(ControlPointInfo,IBeatmapDifficultyInfo,CancellationToken)"/>,
-        /// refreshing <see cref="Objects.HitObject.NestedHitObjects"/> and parameters for the <see cref="HitObject"/>.
-        /// </summary>
-        protected void ApplyDefaultsToHitObject() => HitObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.Difficulty);
-
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
         protected override bool Handle(UIEvent e)
diff --git a/osu.Game/Rulesets/Edit/Tools/HitObjectCompositionTool.cs b/osu.Game/Rulesets/Edit/Tools/CompositionTool.cs
similarity index 84%
rename from osu.Game/Rulesets/Edit/Tools/HitObjectCompositionTool.cs
rename to osu.Game/Rulesets/Edit/Tools/CompositionTool.cs
index ba1dc817bb19..f509302daa90 100644
--- a/osu.Game/Rulesets/Edit/Tools/HitObjectCompositionTool.cs
+++ b/osu.Game/Rulesets/Edit/Tools/CompositionTool.cs
@@ -6,13 +6,13 @@
 
 namespace osu.Game.Rulesets.Edit.Tools
 {
-    public abstract class HitObjectCompositionTool
+    public abstract class CompositionTool
     {
         public readonly string Name;
 
         public LocalisableString TooltipText { get; init; }
 
-        protected HitObjectCompositionTool(string name)
+        protected CompositionTool(string name)
         {
             Name = name;
         }
diff --git a/osu.Game/Rulesets/Edit/Tools/SelectTool.cs b/osu.Game/Rulesets/Edit/Tools/SelectTool.cs
index a272e9f480d9..7f8889bfcaec 100644
--- a/osu.Game/Rulesets/Edit/Tools/SelectTool.cs
+++ b/osu.Game/Rulesets/Edit/Tools/SelectTool.cs
@@ -9,7 +9,7 @@
 
 namespace osu.Game.Rulesets.Edit.Tools
 {
-    public class SelectTool : HitObjectCompositionTool
+    public class SelectTool : CompositionTool
     {
         public SelectTool()
             : base("Select")
@@ -18,6 +18,6 @@ public SelectTool()
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.EditorSelect };
 
-        public override PlacementBlueprint CreatePlacementBlueprint() => null;
+        public override HitObjectPlacementBlueprint CreatePlacementBlueprint() => null;
     }
 }
diff --git a/osu.Game/Rulesets/Judgements/DrawableJudgement.cs b/osu.Game/Rulesets/Judgements/DrawableJudgement.cs
index 8c326ecf4946..3e70f52ee7ce 100644
--- a/osu.Game/Rulesets/Judgements/DrawableJudgement.cs
+++ b/osu.Game/Rulesets/Judgements/DrawableJudgement.cs
@@ -163,7 +163,7 @@ private void prepareDrawables()
             if (JudgementBody != null)
                 RemoveInternal(JudgementBody, true);
 
-            AddInternal(JudgementBody = new SkinnableDrawable(new GameplaySkinComponentLookup<HitResult>(type), _ =>
+            AddInternal(JudgementBody = new SkinnableDrawable(new SkinComponentLookup<HitResult>(type), _ =>
                 CreateDefaultJudgement(type), confineMode: ConfineMode.NoScaling));
 
             JudgementBody.OnSkinChanged += () =>
diff --git a/osu.Game/Rulesets/Mods/Mod.cs b/osu.Game/Rulesets/Mods/Mod.cs
index b9a937b1a2fb..1b21216235d8 100644
--- a/osu.Game/Rulesets/Mods/Mod.cs
+++ b/osu.Game/Rulesets/Mods/Mod.cs
@@ -266,8 +266,7 @@ public void CopyCommonSettingsFrom(Mod source)
 
                 // TODO: special case for handling number types
 
-                PropertyInfo property = targetSetting.GetType().GetProperty(nameof(Bindable<bool>.Value))!;
-                property.SetValue(targetSetting, property.GetValue(sourceSetting));
+                BindableValueAccessor.SetValue(targetSetting, BindableValueAccessor.GetValue(sourceSetting));
             }
         }
 
diff --git a/osu.Game/Rulesets/Mods/ModBarrelRoll.cs b/osu.Game/Rulesets/Mods/ModBarrelRoll.cs
index 0c301d293f4b..4f90496308d1 100644
--- a/osu.Game/Rulesets/Mods/ModBarrelRoll.cs
+++ b/osu.Game/Rulesets/Mods/ModBarrelRoll.cs
@@ -40,9 +40,11 @@ public abstract class ModBarrelRoll<TObject> : Mod, IUpdatableByPlayfield, IAppl
 
         public override string SettingDescription => $"{SpinSpeed.Value:N2} rpm {Direction.Value.GetDescription().ToLowerInvariant()}";
 
+        private PlayfieldAdjustmentContainer playfieldAdjustmentContainer = null!;
+
         public void Update(Playfield playfield)
         {
-            playfield.Rotation = CurrentRotation = (Direction.Value == RotationDirection.Counterclockwise ? -1 : 1) * 360 * (float)(playfield.Time.Current / 60000 * SpinSpeed.Value);
+            playfieldAdjustmentContainer.Rotation = CurrentRotation = (Direction.Value == RotationDirection.Counterclockwise ? -1 : 1) * 360 * (float)(playfield.Time.Current / 60000 * SpinSpeed.Value);
         }
 
         public void ApplyToDrawableRuleset(DrawableRuleset<TObject> drawableRuleset)
@@ -52,7 +54,9 @@ public void ApplyToDrawableRuleset(DrawableRuleset<TObject> drawableRuleset)
             var playfieldSize = drawableRuleset.Playfield.DrawSize;
             float minSide = MathF.Min(playfieldSize.X, playfieldSize.Y);
             float maxSide = MathF.Max(playfieldSize.X, playfieldSize.Y);
-            drawableRuleset.Playfield.Scale = new Vector2(minSide / maxSide);
+
+            playfieldAdjustmentContainer = drawableRuleset.PlayfieldAdjustmentContainer;
+            playfieldAdjustmentContainer.Scale = new Vector2(minSide / maxSide);
         }
     }
 }
diff --git a/osu.Game/Rulesets/Mods/ModFlashlight.cs b/osu.Game/Rulesets/Mods/ModFlashlight.cs
index c924915bd086..64c193d25f2d 100644
--- a/osu.Game/Rulesets/Mods/ModFlashlight.cs
+++ b/osu.Game/Rulesets/Mods/ModFlashlight.cs
@@ -83,8 +83,6 @@ public virtual void ApplyToDrawableRuleset(DrawableRuleset<T> drawableRuleset)
 
             flashlight.RelativeSizeAxes = Axes.Both;
             flashlight.Colour = Color4.Black;
-            // Flashlight mods should always draw above any other mod adding overlays.
-            flashlight.Depth = float.MinValue;
 
             flashlight.Combo.BindTo(Combo);
             flashlight.GetPlayfieldScale = () => drawableRuleset.Playfield.Scale;
@@ -95,6 +93,9 @@ public virtual void ApplyToDrawableRuleset(DrawableRuleset<T> drawableRuleset)
                 // workaround for 1px gaps on the edges of the playfield which would sometimes show with "gameplay" screen scaling active.
                 Padding = new MarginPadding(-1),
                 Child = flashlight,
+                // Flashlight mods should always draw above any other mod adding overlays.
+                // NegativeInfinity is not used to allow one more thing drawn on top (used in replay analysis overlay in osu!).
+                Depth = float.MinValue,
             });
         }
 
diff --git a/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs b/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs
index 8e6ffa20cc1b..c518a3e8b28d 100644
--- a/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs
@@ -351,13 +351,19 @@ private IEnumerable<ArraySegment<PathControlPoint>> convertPoints(PathType type,
             {
                 int endPointLength = endPoint == null ? 0 : 1;
 
-                if (vertices.Length + endPointLength != 3)
-                    type = PathType.BEZIER;
-                else if (isLinear(points[0], points[1], endPoint ?? points[2]))
+                if (FormatVersion < LegacyBeatmapEncoder.FIRST_LAZER_VERSION)
                 {
-                    // osu-stable special-cased colinear perfect curves to a linear path
-                    type = PathType.LINEAR;
+                    if (vertices.Length + endPointLength != 3)
+                        type = PathType.BEZIER;
+                    else if (isLinear(points[0], points[1], endPoint ?? points[2]))
+                    {
+                        // osu-stable special-cased colinear perfect curves to a linear path
+                        type = PathType.LINEAR;
+                    }
                 }
+                else if (vertices.Length + endPointLength > 3)
+                    // Lazer supports perfect curves with less than 3 points and colinear points
+                    type = PathType.BEZIER;
             }
 
             // The first control point must have a definite type.
diff --git a/osu.Game/Rulesets/Objects/SliderPathExtensions.cs b/osu.Game/Rulesets/Objects/SliderPathExtensions.cs
index c03d3646da55..a631274f74f0 100644
--- a/osu.Game/Rulesets/Objects/SliderPathExtensions.cs
+++ b/osu.Game/Rulesets/Objects/SliderPathExtensions.cs
@@ -17,7 +17,7 @@ public static class SliderPathExtensions
         public static void SnapTo<THitObject>(this THitObject hitObject, IDistanceSnapProvider? snapProvider)
             where THitObject : HitObject, IHasPath
         {
-            hitObject.Path.ExpectedDistance.Value = snapProvider?.FindSnappedDistance(hitObject, (float)hitObject.Path.CalculatedDistance) ?? hitObject.Path.CalculatedDistance;
+            hitObject.Path.ExpectedDistance.Value = snapProvider?.FindSnappedDistance(hitObject, (float)hitObject.Path.CalculatedDistance, DistanceSnapTarget.Start) ?? hitObject.Path.CalculatedDistance;
         }
 
         /// <summary>
diff --git a/osu.Game/Rulesets/Ruleset.cs b/osu.Game/Rulesets/Ruleset.cs
index fb0e225c94f2..5af1fd386c3a 100644
--- a/osu.Game/Rulesets/Ruleset.cs
+++ b/osu.Game/Rulesets/Ruleset.cs
@@ -401,5 +401,10 @@ public virtual IEnumerable<SetupSection> CreateEditorSetupSections() =>
             new DifficultySection(),
             new ColoursSection(),
         ];
+
+        /// <summary>
+        /// Can be overridden to avoid showing scroll speed changes in the editor.
+        /// </summary>
+        public virtual bool EditorShowScrollSpeed => true;
     }
 }
diff --git a/osu.Game/Rulesets/Scoring/ScoreProcessor.cs b/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
index 44ddb8c1878e..9752918dfbea 100644
--- a/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
+++ b/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
@@ -181,6 +181,8 @@ public Dictionary<HitResult, int> MaximumStatistics
             }
         }
 
+        public IReadOnlyDictionary<HitResult, int> Statistics => ScoreResultCounts;
+
         private bool beatmapApplied;
 
         protected readonly Dictionary<HitResult, int> ScoreResultCounts = new Dictionary<HitResult, int>();
diff --git a/osu.Game/Rulesets/UI/ModIcon.cs b/osu.Game/Rulesets/UI/ModIcon.cs
index 5d9fafd60ce9..5237425075ac 100644
--- a/osu.Game/Rulesets/UI/ModIcon.cs
+++ b/osu.Game/Rulesets/UI/ModIcon.cs
@@ -11,6 +11,7 @@
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Localisation;
+using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
@@ -139,7 +140,7 @@ private void load(TextureStore textures)
                             Origin = Anchor.Centre,
                             Anchor = Anchor.Centre,
                             Alpha = 0,
-                            Font = OsuFont.Numeric.With(null, 22f),
+                            Font = OsuFont.Numeric.With(size: 22f, weight: FontWeight.Black),
                             UseFullGlyphHeight = false,
                             Text = mod.Acronym
                         },
@@ -204,7 +205,7 @@ private void updateExtendedInformation()
 
         private void updateColour()
         {
-            modAcronym.Colour = modIcon.Colour = OsuColour.Gray(84);
+            modAcronym.Colour = modIcon.Colour = Interpolation.ValueAt<Colour4>(0.1f, Colour4.Black, backgroundColour, 0, 1);
 
             extendedText.Colour = background.Colour = Selected.Value ? backgroundColour.Lighten(0.2f) : backgroundColour;
             extendedBackground.Colour = Selected.Value ? backgroundColour.Darken(2.4f) : backgroundColour.Darken(2.8f);
diff --git a/osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs b/osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs
index d23658ac3304..ba3a9bd48341 100644
--- a/osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs
+++ b/osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs
@@ -64,8 +64,6 @@ public abstract partial class DrawableScrollingRuleset<TObject> : DrawableRulese
             MaxValue = time_span_max
         };
 
-        ScrollVisualisationMethod IDrawableScrollingRuleset.VisualisationMethod => VisualisationMethod;
-
         /// <summary>
         /// Whether the player can change <see cref="TimeRange"/>.
         /// </summary>
diff --git a/osu.Game/Rulesets/UI/Scrolling/IDrawableScrollingRuleset.cs b/osu.Game/Rulesets/UI/Scrolling/IDrawableScrollingRuleset.cs
index b348a220093f..27531492d6d6 100644
--- a/osu.Game/Rulesets/UI/Scrolling/IDrawableScrollingRuleset.cs
+++ b/osu.Game/Rulesets/UI/Scrolling/IDrawableScrollingRuleset.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Configuration;
-
 namespace osu.Game.Rulesets.UI.Scrolling
 {
     /// <summary>
@@ -10,8 +8,6 @@ namespace osu.Game.Rulesets.UI.Scrolling
     /// </summary>
     public interface IDrawableScrollingRuleset
     {
-        ScrollVisualisationMethod VisualisationMethod { get; }
-
         IScrollingInfo ScrollingInfo { get; }
     }
 }
diff --git a/osu.Game/Screens/Edit/BindableBeatDivisor.cs b/osu.Game/Screens/Edit/BindableBeatDivisor.cs
index 4b0726658fe4..bd9c9bab9a88 100644
--- a/osu.Game/Screens/Edit/BindableBeatDivisor.cs
+++ b/osu.Game/Screens/Edit/BindableBeatDivisor.cs
@@ -16,6 +16,9 @@ public class BindableBeatDivisor : BindableInt
     {
         public static readonly int[] PREDEFINED_DIVISORS = { 1, 2, 3, 4, 6, 8, 12, 16 };
 
+        public const int MINIMUM_DIVISOR = 1;
+        public const int MAXIMUM_DIVISOR = 64;
+
         public Bindable<BeatDivisorPresetCollection> ValidDivisors { get; } = new Bindable<BeatDivisorPresetCollection>(BeatDivisorPresetCollection.COMMON);
 
         public BindableBeatDivisor(int value = 1)
@@ -30,8 +33,12 @@ public BindableBeatDivisor(int value = 1)
         /// </summary>
         /// <param name="divisor">The intended divisor.</param>
         /// <param name="preferKnownPresets">Forces changing the valid divisors to a known preset.</param>
-        public void SetArbitraryDivisor(int divisor, bool preferKnownPresets = false)
+        /// <returns>Whether the divisor was successfully set.</returns>
+        public bool SetArbitraryDivisor(int divisor, bool preferKnownPresets = false)
         {
+            if (divisor < MINIMUM_DIVISOR || divisor > MAXIMUM_DIVISOR)
+                return false;
+
             // If the current valid divisor range doesn't contain the proposed value, attempt to find one which does.
             if (preferKnownPresets || !ValidDivisors.Value.Presets.Contains(divisor))
             {
@@ -44,6 +51,7 @@ public void SetArbitraryDivisor(int divisor, bool preferKnownPresets = false)
             }
 
             Value = divisor;
+            return true;
         }
 
         private void updateBindableProperties()
@@ -137,18 +145,18 @@ public static Vector2 GetSize(int beatDivisor)
             {
                 case 1:
                 case 2:
-                    return new Vector2(0.6f, 0.9f);
+                    return new Vector2(1, 0.9f);
 
                 case 3:
                 case 4:
-                    return new Vector2(0.5f, 0.8f);
+                    return new Vector2(0.8f, 0.8f);
 
                 case 6:
                 case 8:
-                    return new Vector2(0.4f, 0.7f);
+                    return new Vector2(0.8f, 0.7f);
 
                 default:
-                    return new Vector2(0.3f, 0.6f);
+                    return new Vector2(0.8f, 0.6f);
             }
         }
 
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BreakPart.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BreakPart.cs
index 17e0d47676c8..be3a7b726854 100644
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BreakPart.cs
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BreakPart.cs
@@ -69,8 +69,9 @@ private void load(OsuColour colours)
                 RelativePositionAxes = Axes.X;
                 RelativeSizeAxes = Axes.Both;
 
-                InternalChild = new Circle { RelativeSizeAxes = Axes.Both };
-                Colour = colours.Gray6;
+                InternalChild = new Box { RelativeSizeAxes = Axes.Both };
+                Colour = colours.Gray5;
+                Alpha = 0.4f;
             }
 
             public LocalisableString TooltipText => $"{breakPeriod.StartTime.ToEditorFormattedString()} - {breakPeriod.EndTime.ToEditorFormattedString()} break time";
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/EffectPointVisualisation.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/EffectPointVisualisation.cs
deleted file mode 100644
index 17fedb933a89..000000000000
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/EffectPointVisualisation.cs
+++ /dev/null
@@ -1,125 +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 osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Localisation;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Extensions;
-using osu.Game.Graphics;
-
-namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
-{
-    public partial class EffectPointVisualisation : CompositeDrawable, IControlPointVisualisation
-    {
-        private readonly EffectControlPoint effect;
-        private Bindable<bool> kiai = null!;
-
-        [Resolved]
-        private EditorBeatmap beatmap { get; set; } = null!;
-
-        [Resolved]
-        private OsuColour colours { get; set; } = null!;
-
-        public EffectPointVisualisation(EffectControlPoint point)
-        {
-            RelativePositionAxes = Axes.Both;
-            RelativeSizeAxes = Axes.Y;
-
-            effect = point;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            kiai = effect.KiaiModeBindable.GetBoundCopy();
-            kiai.BindValueChanged(_ => refreshDisplay(), true);
-        }
-
-        private EffectControlPoint? nextControlPoint;
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            // Due to the limitations of ControlPointInfo, it's impossible to know via event flow when the next kiai point has changed.
-            // This is due to the fact that an EffectPoint can be added to an existing group. We would need to bind to ItemAdded on *every*
-            // future group to track this.
-            //
-            // I foresee this being a potential performance issue on beatmaps with many control points, so let's limit how often we check
-            // for changes. ControlPointInfo needs a refactor to make this flow better, but it should do for now.
-            Scheduler.AddDelayed(() =>
-            {
-                EffectControlPoint? next = null;
-
-                for (int i = 0; i < beatmap.ControlPointInfo.EffectPoints.Count; i++)
-                {
-                    var point = beatmap.ControlPointInfo.EffectPoints[i];
-
-                    if (point.Time > effect.Time)
-                    {
-                        next = point;
-                        break;
-                    }
-                }
-
-                if (!ReferenceEquals(nextControlPoint, next))
-                {
-                    nextControlPoint = next;
-                    refreshDisplay();
-                }
-            }, 100, true);
-        }
-
-        private void refreshDisplay()
-        {
-            ClearInternal();
-
-            AddInternal(new ControlPointVisualisation(effect));
-
-            if (!kiai.Value)
-                return;
-
-            // handle kiai duration
-            // eventually this will be simpler when we have control points with durations.
-            if (nextControlPoint != null)
-            {
-                RelativeSizeAxes = Axes.Both;
-                Origin = Anchor.TopLeft;
-
-                Width = (float)(nextControlPoint.Time - effect.Time);
-
-                AddInternal(new KiaiVisualisation(effect.Time, nextControlPoint.Time)
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.CentreLeft,
-                    Height = 0.4f,
-                    Depth = float.MaxValue,
-                    Colour = colours.Purple1,
-                });
-            }
-        }
-
-        private partial class KiaiVisualisation : Circle, IHasTooltip
-        {
-            private readonly double startTime;
-            private readonly double endTime;
-
-            public KiaiVisualisation(double startTime, double endTime)
-            {
-                this.startTime = startTime;
-                this.endTime = endTime;
-            }
-
-            public LocalisableString TooltipText => $"{startTime.ToEditorFormattedString()} - {endTime.ToEditorFormattedString()} kiai time";
-        }
-
-        // kiai sections display duration, so are required to be visualised.
-        public bool IsVisuallyRedundant(ControlPoint other) => other is EffectControlPoint otherEffect && effect.KiaiMode == otherEffect.KiaiMode;
-    }
-}
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/GroupVisualisation.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/GroupVisualisation.cs
index b872c3725c15..0dd945805b80 100644
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/GroupVisualisation.cs
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/GroupVisualisation.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -15,6 +16,8 @@ public partial class GroupVisualisation : CompositeDrawable
 
         private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
 
+        private bool showScrollSpeed;
+
         public GroupVisualisation(ControlPointGroup group)
         {
             RelativePositionAxes = Axes.X;
@@ -24,8 +27,13 @@ public GroupVisualisation(ControlPointGroup group)
 
             Group = group;
             X = (float)group.Time;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(EditorBeatmap beatmap)
+        {
+            showScrollSpeed = beatmap.BeatmapInfo.Ruleset.CreateInstance().EditorShowScrollSpeed;
 
-            // Run in constructor so IsRedundant calls can work correctly.
             controlPoints.BindTo(Group.ControlPoints);
             controlPoints.BindCollectionChanged((_, _) =>
             {
@@ -47,8 +55,15 @@ public GroupVisualisation(ControlPointGroup group)
                             });
                             break;
 
-                        case EffectControlPoint effect:
-                            AddInternal(new EffectPointVisualisation(effect));
+                        case EffectControlPoint:
+                            if (!showScrollSpeed)
+                                return;
+
+                            AddInternal(new ControlPointVisualisation(point)
+                            {
+                                // importantly, override the x position being set since we do that above.
+                                X = 0,
+                            });
                             break;
                     }
                 }
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/KiaiPart.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/KiaiPart.cs
new file mode 100644
index 000000000000..ee44df8598d0
--- /dev/null
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/KiaiPart.cs
@@ -0,0 +1,123 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Localisation;
+using osu.Game.Extensions;
+using osu.Game.Graphics;
+
+namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
+{
+    /// <summary>
+    /// The part of the timeline that displays kiai sections in the song.
+    /// </summary>
+    public partial class KiaiPart : TimelinePart
+    {
+        private DrawablePool<KiaiVisualisation> pool = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddInternal(pool = new DrawablePool<KiaiVisualisation>(10));
+        }
+
+        protected override void LoadBeatmap(EditorBeatmap beatmap)
+        {
+            base.LoadBeatmap(beatmap);
+            EditorBeatmap.ControlPointInfo.ControlPointsChanged += updateParts;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            updateParts();
+        }
+
+        private void updateParts() => Scheduler.AddOnce(() =>
+        {
+            Clear(disposeChildren: false);
+
+            double? startTime = null;
+
+            foreach (var effectPoint in EditorBeatmap.ControlPointInfo.EffectPoints)
+            {
+                if (startTime.HasValue)
+                {
+                    if (effectPoint.KiaiMode)
+                        continue;
+
+                    var section = new KiaiSection
+                    {
+                        StartTime = startTime.Value,
+                        EndTime = effectPoint.Time
+                    };
+
+                    Add(pool.Get(v => v.Section = section));
+
+                    startTime = null;
+                }
+                else
+                {
+                    if (!effectPoint.KiaiMode)
+                        continue;
+
+                    startTime = effectPoint.Time;
+                }
+            }
+
+            // last effect point has kiai enabled, kiai should last until the end of the map
+            if (startTime.HasValue)
+            {
+                Add(pool.Get(v => v.Section = new KiaiSection
+                {
+                    StartTime = startTime.Value,
+                    EndTime = Content.RelativeChildSize.X
+                }));
+            }
+        });
+
+        private partial class KiaiVisualisation : PoolableDrawable, IHasTooltip
+        {
+            private KiaiSection section;
+
+            public KiaiSection Section
+            {
+                set
+                {
+                    section = value;
+
+                    X = (float)value.StartTime;
+                    Width = (float)value.Duration;
+                }
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                RelativePositionAxes = Axes.X;
+                RelativeSizeAxes = Axes.Both;
+                Anchor = Anchor.CentreLeft;
+                Origin = Anchor.CentreLeft;
+                Height = 0.2f;
+                AddInternal(new FastCircle
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colours.Purple1
+                });
+            }
+
+            public LocalisableString TooltipText => $"{section.StartTime.ToEditorFormattedString()} - {section.EndTime.ToEditorFormattedString()} kiai time";
+        }
+
+        private readonly struct KiaiSection
+        {
+            public double StartTime { get; init; }
+            public double EndTime { get; init; }
+            public double Duration => EndTime - StartTime;
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs
index a495442c1d46..c01481e840a7 100644
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs
@@ -59,6 +59,18 @@ private void load(OverlayColourProvider colourProvider)
                     RelativeSizeAxes = Axes.Both,
                     Height = 0.4f,
                 },
+                new BreakPart
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new KiaiPart
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                },
                 new ControlPointPart
                 {
                     Anchor = Anchor.Centre,
@@ -73,13 +85,6 @@ private void load(OverlayColourProvider colourProvider)
                     RelativeSizeAxes = Axes.Both,
                     Height = 0.4f
                 },
-                new BreakPart
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.Both,
-                    Height = 0.15f
-                },
                 new MarkerPart { RelativeSizeAxes = Axes.Both },
             };
         }
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/PointVisualisation.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/PointVisualisation.cs
index 9c16f457f751..6c9af5396471 100644
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/PointVisualisation.cs
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/PointVisualisation.cs
@@ -9,7 +9,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations
     /// <summary>
     /// Represents a singular point on a timeline part.
     /// </summary>
-    public partial class PointVisualisation : Circle
+    public partial class PointVisualisation : FastCircle
     {
         public readonly double StartTime;
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs b/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
index 1d8266d610e8..43a2abe4c441 100644
--- a/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
@@ -330,14 +330,14 @@ protected override void LoadComplete()
 
             private void setPresetsFromTextBoxEntry()
             {
-                if (!int.TryParse(divisorTextBox.Text, out int divisor) || divisor < 1 || divisor > 64)
+                if (!int.TryParse(divisorTextBox.Text, out int divisor) || !BeatDivisor.SetArbitraryDivisor(divisor))
                 {
+                    // the text either didn't parse as a divisor, or the divisor was not set due to being out of range.
+                    // force a state update to reset the text box's value to the last sane value.
                     updateState();
                     return;
                 }
 
-                BeatDivisor.SetArbitraryDivisor(divisor);
-
                 this.HidePopover();
             }
 
@@ -526,7 +526,7 @@ public Tick(int divisor, bool alwaysDisplayed)
                     AlwaysDisplayed = alwaysDisplayed;
                     Divisor = divisor;
 
-                    Size = new Vector2(6f, 18) * BindableBeatDivisor.GetSize(divisor);
+                    Size = new Vector2(4, 18) * BindableBeatDivisor.GetSize(divisor);
                     Alpha = alwaysDisplayed ? 1 : 0;
 
                     InternalChild = new Box { RelativeSizeAxes = Axes.Both };
diff --git a/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs
index c66be9060515..30c1258f93b0 100644
--- a/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs
@@ -196,6 +196,11 @@ protected override bool OnDragStart(DragStartEvent e)
 
             DragBox.HandleDrag(e);
             DragBox.Show();
+
+            selectionBeforeDrag.Clear();
+            if (e.ControlPressed)
+                selectionBeforeDrag.UnionWith(SelectedItems);
+
             return true;
         }
 
@@ -217,6 +222,7 @@ protected override void OnDragEnd(DragEndEvent e)
             }
 
             DragBox.Hide();
+            selectionBeforeDrag.Clear();
         }
 
         protected override void Update()
@@ -227,7 +233,7 @@ protected override void Update()
             {
                 lastDragEvent.Target = this;
                 DragBox.HandleDrag(lastDragEvent);
-                UpdateSelectionFromDragBox();
+                UpdateSelectionFromDragBox(selectionBeforeDrag);
             }
         }
 
@@ -426,7 +432,7 @@ bool runForBlueprint(SelectionBlueprint<T> blueprint)
         private bool endClickSelection(MouseButtonEvent e)
         {
             // If already handled a selection, double-click, or drag, we don't want to perform a mouse up / click action.
-            if (clickSelectionHandled || doubleClickHandled || isDraggingBlueprint) return true;
+            if (clickSelectionHandled || doubleClickHandled || isDraggingBlueprint || wasDragStarted) return true;
 
             if (e.Button != MouseButton.Left) return false;
 
@@ -442,7 +448,7 @@ private bool endClickSelection(MouseButtonEvent e)
                 return false;
             }
 
-            if (!wasDragStarted && selectedBlueprintAlreadySelectedOnMouseDown && SelectedItems.Count == 1)
+            if (selectedBlueprintAlreadySelectedOnMouseDown && SelectedItems.Count == 1)
             {
                 // If a click occurred and was handled by the currently selected blueprint but didn't result in a drag,
                 // cycle between other blueprints which are also under the cursor.
@@ -472,7 +478,7 @@ private bool endClickSelection(MouseButtonEvent e)
         /// <summary>
         /// Select all blueprints in a selection area specified by <see cref="DragBox"/>.
         /// </summary>
-        protected virtual void UpdateSelectionFromDragBox()
+        protected virtual void UpdateSelectionFromDragBox(HashSet<T> selectionBeforeDrag)
         {
             var quad = DragBox.Box.ScreenSpaceDrawQuad;
 
@@ -482,7 +488,7 @@ protected virtual void UpdateSelectionFromDragBox()
                 {
                     case SelectionState.Selected:
                         // Selection is preserved even after blueprint becomes dead.
-                        if (!quad.Contains(blueprint.ScreenSpaceSelectionPoint))
+                        if (!quad.Contains(blueprint.ScreenSpaceSelectionPoint) && !selectionBeforeDrag.Contains(blueprint.Item))
                             blueprint.Deselect();
                         break;
 
@@ -535,6 +541,8 @@ protected virtual void OnBlueprintDeselected(SelectionBlueprint<T> blueprint)
         /// </summary>
         private bool wasDragStarted;
 
+        private readonly HashSet<T> selectionBeforeDrag = new HashSet<T>();
+
         /// <summary>
         /// Attempts to begin the movement of any selected blueprints.
         /// </summary>
diff --git a/osu.Game/Screens/Edit/Compose/Components/CircularDistanceSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/CircularDistanceSnapGrid.cs
index 92fe52148c06..bd750dac76cf 100644
--- a/osu.Game/Screens/Edit/Compose/Components/CircularDistanceSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/CircularDistanceSnapGrid.cs
@@ -59,7 +59,7 @@ protected override void CreateContent()
             // Picture the scenario where the user has just placed an object on a 1/2 snap, then changes to
             // 1/3 snap and expects to be able to place the next object on a valid 1/3 snap, regardless of the
             // fact that the 1/2 snap reference object is not valid for 1/3 snapping.
-            float offset = SnapProvider.FindSnappedDistance(ReferenceObject, 0);
+            float offset = SnapProvider.FindSnappedDistance(ReferenceObject, 0, DistanceSnapTarget.End);
 
             for (int i = 0; i < requiredCircles; i++)
             {
@@ -104,7 +104,7 @@ public override (Vector2 position, double time) GetSnappedPosition(Vector2 posit
                 ? SnapProvider.DurationToDistance(ReferenceObject, editorClock.CurrentTime - ReferenceObject.GetEndTime())
                 // When interacting with the resolved snap provider, the distance spacing multiplier should first be removed
                 // to allow for snapping at a non-multiplied ratio.
-                : SnapProvider.FindSnappedDistance(ReferenceObject, travelLength / distanceSpacingMultiplier);
+                : SnapProvider.FindSnappedDistance(ReferenceObject, travelLength / distanceSpacingMultiplier, DistanceSnapTarget.End);
 
             double snappedTime = StartTime + SnapProvider.DistanceToDuration(ReferenceObject, snappedDistance);
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
index 9f2fff9ca307..76e35a35c6c6 100644
--- a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
@@ -41,6 +41,8 @@ public partial class ComposeBlueprintContainer : EditorBlueprintContainer
 
         public PlacementBlueprint CurrentPlacement { get; private set; }
 
+        public HitObjectPlacementBlueprint CurrentHitObjectPlacement => CurrentPlacement as HitObjectPlacementBlueprint;
+
         [Resolved(canBeNull: true)]
         private EditorScreenWithTimeline editorScreen { get; set; }
 
@@ -168,13 +170,13 @@ private void nudgeSelection(Vector2 delta)
 
         private void updatePlacementNewCombo()
         {
-            if (CurrentPlacement?.HitObject is IHasComboInformation c)
+            if (CurrentHitObjectPlacement?.HitObject is IHasComboInformation c)
                 c.NewCombo = NewCombo.Value == TernaryState.True;
         }
 
         private void updatePlacementSamples()
         {
-            if (CurrentPlacement == null) return;
+            if (CurrentHitObjectPlacement == null) return;
 
             foreach (var kvp in SelectionHandler.SelectionSampleStates)
                 sampleChanged(kvp.Key, kvp.Value.Value);
@@ -188,9 +190,9 @@ private void updatePlacementSamples()
 
         private void sampleChanged(string sampleName, TernaryState state)
         {
-            if (CurrentPlacement == null) return;
+            if (CurrentHitObjectPlacement == null) return;
 
-            var samples = CurrentPlacement.HitObject.Samples;
+            var samples = CurrentHitObjectPlacement.HitObject.Samples;
 
             var existingSample = samples.FirstOrDefault(s => s.Name == sampleName);
 
@@ -203,29 +205,29 @@ private void sampleChanged(string sampleName, TernaryState state)
 
                 case TernaryState.True:
                     if (existingSample == null)
-                        samples.Add(CurrentPlacement.HitObject.CreateHitSampleInfo(sampleName));
+                        samples.Add(CurrentHitObjectPlacement.HitObject.CreateHitSampleInfo(sampleName));
                     break;
             }
         }
 
         private void bankChanged(string bankName, TernaryState state)
         {
-            if (CurrentPlacement == null) return;
+            if (CurrentHitObjectPlacement == null) return;
 
             if (bankName == EditorSelectionHandler.HIT_BANK_AUTO)
-                CurrentPlacement.AutomaticBankAssignment = state == TernaryState.True;
+                CurrentHitObjectPlacement.AutomaticBankAssignment = state == TernaryState.True;
             else if (state == TernaryState.True)
-                CurrentPlacement.HitObject.Samples = CurrentPlacement.HitObject.Samples.Select(s => s.Name == HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
+                CurrentHitObjectPlacement.HitObject.Samples = CurrentHitObjectPlacement.HitObject.Samples.Select(s => s.Name == HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
         }
 
         private void additionBankChanged(string bankName, TernaryState state)
         {
-            if (CurrentPlacement == null) return;
+            if (CurrentHitObjectPlacement == null) return;
 
             if (bankName == EditorSelectionHandler.HIT_BANK_AUTO)
-                CurrentPlacement.AutomaticAdditionBankAssignment = state == TernaryState.True;
+                CurrentHitObjectPlacement.AutomaticAdditionBankAssignment = state == TernaryState.True;
             else if (state == TernaryState.True)
-                CurrentPlacement.HitObject.Samples = CurrentPlacement.HitObject.Samples.Select(s => s.Name != HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
+                CurrentHitObjectPlacement.HitObject.Samples = CurrentHitObjectPlacement.HitObject.Samples.Select(s => s.Name != HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
         }
 
         public readonly Bindable<TernaryState> NewCombo = new Bindable<TernaryState> { Description = "New Combo" };
@@ -390,12 +392,12 @@ private void removePlacement()
             CurrentPlacement = null;
         }
 
-        private HitObjectCompositionTool currentTool;
+        private CompositionTool currentTool;
 
         /// <summary>
         /// The current placement tool.
         /// </summary>
-        public HitObjectCompositionTool CurrentTool
+        public CompositionTool CurrentTool
         {
             get => currentTool;
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs
index 8aa2fa9f4575..7003d632caa8 100644
--- a/osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs
@@ -155,7 +155,7 @@ protected Color4 GetColourForIndexFromPlacement(int placementIndex)
         {
             var timingPoint = Beatmap.ControlPointInfo.TimingPointAt(StartTime);
             double beatLength = timingPoint.BeatLength / beatDivisor.Value;
-            int beatIndex = (int)Math.Round((StartTime - timingPoint.Time) / beatLength);
+            int beatIndex = (int)Math.Floor((StartTime - timingPoint.Time) / beatLength);
 
             var colour = BindableBeatDivisor.GetColourFor(BindableBeatDivisor.GetDivisorForBeatIndex(beatIndex + placementIndex + 1, beatDivisor.Value), Colours);
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
index df8c0176e1a6..769240839aa4 100644
--- a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
@@ -315,7 +315,7 @@ bool hasRelevantBank(HitObject hitObject)
 
             EditorBeatmap.PerformOnSelection(h =>
             {
-                if (h.Samples.Where(o => o.Name == HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName))
+                if (hasRelevantBank(h))
                     return;
 
                 h.Samples = h.Samples.Select(s => s.Name == HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
@@ -394,10 +394,8 @@ public void AddHitSample(string sampleName)
             EditorBeatmap.PerformOnSelection(h =>
             {
                 // Make sure there isn't already an existing sample
-                if (h.Samples.Any(s => s.Name == sampleName))
-                    return;
-
-                h.Samples.Add(h.CreateHitSampleInfo(sampleName));
+                if (h.Samples.All(s => s.Name != sampleName))
+                    h.Samples.Add(h.CreateHitSampleInfo(sampleName));
 
                 if (h is IHasRepeats hasRepeats)
                 {
diff --git a/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
index e576ac1e49d9..cbdf02488a0d 100644
--- a/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
@@ -2,15 +2,17 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Layout;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
-    public abstract partial class PositionSnapGrid : CompositeDrawable
+    public abstract partial class PositionSnapGrid : BufferedContainer
     {
         /// <summary>
         /// The position of the origin of this <see cref="PositionSnapGrid"/> in local coordinates.
@@ -20,7 +22,10 @@ public abstract partial class PositionSnapGrid : CompositeDrawable
         protected readonly LayoutValue GridCache = new LayoutValue(Invalidation.RequiredParentSizeToFit);
 
         protected PositionSnapGrid()
+            : base(cachedFrameBuffer: true)
         {
+            BackgroundColour = Color4.White.Opacity(0);
+
             StartPosition.BindValueChanged(_ => GridCache.Invalidate());
 
             AddLayout(GridCache);
@@ -30,7 +35,8 @@ protected override void Update()
         {
             base.Update();
 
-            if (GridCache.IsValid) return;
+            if (GridCache.IsValid)
+                return;
 
             ClearInternal();
 
@@ -38,6 +44,7 @@ protected override void Update()
                 CreateContent();
 
             GridCache.Validate();
+            ForceRedraw();
         }
 
         protected abstract void CreateContent();
@@ -53,7 +60,6 @@ protected void GenerateOutline(Vector2 drawSize)
                 {
                     Colour = Colour4.White,
                     Alpha = 0.3f,
-                    Origin = Anchor.CentreLeft,
                     RelativeSizeAxes = Axes.X,
                     Height = lineWidth,
                     Y = 0,
@@ -62,28 +68,26 @@ protected void GenerateOutline(Vector2 drawSize)
                 {
                     Colour = Colour4.White,
                     Alpha = 0.3f,
-                    Origin = Anchor.CentreLeft,
+                    Origin = Anchor.BottomLeft,
+                    Anchor = Anchor.BottomLeft,
                     RelativeSizeAxes = Axes.X,
-                    Height = lineWidth,
-                    Y = drawSize.Y,
+                    Height = lineWidth
                 },
                 new Box
                 {
                     Colour = Colour4.White,
                     Alpha = 0.3f,
-                    Origin = Anchor.TopCentre,
                     RelativeSizeAxes = Axes.Y,
-                    Width = lineWidth,
-                    X = 0,
+                    Width = lineWidth
                 },
                 new Box
                 {
                     Colour = Colour4.White,
                     Alpha = 0.3f,
-                    Origin = Anchor.TopCentre,
+                    Origin = Anchor.TopRight,
+                    Anchor = Anchor.TopRight,
                     RelativeSizeAxes = Axes.Y,
-                    Width = lineWidth,
-                    X = drawSize.X,
+                    Width = lineWidth
                 },
             });
         }
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs
index 0cc8a8273f15..d685fe74b0d3 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs
@@ -2,6 +2,7 @@
 // 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;
@@ -284,8 +285,12 @@ private SelectionBoxButton addButton(IconUsage icon, string tooltip, Action acti
                 Action = action
             };
 
+            button.OperationStarted += freezeButtonPosition;
+            button.HoverLost += unfreezeButtonPosition;
+
             button.OperationStarted += operationStarted;
             button.OperationEnded += operationEnded;
+
             buttons.Add(button);
 
             return button;
@@ -357,9 +362,35 @@ private void operationStarted()
                 OperationStarted?.Invoke();
         }
 
-        private void ensureButtonsOnScreen()
+        private Vector2? frozenButtonsPosition;
+
+        private void freezeButtonPosition()
+        {
+            frozenButtonsPosition = buttons.ScreenSpaceDrawQuad.TopLeft;
+        }
+
+        private void unfreezeButtonPosition()
         {
-            buttons.Position = Vector2.Zero;
+            if (frozenButtonsPosition != null)
+            {
+                frozenButtonsPosition = null;
+                ensureButtonsOnScreen(true);
+            }
+        }
+
+        private void ensureButtonsOnScreen(bool animated = false)
+        {
+            if (frozenButtonsPosition != null)
+            {
+                buttons.Anchor = Anchor.TopLeft;
+                buttons.Origin = Anchor.TopLeft;
+
+                buttons.Position = ToLocalSpace(frozenButtonsPosition.Value) - new Vector2(button_padding);
+                return;
+            }
+
+            if (!animated && buttons.Transforms.Any())
+                return;
 
             var thisQuad = ScreenSpaceDrawQuad;
 
@@ -374,24 +405,51 @@ private void ensureButtonsOnScreen()
 
             float minHeight = buttons.ScreenSpaceDrawQuad.Height;
 
+            Anchor targetAnchor;
+            Anchor targetOrigin;
+            Vector2 targetPosition = Vector2.Zero;
+
             if (topExcess < minHeight && bottomExcess < minHeight)
             {
-                buttons.Anchor = Anchor.BottomCentre;
-                buttons.Origin = Anchor.BottomCentre;
-                buttons.Y = Math.Min(0, ToLocalSpace(Parent!.ScreenSpaceDrawQuad.BottomLeft).Y - DrawHeight);
+                targetAnchor = Anchor.BottomCentre;
+                targetOrigin = Anchor.BottomCentre;
+                targetPosition.Y = Math.Min(0, ToLocalSpace(Parent!.ScreenSpaceDrawQuad.BottomLeft).Y - DrawHeight);
             }
             else if (topExcess > bottomExcess)
             {
-                buttons.Anchor = Anchor.TopCentre;
-                buttons.Origin = Anchor.BottomCentre;
+                targetAnchor = Anchor.TopCentre;
+                targetOrigin = Anchor.BottomCentre;
             }
             else
             {
-                buttons.Anchor = Anchor.BottomCentre;
-                buttons.Origin = Anchor.TopCentre;
+                targetAnchor = Anchor.BottomCentre;
+                targetOrigin = Anchor.TopCentre;
             }
 
-            buttons.X += ToLocalSpace(thisQuad.TopLeft - new Vector2(Math.Min(0, leftExcess)) + new Vector2(Math.Min(0, rightExcess))).X;
+            targetPosition.X += ToLocalSpace(thisQuad.TopLeft - new Vector2(Math.Min(0, leftExcess)) + new Vector2(Math.Min(0, rightExcess))).X;
+
+            if (animated)
+            {
+                var originalPosition = ToLocalSpace(buttons.ScreenSpaceDrawQuad.TopLeft);
+
+                buttons.Origin = targetOrigin;
+                buttons.Anchor = targetAnchor;
+                buttons.Position = targetPosition;
+
+                var newPosition = ToLocalSpace(buttons.ScreenSpaceDrawQuad.TopLeft);
+
+                var delta = newPosition - originalPosition;
+
+                buttons.Position -= delta;
+
+                buttons.MoveTo(targetPosition, 300, Easing.OutQuint);
+            }
+            else
+            {
+                buttons.Anchor = targetAnchor;
+                buttons.Origin = targetOrigin;
+                buttons.Position = targetPosition;
+            }
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxButton.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxButton.cs
index 6108d44c81b0..e355add40bfc 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxButton.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxButton.cs
@@ -21,6 +21,8 @@ public sealed partial class SelectionBoxButton : SelectionBoxControl, IHasToolti
 
         public Action? Action;
 
+        public event Action? HoverLost;
+
         public SelectionBoxButton(IconUsage iconUsage, string tooltip)
         {
             this.iconUsage = iconUsage;
@@ -61,6 +63,13 @@ protected override void UpdateHoverState()
             icon.FadeColour(!IsHeld && IsHovered ? Color4.White : Color4.Black, TRANSFORM_DURATION, Easing.OutQuint);
         }
 
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+
+            HoverLost?.Invoke();
+        }
+
         public LocalisableString TooltipText { get; }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs
index c62e0e0d4161..03d600bfa26e 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs
@@ -77,6 +77,8 @@ protected override void OnDrag(DragEvent e)
         {
             base.OnDrag(e);
 
+            if (rotationHandler == null || !rotationHandler.OperationInProgress.Value) return;
+
             rawCumulativeRotation += convertDragEventToAngleOfRotation(e);
 
             applyRotation(shouldSnap: e.ShiftPressed);
@@ -113,9 +115,11 @@ protected override void OnDragEnd(DragEndEvent e)
 
         private float convertDragEventToAngleOfRotation(DragEvent e)
         {
-            // Adjust coordinate system to the center of SelectionBox
-            float startAngle = MathF.Atan2(e.LastMousePosition.Y - selectionBox.DrawHeight / 2, e.LastMousePosition.X - selectionBox.DrawWidth / 2);
-            float endAngle = MathF.Atan2(e.MousePosition.Y - selectionBox.DrawHeight / 2, e.MousePosition.X - selectionBox.DrawWidth / 2);
+            // Adjust coordinate system to the center of the selection
+            Vector2 center = selectionBox.ToLocalSpace(rotationHandler!.ToScreenSpace(rotationHandler!.DefaultOrigin!.Value));
+
+            float startAngle = MathF.Atan2(e.LastMousePosition.Y - center.Y, e.LastMousePosition.X - center.X);
+            float endAngle = MathF.Atan2(e.MousePosition.Y - center.Y, e.MousePosition.X - center.X);
 
             return (endAngle - startAngle) * 180 / MathF.PI;
         }
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxScaleHandle.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxScaleHandle.cs
index 7b0943c1d0cf..3b7e29cf3dc6 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxScaleHandle.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxScaleHandle.cs
@@ -50,14 +50,14 @@ protected override void OnDrag(DragEvent e)
 
             rawScale = convertDragEventToScaleMultiplier(e);
 
-            applyScale(shouldLockAspectRatio: isCornerAnchor(originalAnchor) && e.ShiftPressed);
+            applyScale(shouldLockAspectRatio: isCornerAnchor(originalAnchor) && e.ShiftPressed, useDefaultOrigin: e.AltPressed);
         }
 
         protected override bool OnKeyDown(KeyDownEvent e)
         {
             if (IsDragged)
             {
-                applyScale(shouldLockAspectRatio: isCornerAnchor(originalAnchor) && e.ShiftPressed);
+                applyScale(shouldLockAspectRatio: isCornerAnchor(originalAnchor) && e.ShiftPressed, useDefaultOrigin: e.AltPressed);
                 return true;
             }
 
@@ -69,7 +69,7 @@ protected override void OnKeyUp(KeyUpEvent e)
             base.OnKeyUp(e);
 
             if (IsDragged)
-                applyScale(shouldLockAspectRatio: isCornerAnchor(originalAnchor) && e.ShiftPressed);
+                applyScale(shouldLockAspectRatio: isCornerAnchor(originalAnchor) && e.ShiftPressed, useDefaultOrigin: e.AltPressed);
         }
 
         protected override void OnDragEnd(DragEndEvent e)
@@ -100,13 +100,13 @@ private void adjustScaleFromAnchor(ref Vector2 scale)
             if ((originalAnchor & Anchor.y0) > 0) scale.Y = -scale.Y;
         }
 
-        private void applyScale(bool shouldLockAspectRatio)
+        private void applyScale(bool shouldLockAspectRatio, bool useDefaultOrigin = false)
         {
             var newScale = shouldLockAspectRatio
                 ? new Vector2((rawScale.X + rawScale.Y) * 0.5f)
                 : rawScale;
 
-            var scaleOrigin = originalAnchor.Opposite().PositionOnQuad(scaleHandler!.OriginalSurroundingQuad!.Value);
+            Vector2? scaleOrigin = useDefaultOrigin ? null : originalAnchor.Opposite().PositionOnQuad(scaleHandler!.OriginalSurroundingQuad!.Value);
             scaleHandler!.Update(newScale, scaleOrigin, getAdjustAxis());
         }
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
index 532daaf7fa03..af3b3d64890f 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
@@ -13,7 +13,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
     public partial class SelectionRotationHandler : Component
     {
         /// <summary>
-        /// Whether there is any ongoing scale operation right now.
+        /// Whether there is any ongoing rotation operation right now.
         /// </summary>
         public Bindable<bool> OperationInProgress { get; private set; } = new BindableBool();
 
@@ -27,6 +27,12 @@ public partial class SelectionRotationHandler : Component
         /// </summary>
         public Bindable<bool> CanRotateAroundPlayfieldOrigin { get; private set; } = new BindableBool();
 
+        /// <summary>
+        /// Implementation-defined origin point to rotate around when no explicit origin is provided.
+        /// This field is only assigned during a rotation operation.
+        /// </summary>
+        public Vector2? DefaultOrigin { get; protected set; }
+
         /// <summary>
         /// Performs a single, instant, atomic rotation operation.
         /// </summary>
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
index c91362219c79..177de9df3307 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
@@ -52,10 +52,11 @@ public partial class SelectionScaleHandler : Component
         /// If the default <see langword="null"/> value is supplied, a sane implementation-defined default will be used.
         /// </param>
         /// <param name="adjustAxis">The axes to adjust the scale in.</param>
-        public void ScaleSelection(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+        /// <param name="axisRotation">The rotation of the axes in degrees.</param>
+        public void ScaleSelection(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
         {
             Begin();
-            Update(scale, origin, adjustAxis);
+            Update(scale, origin, adjustAxis, axisRotation);
             Commit();
         }
 
@@ -91,7 +92,8 @@ public virtual void Begin()
         /// If the default <see langword="null"/> value is supplied, a sane implementation-defined default will be used.
         /// </param>
         /// <param name="adjustAxis">The axes to adjust the scale in.</param>
-        public virtual void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+        /// <param name="axisRotation">The rotation of the axes in degrees.</param>
+        public virtual void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
         {
         }
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/CentreMarker.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/CentreMarker.cs
index 7d8622905cda..c63dfdfb559d 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/CentreMarker.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/CentreMarker.cs
@@ -2,9 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Overlays;
@@ -14,32 +12,28 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
     public partial class CentreMarker : CompositeDrawable
     {
-        private const float triangle_width = 8;
-
-        private const float bar_width = 1.6f;
-
-        public CentreMarker()
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colours)
         {
+            const float triangle_width = 8;
+            const float bar_width = 2f;
+
             RelativeSizeAxes = Axes.Y;
-            Size = new Vector2(triangle_width, 1);
 
             Anchor = Anchor.TopCentre;
             Origin = Anchor.TopCentre;
-        }
 
-        [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colours)
-        {
+            Size = new Vector2(triangle_width, 1);
+
             InternalChildren = new Drawable[]
             {
-                new Box
+                new Circle
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Y,
                     Width = bar_width,
-                    Blending = BlendingParameters.Additive,
-                    Colour = ColourInfo.GradientVertical(colours.Colour2.Opacity(0.6f), colours.Colour2.Opacity(0)),
+                    Colour = colours.Colour2,
                 },
                 new Triangle
                 {
@@ -47,6 +41,15 @@ private void load(OverlayColourProvider colours)
                     Origin = Anchor.BottomCentre,
                     Size = new Vector2(triangle_width, triangle_width * 0.8f),
                     Scale = new Vector2(1, -1),
+                    EdgeSmoothness = new Vector2(1, 0),
+                    Colour = colours.Colour2,
+                },
+                new Triangle
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    Size = new Vector2(triangle_width, triangle_width * 0.8f),
+                    Scale = new Vector2(1, 1),
                     Colour = colours.Colour2,
                 },
             };
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/NodeSamplePointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/NodeSamplePointPiece.cs
index 9cc1268db7ab..46e1ee2193b1 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/NodeSamplePointPiece.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/NodeSamplePointPiece.cs
@@ -22,6 +22,12 @@ public NodeSamplePointPiece(HitObject hitObject, int nodeIndex)
             NodeIndex = nodeIndex;
         }
 
+        protected override double GetTime()
+        {
+            var hasRepeats = (IHasRepeats)HitObject;
+            return HitObject.StartTime + hasRepeats.Duration * NodeIndex / hasRepeats.SpanCount();
+        }
+
         protected override IList<HitSampleInfo> GetSamples()
         {
             var hasRepeats = (IHasRepeats)HitObject;
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
index c391bbd19032..627609055769 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
@@ -14,6 +14,7 @@
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
+using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
@@ -33,6 +34,12 @@ public partial class SamplePointPiece : HitObjectPointPiece, IHasPopover
     {
         public readonly HitObject HitObject;
 
+        [Resolved]
+        private EditorClock? editorClock { get; set; }
+
+        [Resolved]
+        private Editor? editor { get; set; }
+
         public SamplePointPiece(HitObject hitObject)
         {
             HitObject = hitObject;
@@ -43,11 +50,32 @@ public SamplePointPiece(HitObject hitObject)
 
         protected override Color4 GetRepresentingColour(OsuColour colours) => AlternativeColor ? colours.Pink2 : colours.Pink1;
 
+        protected virtual double GetTime() => HitObject is IHasRepeats r ? HitObject.StartTime + r.Duration / r.SpanCount() / 2 : HitObject.StartTime;
+
         [BackgroundDependencyLoader]
         private void load()
         {
             HitObject.DefaultsApplied += _ => updateText();
             updateText();
+
+            if (editor != null)
+                editor.ShowSampleEditPopoverRequested += onShowSampleEditPopoverRequested;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (editor != null)
+                editor.ShowSampleEditPopoverRequested -= onShowSampleEditPopoverRequested;
+        }
+
+        private void onShowSampleEditPopoverRequested(double time)
+        {
+            if (!Precision.AlmostEquals(time, GetTime())) return;
+
+            editorClock?.SeekSmoothlyTo(GetTime());
+            this.ShowPopover();
         }
 
         protected override bool OnClick(ClickEvent e)
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
index 7a28f7bbaae7..aea8d0283802 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
@@ -14,6 +14,7 @@
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
+using osu.Game.Overlays;
 using osu.Game.Rulesets.Edit;
 using osuTK;
 using osuTK.Input;
@@ -24,7 +25,6 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
     public partial class Timeline : ZoomableScrollContainer, IPositionSnapProvider
     {
         private const float timeline_height = 80;
-        private const float timeline_expanded_height = 94;
 
         private readonly Drawable userContent;
 
@@ -78,9 +78,7 @@ public bool AlwaysShowControlPoints
 
         private TimelineTickDisplay ticks = null!;
 
-        private TimelineControlPointDisplay controlPoints = null!;
-
-        private Container mainContent = null!;
+        private TimelineTimingChangeDisplay controlPoints = null!;
 
         private Bindable<float> waveformOpacity = null!;
         private Bindable<bool> controlPointsVisible = null!;
@@ -103,31 +101,34 @@ public Timeline(Drawable userContent)
         }
 
         [BackgroundDependencyLoader]
-        private void load(IBindable<WorkingBeatmap> beatmap, OsuColour colours, OsuConfigManager config)
+        private void load(IBindable<WorkingBeatmap> beatmap, OsuColour colours, OverlayColourProvider colourProvider, OsuConfigManager config)
         {
             CentreMarker centreMarker;
 
             // We don't want the centre marker to scroll
             AddInternal(centreMarker = new CentreMarker());
 
-            ticks = new TimelineTickDisplay
-            {
-                Padding = new MarginPadding { Vertical = 2, },
-            };
-
             AddRange(new Drawable[]
             {
-                controlPoints = new TimelineControlPointDisplay
+                ticks = new TimelineTickDisplay(),
+                new Box
                 {
-                    RelativeSizeAxes = Axes.X,
-                    Height = timeline_expanded_height,
+                    Name = "zero marker",
+                    RelativeSizeAxes = Axes.Y,
+                    Width = TimelineTickDisplay.TICK_WIDTH / 2,
+                    Origin = Anchor.TopCentre,
+                    Colour = colourProvider.Background1,
                 },
-                ticks,
-                mainContent = new Container
+                controlPoints = new TimelineTimingChangeDisplay
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                },
+                new Container
                 {
                     RelativeSizeAxes = Axes.X,
                     Height = timeline_height,
-                    Depth = float.MaxValue,
                     Children = new[]
                     {
                         waveform = new WaveformGraph
@@ -138,16 +139,8 @@ private void load(IBindable<WorkingBeatmap> beatmap, OsuColour colours, OsuConfi
                             MidColour = colours.BlueDark,
                             HighColour = colours.BlueDarker,
                         },
-                        ticks.CreateProxy(),
                         centreMarker.CreateProxy(),
-                        new Box
-                        {
-                            Name = "zero marker",
-                            RelativeSizeAxes = Axes.Y,
-                            Width = 2,
-                            Origin = Anchor.TopCentre,
-                            Colour = colours.YellowDarker,
-                        },
+                        ticks.CreateProxy(),
                         userContent,
                     }
                 },
@@ -192,21 +185,9 @@ protected override void LoadComplete()
             controlPointsVisible.BindValueChanged(visible =>
             {
                 if (visible.NewValue || alwaysShowControlPoints)
-                {
-                    this.ResizeHeightTo(timeline_expanded_height, 200, Easing.OutQuint);
-                    mainContent.MoveToY(15, 200, Easing.OutQuint);
-
-                    // delay the fade in else masking looks weird.
-                    controlPoints.Delay(180).FadeIn(400, Easing.OutQuint);
-                }
+                    controlPoints.FadeIn(400, Easing.OutQuint);
                 else
-                {
                     controlPoints.FadeOut(200, Easing.OutQuint);
-
-                    // likewise, delay the resize until the fade is complete.
-                    this.Delay(180).ResizeHeightTo(timeline_height, 200, Easing.OutQuint);
-                    mainContent.Delay(180).MoveToY(0, 200, Easing.OutQuint);
-                }
             }, true);
         }
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
index 740f0b6aac24..a6af83d268e7 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
@@ -173,7 +173,7 @@ protected override SelectionBlueprint<HitObject> CreateBlueprintFor(HitObject it
 
         protected sealed override DragBox CreateDragBox() => new TimelineDragBox();
 
-        protected override void UpdateSelectionFromDragBox()
+        protected override void UpdateSelectionFromDragBox(HashSet<HitObject> selectionBeforeDrag)
         {
             Composer.BlueprintContainer.CommitIfPlacementActive();
 
@@ -191,6 +191,9 @@ protected override void UpdateSelectionFromDragBox()
 
             bool shouldBeSelected(HitObject hitObject)
             {
+                if (selectionBeforeDrag.Contains(hitObject))
+                    return true;
+
                 double midTime = (hitObject.StartTime + hitObject.GetEndTime()) / 2;
                 return minTime <= midTime && midTime <= maxTime;
             }
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointDisplay.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointDisplay.cs
deleted file mode 100644
index 116a3ee1050c..000000000000
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointDisplay.cs
+++ /dev/null
@@ -1,98 +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 osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Caching;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
-
-namespace osu.Game.Screens.Edit.Compose.Components.Timeline
-{
-    /// <summary>
-    /// The part of the timeline that displays the control points.
-    /// </summary>
-    public partial class TimelineControlPointDisplay : TimelinePart<TimelineControlPointGroup>
-    {
-        [Resolved]
-        private Timeline timeline { get; set; } = null!;
-
-        /// <summary>
-        /// The visible time/position range of the timeline.
-        /// </summary>
-        private (float min, float max) visibleRange = (float.MinValue, float.MaxValue);
-
-        private readonly Cached groupCache = new Cached();
-
-        private readonly IBindableList<ControlPointGroup> controlPointGroups = new BindableList<ControlPointGroup>();
-
-        protected override void LoadBeatmap(EditorBeatmap beatmap)
-        {
-            base.LoadBeatmap(beatmap);
-
-            controlPointGroups.UnbindAll();
-            controlPointGroups.BindTo(beatmap.ControlPointInfo.Groups);
-            controlPointGroups.BindCollectionChanged((_, _) => groupCache.Invalidate(), true);
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            if (DrawWidth <= 0) return;
-
-            (float, float) newRange = (
-                (ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopLeft).X - TopPointPiece.WIDTH) / DrawWidth * Content.RelativeChildSize.X,
-                (ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopRight).X) / DrawWidth * Content.RelativeChildSize.X);
-
-            if (visibleRange != newRange)
-            {
-                visibleRange = newRange;
-                groupCache.Invalidate();
-            }
-
-            if (!groupCache.IsValid)
-            {
-                recreateDrawableGroups();
-                groupCache.Validate();
-            }
-        }
-
-        private void recreateDrawableGroups()
-        {
-            // Remove groups outside the visible range
-            foreach (TimelineControlPointGroup drawableGroup in this)
-            {
-                if (!shouldBeVisible(drawableGroup.Group))
-                    drawableGroup.Expire();
-            }
-
-            // Add remaining ones
-            for (int i = 0; i < controlPointGroups.Count; i++)
-            {
-                var group = controlPointGroups[i];
-
-                if (!shouldBeVisible(group))
-                    continue;
-
-                bool alreadyVisible = false;
-
-                foreach (var g in this)
-                {
-                    if (ReferenceEquals(g.Group, group))
-                    {
-                        alreadyVisible = true;
-                        break;
-                    }
-                }
-
-                if (alreadyVisible)
-                    continue;
-
-                Add(new TimelineControlPointGroup(group));
-            }
-        }
-
-        private bool shouldBeVisible(ControlPointGroup group) => group.Time >= visibleRange.min && group.Time <= visibleRange.max;
-    }
-}
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointGroup.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointGroup.cs
deleted file mode 100644
index 98556fda4520..000000000000
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointGroup.cs
+++ /dev/null
@@ -1,52 +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 osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps.ControlPoints;
-
-namespace osu.Game.Screens.Edit.Compose.Components.Timeline
-{
-    public partial class TimelineControlPointGroup : CompositeDrawable
-    {
-        public readonly ControlPointGroup Group;
-
-        private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
-
-        public TimelineControlPointGroup(ControlPointGroup group)
-        {
-            Group = group;
-
-            RelativePositionAxes = Axes.X;
-            RelativeSizeAxes = Axes.Y;
-            AutoSizeAxes = Axes.X;
-
-            Origin = Anchor.TopLeft;
-
-            // offset visually to avoid overlapping timeline tick display.
-            X = (float)group.Time + 6;
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            controlPoints.BindTo(Group.ControlPoints);
-            controlPoints.BindCollectionChanged((_, _) =>
-            {
-                ClearInternal();
-
-                foreach (var point in controlPoints)
-                {
-                    switch (point)
-                    {
-                        case TimingControlPoint timingPoint:
-                            AddInternal(new TimingPointPiece(timingPoint));
-                            break;
-                    }
-                }
-            }, true);
-        }
-    }
-}
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
index a168dcbd3e3f..6c0d5af24769 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
@@ -30,7 +30,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
     public partial class TimelineHitObjectBlueprint : SelectionBlueprint<HitObject>
     {
-        private const float circle_size = 38;
+        private const float circle_size = 32;
 
         private Container? repeatsContainer;
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTickDisplay.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTickDisplay.cs
index 4796c08809ff..66d0df9e1800 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTickDisplay.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTickDisplay.cs
@@ -17,6 +17,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
     public partial class TimelineTickDisplay : TimelinePart<PointVisualisation>
     {
+        public const float TICK_WIDTH = 3;
+
         // With current implementation every tick in the sub-tree should be visible, no need to check whether they are masked away.
         public override bool UpdateSubTreeMasking() => false;
 
@@ -138,20 +140,15 @@ private void createTicks()
 
                         // even though "bar lines" take up the full vertical space, we render them in two pieces because it allows for less anchor/origin churn.
 
-                        Vector2 size = Vector2.One;
-
-                        if (indexInBar != 0)
-                            size = BindableBeatDivisor.GetSize(divisor);
+                        var size = indexInBar == 0
+                            ? new Vector2(1.3f, 1)
+                            : BindableBeatDivisor.GetSize(divisor);
 
                         var line = getNextUsableLine();
                         line.X = xPos;
 
-                        line.Anchor = Anchor.CentreLeft;
-                        line.Origin = Anchor.Centre;
-
-                        line.Height = 0.6f + size.Y * 0.4f;
-                        line.Width = PointVisualisation.MAX_WIDTH * (0.6f + 0.4f * size.X);
-
+                        line.Width = TICK_WIDTH * size.X;
+                        line.Height = size.Y;
                         line.Colour = colour;
                     }
 
@@ -174,8 +171,15 @@ private void createTicks()
             Drawable getNextUsableLine()
             {
                 PointVisualisation point;
+
                 if (drawableIndex >= Count)
-                    Add(point = new PointVisualisation(0));
+                {
+                    Add(point = new PointVisualisation(0)
+                    {
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.Centre,
+                    });
+                }
                 else
                     point = Children[drawableIndex];
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTimingChangeDisplay.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTimingChangeDisplay.cs
new file mode 100644
index 000000000000..419f7e111f7a
--- /dev/null
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineTimingChangeDisplay.cs
@@ -0,0 +1,161 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    /// <summary>
+    /// The part of the timeline that displays the control points.
+    /// </summary>
+    public partial class TimelineTimingChangeDisplay : TimelinePart<TimelineTimingChangeDisplay.TimingPointPiece>
+    {
+        [Resolved]
+        private Timeline timeline { get; set; } = null!;
+
+        /// <summary>
+        /// The visible time/position range of the timeline.
+        /// </summary>
+        private (float min, float max) visibleRange = (float.MinValue, float.MaxValue);
+
+        private readonly Cached groupCache = new Cached();
+
+        private ControlPointInfo controlPointInfo = null!;
+
+        protected override void LoadBeatmap(EditorBeatmap beatmap)
+        {
+            base.LoadBeatmap(beatmap);
+
+            beatmap.ControlPointInfo.ControlPointsChanged += () => groupCache.Invalidate();
+            controlPointInfo = beatmap.ControlPointInfo;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (DrawWidth <= 0) return;
+
+            (float, float) newRange = (
+                (ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopLeft).X - TimingPointPiece.WIDTH) / DrawWidth * Content.RelativeChildSize.X,
+                (ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopRight).X + TimingPointPiece.WIDTH) / DrawWidth * Content.RelativeChildSize.X);
+
+            if (visibleRange != newRange)
+            {
+                visibleRange = newRange;
+                groupCache.Invalidate();
+            }
+
+            if (!groupCache.IsValid)
+            {
+                recreateDrawableGroups();
+                groupCache.Validate();
+            }
+        }
+
+        private void recreateDrawableGroups()
+        {
+            // Remove groups outside the visible range (or timing points which have since been removed from the beatmap).
+            foreach (TimingPointPiece drawableGroup in this)
+            {
+                if (!controlPointInfo.TimingPoints.Contains(drawableGroup.Point) || !shouldBeVisible(drawableGroup.Point))
+                    drawableGroup.Expire();
+            }
+
+            // Add remaining / new ones.
+            foreach (TimingControlPoint t in controlPointInfo.TimingPoints)
+                attemptAddTimingPoint(t);
+        }
+
+        private void attemptAddTimingPoint(TimingControlPoint point)
+        {
+            if (!shouldBeVisible(point))
+                return;
+
+            foreach (var child in this)
+            {
+                if (ReferenceEquals(child.Point, point))
+                    return;
+            }
+
+            Add(new TimingPointPiece(point));
+        }
+
+        private bool shouldBeVisible(TimingControlPoint point) => point.Time >= visibleRange.min && point.Time <= visibleRange.max;
+
+        public partial class TimingPointPiece : CompositeDrawable
+        {
+            public const float WIDTH = 16;
+
+            public readonly TimingControlPoint Point;
+
+            private readonly BindableNumber<double> beatLength;
+
+            protected OsuSpriteText Label { get; private set; } = null!;
+
+            public TimingPointPiece(TimingControlPoint timingPoint)
+            {
+                RelativePositionAxes = Axes.X;
+
+                RelativeSizeAxes = Axes.Y;
+                Width = WIDTH;
+
+                Origin = Anchor.TopRight;
+
+                Point = timingPoint;
+
+                beatLength = timingPoint.BeatLengthBindable.GetBoundCopy();
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                InternalChildren = new Drawable[]
+                {
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Point.GetRepresentingColour(colours),
+                        Masking = true,
+                        CornerRadius = TimelineTickDisplay.TICK_WIDTH / 2,
+                        Child = new Box
+                        {
+                            Colour = Color4.White,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                    },
+                    Label = new OsuSpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Rotation = 90,
+                        Padding = new MarginPadding { Horizontal = 2 },
+                        Font = OsuFont.Default.With(size: 12, weight: FontWeight.SemiBold),
+                    }
+                };
+
+                beatLength.BindValueChanged(beatLength =>
+                {
+                    Label.Text = $"{60000 / beatLength.NewValue:n1} BPM";
+                }, true);
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+                X = (float)Point.Time;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimingPointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimingPointPiece.cs
deleted file mode 100644
index 2a4ad6691838..000000000000
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimingPointPiece.cs
+++ /dev/null
@@ -1,29 +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 osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Game.Beatmaps.ControlPoints;
-
-namespace osu.Game.Screens.Edit.Compose.Components.Timeline
-{
-    public partial class TimingPointPiece : TopPointPiece
-    {
-        private readonly BindableNumber<double> beatLength;
-
-        public TimingPointPiece(TimingControlPoint point)
-            : base(point)
-        {
-            beatLength = point.BeatLengthBindable.GetBoundCopy();
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            beatLength.BindValueChanged(beatLength =>
-            {
-                Label.Text = $"{60000 / beatLength.NewValue:n1} BPM";
-            }, true);
-        }
-    }
-}
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TopPointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TopPointPiece.cs
deleted file mode 100644
index a40a80536158..000000000000
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TopPointPiece.cs
+++ /dev/null
@@ -1,91 +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 osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
-using osuTK;
-using osuTK.Graphics;
-
-namespace osu.Game.Screens.Edit.Compose.Components.Timeline
-{
-    public partial class TopPointPiece : CompositeDrawable
-    {
-        protected readonly ControlPoint Point;
-
-        protected OsuSpriteText Label { get; private set; } = null!;
-
-        public const float WIDTH = 80;
-
-        public TopPointPiece(ControlPoint point)
-        {
-            Point = point;
-            Width = WIDTH;
-            Height = 16;
-            Margin = new MarginPadding { Vertical = 4 };
-
-            Origin = Anchor.TopCentre;
-            Anchor = Anchor.TopCentre;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            const float corner_radius = 4;
-            const float arrow_extension = 3;
-            const float triangle_portion = 15;
-
-            InternalChildren = new Drawable[]
-            {
-                // This is a triangle, trust me.
-                // Doing it this way looks okay. Doing it using Triangle primitive is basically impossible.
-                new Container
-                {
-                    Colour = Point.GetRepresentingColour(colours),
-                    X = -corner_radius,
-                    Size = new Vector2(triangle_portion * arrow_extension, Height),
-                    Anchor = Anchor.CentreRight,
-                    Origin = Anchor.CentreRight,
-                    Masking = true,
-                    CornerRadius = Height,
-                    CornerExponent = 1.4f,
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            Colour = Color4.White,
-                            RelativeSizeAxes = Axes.Both,
-                        },
-                    }
-                },
-                new Container
-                {
-                    RelativeSizeAxes = Axes.Y,
-                    Width = WIDTH - triangle_portion,
-                    Anchor = Anchor.CentreLeft,
-                    Origin = Anchor.CentreLeft,
-                    Colour = Point.GetRepresentingColour(colours),
-                    Masking = true,
-                    CornerRadius = corner_radius,
-                    Child = new Box
-                    {
-                        Colour = Color4.White,
-                        RelativeSizeAxes = Axes.Both,
-                    },
-                },
-                Label = new OsuSpriteText
-                {
-                    Anchor = Anchor.CentreLeft,
-                    Origin = Anchor.CentreLeft,
-                    Padding = new MarginPadding(3),
-                    Font = OsuFont.Default.With(size: 14, weight: FontWeight.SemiBold),
-                    Colour = colours.B5,
-                }
-            };
-        }
-    }
-}
diff --git a/osu.Game/Screens/Edit/Editor.cs b/osu.Game/Screens/Edit/Editor.cs
index 167ac9287486..9bb91af80652 100644
--- a/osu.Game/Screens/Edit/Editor.cs
+++ b/osu.Game/Screens/Edit/Editor.cs
@@ -44,6 +44,7 @@
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Screens.Edit.Components.Menus;
 using osu.Game.Screens.Edit.Compose;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
@@ -224,6 +225,9 @@ protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnl
         /// </remarks>
         public Bindable<bool> ComposerFocusMode { get; } = new Bindable<bool>();
 
+        [CanBeNull]
+        public event Action<double> ShowSampleEditPopoverRequested;
+
         public Editor(EditorLoader loader = null)
         {
             this.loader = loader;
@@ -713,6 +717,26 @@ protected override bool OnScroll(ScrollEvent e)
 
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
+            // Repeatable actions
+            switch (e.Action)
+            {
+                case GlobalAction.EditorSeekToPreviousHitObject:
+                    seekHitObject(-1);
+                    return true;
+
+                case GlobalAction.EditorSeekToNextHitObject:
+                    seekHitObject(1);
+                    return true;
+
+                case GlobalAction.EditorSeekToPreviousSamplePoint:
+                    seekSamplePoint(-1);
+                    return true;
+
+                case GlobalAction.EditorSeekToNextSamplePoint:
+                    seekSamplePoint(1);
+                    return true;
+            }
+
             if (e.Repeat)
                 return false;
 
@@ -750,10 +774,9 @@ public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
                 case GlobalAction.EditorTestGameplay:
                     bottomBar.TestGameplayButton.TriggerClick();
                     return true;
-
-                default:
-                    return false;
             }
+
+            return false;
         }
 
         public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
@@ -1077,6 +1100,66 @@ private void seekControlPoint(int direction)
                 clock.Seek(found.Time);
         }
 
+        private void seekHitObject(int direction)
+        {
+            var found = direction < 1
+                ? editorBeatmap.HitObjects.LastOrDefault(p => p.StartTime < clock.CurrentTimeAccurate)
+                : editorBeatmap.HitObjects.FirstOrDefault(p => p.StartTime > clock.CurrentTimeAccurate);
+
+            if (found != null)
+                clock.SeekSmoothlyTo(found.StartTime);
+        }
+
+        private void seekSamplePoint(int direction)
+        {
+            double currentTime = clock.CurrentTimeAccurate;
+
+            // Check if we are currently inside a hit object with node samples, if so seek to the next node sample point
+            var current = direction < 1
+                ? editorBeatmap.HitObjects.LastOrDefault(p => p is IHasRepeats r && p.StartTime < currentTime && r.EndTime >= currentTime)
+                : editorBeatmap.HitObjects.LastOrDefault(p => p is IHasRepeats r && p.StartTime <= currentTime && r.EndTime > currentTime);
+
+            if (current != null)
+            {
+                // Find the next node sample point
+                var r = (IHasRepeats)current;
+                double[] nodeSamplePointTimes = new double[r.RepeatCount + 3];
+
+                nodeSamplePointTimes[0] = current.StartTime;
+                // The sample point for the main samples is sandwiched between the head and the first repeat
+                nodeSamplePointTimes[1] = current.StartTime + r.Duration / r.SpanCount() / 2;
+
+                for (int i = 0; i < r.SpanCount(); i++)
+                {
+                    nodeSamplePointTimes[i + 2] = current.StartTime + r.Duration * (i + 1) / r.SpanCount();
+                }
+
+                double found = direction < 1
+                    ? nodeSamplePointTimes.Last(p => p < currentTime)
+                    : nodeSamplePointTimes.First(p => p > currentTime);
+
+                clock.SeekSmoothlyTo(found);
+            }
+            else
+            {
+                if (direction < 1)
+                {
+                    current = editorBeatmap.HitObjects.LastOrDefault(p => p.StartTime < currentTime);
+                    if (current != null)
+                        clock.SeekSmoothlyTo(current is IHasRepeats r ? r.EndTime : current.StartTime);
+                }
+                else
+                {
+                    current = editorBeatmap.HitObjects.FirstOrDefault(p => p.StartTime > currentTime);
+                    if (current != null)
+                        clock.SeekSmoothlyTo(current.StartTime);
+                }
+            }
+
+            // Show the sample edit popover at the current time
+            ShowSampleEditPopoverRequested?.Invoke(clock.CurrentTimeAccurate);
+        }
+
         private void seek(UIEvent e, int direction)
         {
             double amount = e.ShiftPressed ? 4 : 1;
diff --git a/osu.Game/Screens/Edit/EditorClock.cs b/osu.Game/Screens/Edit/EditorClock.cs
index 773abaa737ba..5b9c662c95a5 100644
--- a/osu.Game/Screens/Edit/EditorClock.cs
+++ b/osu.Game/Screens/Edit/EditorClock.cs
@@ -132,7 +132,7 @@ private void seek(int direction, bool snapped, double amount = 1)
             seekTime = timingPoint.Time + closestBeat * seekAmount;
 
             // limit forward seeking to only up to the next timing point's start time.
-            var nextTimingPoint = ControlPointInfo.TimingPoints.FirstOrDefault(t => t.Time > timingPoint.Time);
+            var nextTimingPoint = ControlPointInfo.TimingPointAfter(timingPoint.Time);
             if (seekTime > nextTimingPoint?.Time)
                 seekTime = nextTimingPoint.Time;
 
diff --git a/osu.Game/Screens/Edit/Setup/LabelledFileChooser.cs b/osu.Game/Screens/Edit/Setup/LabelledFileChooser.cs
index 61f33c4bdcda..a113ca5407bc 100644
--- a/osu.Game/Screens/Edit/Setup/LabelledFileChooser.cs
+++ b/osu.Game/Screens/Edit/Setup/LabelledFileChooser.cs
@@ -18,6 +18,7 @@
 using osu.Framework.Platform;
 using osu.Game.Database;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays;
 using osuTK;
 
 namespace osu.Game.Screens.Edit.Setup
@@ -118,6 +119,7 @@ private partial class FileChooserPopover : OsuPopover
             protected override string PopOutSampleName => "UI/overlay-big-pop-out";
 
             public FileChooserPopover(string[] handledExtensions, Bindable<FileInfo?> currentFile, string? chooserPath)
+                : base(false)
             {
                 Child = new Container
                 {
@@ -129,6 +131,13 @@ public FileChooserPopover(string[] handledExtensions, Bindable<FileInfo?> curren
                     },
                 };
             }
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider)
+            {
+                Body.BorderColour = colourProvider.Highlight1;
+                Body.BorderThickness = 2;
+            }
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Timing/ControlPointList.cs b/osu.Game/Screens/Edit/Timing/ControlPointList.cs
index b7367dddda4a..49e5b76dd689 100644
--- a/osu.Game/Screens/Edit/Timing/ControlPointList.cs
+++ b/osu.Game/Screens/Edit/Timing/ControlPointList.cs
@@ -7,8 +7,10 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Overlays;
@@ -18,6 +20,8 @@ namespace osu.Game.Screens.Edit.Timing
 {
     public partial class ControlPointList : CompositeDrawable
     {
+        private ControlPointTable table = null!;
+        private Container controls = null!;
         private OsuButton deleteButton = null!;
         private RoundedButton addButton = null!;
 
@@ -31,42 +35,77 @@ public partial class ControlPointList : CompositeDrawable
         private Bindable<ControlPointGroup?> selectedGroup { get; set; } = null!;
 
         [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colours)
+        private void load(OsuColour colours, OverlayColourProvider colourProvider)
         {
             RelativeSizeAxes = Axes.Both;
 
             const float margins = 10;
             InternalChildren = new Drawable[]
             {
-                new ControlPointTable
+                table = new ControlPointTable
                 {
                     RelativeSizeAxes = Axes.Both,
                     Groups = { BindTarget = Beatmap.ControlPointInfo.Groups, },
                 },
-                new FillFlowContainer
+                controls = new Container
                 {
-                    AutoSizeAxes = Axes.Both,
-                    Anchor = Anchor.BottomRight,
-                    Origin = Anchor.BottomRight,
-                    Direction = FillDirection.Horizontal,
-                    Margin = new MarginPadding(margins),
-                    Spacing = new Vector2(5),
+                    AutoSizeAxes = Axes.Y,
+                    RelativeSizeAxes = Axes.X,
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
                     Children = new Drawable[]
                     {
-                        deleteButton = new RoundedButton
+                        new Box
                         {
-                            Text = "-",
-                            Size = new Vector2(30, 30),
-                            Action = delete,
-                            Anchor = Anchor.BottomRight,
-                            Origin = Anchor.BottomRight,
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = colourProvider.Background2,
                         },
-                        addButton = new RoundedButton
+                        new FillFlowContainer
                         {
-                            Action = addNew,
-                            Size = new Vector2(160, 30),
-                            Anchor = Anchor.BottomRight,
-                            Origin = Anchor.BottomRight,
+                            AutoSizeAxes = Axes.Both,
+                            Direction = FillDirection.Horizontal,
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Padding = new MarginPadding { Left = margins, Vertical = margins, },
+                            Children = new Drawable[]
+                            {
+                                new RoundedButton
+                                {
+                                    Text = "Select closest to current time",
+                                    Action = goToCurrentGroup,
+                                    Size = new Vector2(220, 30),
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                },
+                            }
+                        },
+                        new FillFlowContainer
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Direction = FillDirection.Horizontal,
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreRight,
+                            Spacing = new Vector2(5),
+                            Padding = new MarginPadding { Right = margins, Vertical = margins, },
+                            Children = new Drawable[]
+                            {
+                                deleteButton = new RoundedButton
+                                {
+                                    Text = "-",
+                                    Size = new Vector2(30, 30),
+                                    Action = delete,
+                                    Anchor = Anchor.CentreRight,
+                                    Origin = Anchor.CentreRight,
+                                    BackgroundColour = colours.Red3,
+                                },
+                                addButton = new RoundedButton
+                                {
+                                    Action = addNew,
+                                    Size = new Vector2(160, 30),
+                                    Anchor = Anchor.CentreRight,
+                                    Origin = Anchor.CentreRight,
+                                },
+                            }
                         },
                     }
                 },
@@ -97,78 +136,19 @@ protected override void Update()
         {
             base.Update();
 
-            trackActivePoint();
-
             addButton.Enabled.Value = clock.CurrentTimeAccurate != selectedGroup.Value?.Time;
+            table.Padding = new MarginPadding { Bottom = controls.DrawHeight };
         }
 
-        private Type? trackedType;
-
-        /// <summary>
-        /// Given the user has selected a control point group, we want to track any group which is
-        /// active at the current point in time which matches the type the user has selected.
-        ///
-        /// So if the user is currently looking at a timing point and seeks into the future, a
-        /// future timing point would be automatically selected if it is now the new "current" point.
-        /// </summary>
-        private void trackActivePoint()
+        private void goToCurrentGroup()
         {
-            // For simplicity only match on the first type of the active control point.
-            if (selectedGroup.Value == null)
-                trackedType = null;
-            else
-            {
-                switch (selectedGroup.Value.ControlPoints.Count)
-                {
-                    // If the selected group has no control points, clear the tracked type.
-                    // Otherwise the user will be unable to select a group with no control points.
-                    case 0:
-                        trackedType = null;
-                        break;
-
-                    // If the selected group only has one control point, update the tracking type.
-                    case 1:
-                        trackedType = selectedGroup.Value?.ControlPoints[0].GetType();
-                        break;
-
-                    // If the selected group has more than one control point, choose the first as the tracking type
-                    // if we don't already have a singular tracked type.
-                    default:
-                        trackedType ??= selectedGroup.Value?.ControlPoints[0].GetType();
-                        break;
-                }
-            }
-
-            if (trackedType != null)
-            {
-                double accurateTime = clock.CurrentTimeAccurate;
-
-                // We don't have an efficient way of looking up groups currently, only individual point types.
-                // To improve the efficiency of this in the future, we should reconsider the overall structure of ControlPointInfo.
-
-                // Find the next group which has the same type as the selected one.
-                ControlPointGroup? found = null;
+            double accurateTime = clock.CurrentTimeAccurate;
 
-                for (int i = 0; i < Beatmap.ControlPointInfo.Groups.Count; i++)
-                {
-                    var g = Beatmap.ControlPointInfo.Groups[i];
-
-                    if (g.Time > accurateTime)
-                        continue;
+            var activeTimingPoint = Beatmap.ControlPointInfo.TimingPointAt(accurateTime);
+            var activeEffectPoint = Beatmap.ControlPointInfo.EffectPointAt(accurateTime);
 
-                    for (int j = 0; j < g.ControlPoints.Count; j++)
-                    {
-                        if (g.ControlPoints[j].GetType() == trackedType)
-                        {
-                            found = g;
-                            break;
-                        }
-                    }
-                }
-
-                if (found != null)
-                    selectedGroup.Value = found;
-            }
+            double latestActiveTime = Math.Max(activeTimingPoint.Time, activeEffectPoint.Time);
+            selectedGroup.Value = Beatmap.ControlPointInfo.GroupAt(latestActiveTime);
         }
 
         private void delete()
diff --git a/osu.Game/Screens/Edit/Timing/ControlPointTable.cs b/osu.Game/Screens/Edit/Timing/ControlPointTable.cs
index 2204fabf572d..fd812cfe2b44 100644
--- a/osu.Game/Screens/Edit/Timing/ControlPointTable.cs
+++ b/osu.Game/Screens/Edit/Timing/ControlPointTable.cs
@@ -6,6 +6,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Pooling;
 using osu.Framework.Graphics.Shapes;
@@ -27,10 +28,33 @@ public partial class ControlPointTable : CompositeDrawable
     {
         public BindableList<ControlPointGroup> Groups { get; } = new BindableList<ControlPointGroup>();
 
+        public new MarginPadding Padding
+        {
+            get => base.Padding;
+            set => base.Padding = value;
+        }
+
+        [Cached]
+        private Bindable<TimingControlPoint?> activeTimingPoint { get; } = new Bindable<TimingControlPoint?>();
+
+        [Cached]
+        private Bindable<EffectControlPoint?> activeEffectPoint { get; } = new Bindable<EffectControlPoint?>();
+
+        [Resolved]
+        private EditorBeatmap beatmap { get; set; } = null!;
+
+        [Resolved]
+        private Bindable<ControlPointGroup?> selectedGroup { get; set; } = null!;
+
+        [Resolved]
+        private EditorClock editorClock { get; set; } = null!;
+
         private const float timing_column_width = 300;
         private const float row_height = 25;
         private const float row_horizontal_padding = 20;
 
+        private ControlPointRowList list = null!;
+
         [BackgroundDependencyLoader]
         private void load(OverlayColourProvider colours)
         {
@@ -65,7 +89,7 @@ private void load(OverlayColourProvider colours)
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
-                            Margin = new MarginPadding { Left = ControlPointTable.timing_column_width }
+                            Margin = new MarginPadding { Left = timing_column_width }
                         },
                     }
                 },
@@ -73,7 +97,7 @@ private void load(OverlayColourProvider colours)
                 {
                     RelativeSizeAxes = Axes.Both,
                     Padding = new MarginPadding { Top = row_height },
-                    Child = new ControlPointRowList
+                    Child = list = new ControlPointRowList
                     {
                         RelativeSizeAxes = Axes.Both,
                         RowData = { BindTarget = Groups, },
@@ -82,40 +106,63 @@ private void load(OverlayColourProvider colours)
             };
         }
 
-        private partial class ControlPointRowList : VirtualisedListContainer<ControlPointGroup, DrawableControlGroup>
+        protected override void LoadComplete()
         {
-            [Resolved]
-            private Bindable<ControlPointGroup?> selectedGroup { get; set; } = null!;
+            base.LoadComplete();
+
+            selectedGroup.BindValueChanged(_ => scrollToMostRelevantRow(force: true), true);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            scrollToMostRelevantRow(force: false);
+        }
+
+        private void scrollToMostRelevantRow(bool force)
+        {
+            double accurateTime = editorClock.CurrentTimeAccurate;
+
+            activeTimingPoint.Value = beatmap.ControlPointInfo.TimingPointAt(accurateTime);
+            activeEffectPoint.Value = beatmap.ControlPointInfo.EffectPointAt(accurateTime);
+
+            double latestActiveTime = Math.Max(activeTimingPoint.Value?.Time ?? double.NegativeInfinity, activeEffectPoint.Value?.Time ?? double.NegativeInfinity);
+            var groupToShow = selectedGroup.Value ?? beatmap.ControlPointInfo.GroupAt(latestActiveTime);
+            list.ScrollTo(groupToShow, force);
+        }
 
+        private partial class ControlPointRowList : VirtualisedListContainer<ControlPointGroup, DrawableControlGroup>
+        {
             public ControlPointRowList()
                 : base(row_height, 50)
             {
             }
 
-            protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer();
+            protected override ScrollContainer<Drawable> CreateScrollContainer() => new UserTrackingScrollContainer();
 
-            protected override void LoadComplete()
+            protected new UserTrackingScrollContainer Scroll => (UserTrackingScrollContainer)base.Scroll;
+
+            public void ScrollTo(ControlPointGroup group, bool force)
             {
-                base.LoadComplete();
+                if (Scroll.UserScrolling && !force)
+                    return;
 
-                selectedGroup.BindValueChanged(val =>
-                {
-                    // can't use `.ScrollIntoView()` here because of the list virtualisation not giving
-                    // child items valid coordinates from the start, so ballpark something similar
-                    // using estimated row height.
-                    var row = Items.FlowingChildren.SingleOrDefault(item => item.Row.Equals(val.NewValue));
+                // can't use `.ScrollIntoView()` here because of the list virtualisation not giving
+                // child items valid coordinates from the start, so ballpark something similar
+                // using estimated row height.
+                var row = Items.FlowingChildren.SingleOrDefault(item => item.Row.Equals(group));
 
-                    if (row == null)
-                        return;
+                if (row == null)
+                    return;
 
-                    float minPos = row.Y;
-                    float maxPos = minPos + row_height;
+                float minPos = row.Y;
+                float maxPos = minPos + row_height;
 
-                    if (minPos < Scroll.Current)
-                        Scroll.ScrollTo(minPos);
-                    else if (maxPos > Scroll.Current + Scroll.DisplayableContent)
-                        Scroll.ScrollTo(maxPos - Scroll.DisplayableContent);
-                });
+                if (minPos < Scroll.Current)
+                    Scroll.ScrollTo(minPos);
+                else if (maxPos > Scroll.Current + Scroll.DisplayableContent)
+                    Scroll.ScrollTo(maxPos - Scroll.DisplayableContent);
             }
         }
 
@@ -130,13 +177,23 @@ public Bindable<ControlPointGroup> Current
             private readonly BindableWithCurrent<ControlPointGroup> current = new BindableWithCurrent<ControlPointGroup>();
 
             private Box background = null!;
+            private Box currentIndicator = null!;
 
             [Resolved]
             private OverlayColourProvider colourProvider { get; set; } = null!;
 
+            [Resolved]
+            private OsuColour colours { get; set; } = null!;
+
             [Resolved]
             private Bindable<ControlPointGroup?> selectedGroup { get; set; } = null!;
 
+            [Resolved]
+            private Bindable<TimingControlPoint?> activeTimingPoint { get; set; } = null!;
+
+            [Resolved]
+            private Bindable<EffectControlPoint?> activeEffectPoint { get; set; } = null!;
+
             [Resolved]
             private EditorClock editorClock { get; set; } = null!;
 
@@ -153,6 +210,12 @@ private void load()
                         Colour = colourProvider.Background1,
                         Alpha = 0,
                     },
+                    currentIndicator = new Box
+                    {
+                        RelativeSizeAxes = Axes.Y,
+                        Width = 5,
+                        Alpha = 0,
+                    },
                     new Container
                     {
                         RelativeSizeAxes = Axes.Both,
@@ -174,7 +237,9 @@ protected override void LoadComplete()
             {
                 base.LoadComplete();
 
-                selectedGroup.BindValueChanged(_ => updateState(), true);
+                selectedGroup.BindValueChanged(_ => updateState());
+                activeEffectPoint.BindValueChanged(_ => updateState());
+                activeTimingPoint.BindValueChanged(_ => updateState(), true);
                 FinishTransforms(true);
             }
 
@@ -213,12 +278,31 @@ private void updateState()
             {
                 bool isSelected = selectedGroup.Value?.Equals(current.Value) == true;
 
+                bool hasCurrentTimingPoint = activeTimingPoint.Value != null && current.Value.ControlPoints.Contains(activeTimingPoint.Value);
+                bool hasCurrentEffectPoint = activeEffectPoint.Value != null && current.Value.ControlPoints.Contains(activeEffectPoint.Value);
+
                 if (IsHovered || isSelected)
                     background.FadeIn(100, Easing.OutQuint);
+                else if (hasCurrentTimingPoint || hasCurrentEffectPoint)
+                    background.FadeTo(0.2f, 100, Easing.OutQuint);
                 else
                     background.FadeOut(100, Easing.OutQuint);
 
                 background.Colour = isSelected ? colourProvider.Colour3 : colourProvider.Background1;
+
+                if (hasCurrentTimingPoint || hasCurrentEffectPoint)
+                {
+                    currentIndicator.FadeIn(100, Easing.OutQuint);
+
+                    if (hasCurrentTimingPoint && hasCurrentEffectPoint)
+                        currentIndicator.Colour = ColourInfo.GradientVertical(activeTimingPoint.Value!.GetRepresentingColour(colours), activeEffectPoint.Value!.GetRepresentingColour(colours));
+                    else if (hasCurrentTimingPoint)
+                        currentIndicator.Colour = activeTimingPoint.Value!.GetRepresentingColour(colours);
+                    else
+                        currentIndicator.Colour = activeEffectPoint.Value!.GetRepresentingColour(colours);
+                }
+                else
+                    currentIndicator.FadeOut(100, Easing.OutQuint);
             }
         }
 
@@ -323,14 +407,8 @@ private Drawable createAttribute(ControlPoint controlPoint)
                     case TimingControlPoint timing:
                         return new TimingRowAttribute(timing);
 
-                    case DifficultyControlPoint difficulty:
-                        return new DifficultyRowAttribute(difficulty);
-
                     case EffectControlPoint effect:
                         return new EffectRowAttribute(effect);
-
-                    case SampleControlPoint sample:
-                        return new SampleRowAttribute(sample);
                 }
 
                 throw new ArgumentOutOfRangeException(nameof(controlPoint), $"Control point type {controlPoint.GetType()} is not supported");
diff --git a/osu.Game/Screens/Edit/Timing/EffectSection.cs b/osu.Game/Screens/Edit/Timing/EffectSection.cs
index f321f7eeb0a3..f9ef46023266 100644
--- a/osu.Game/Screens/Edit/Timing/EffectSection.cs
+++ b/osu.Game/Screens/Edit/Timing/EffectSection.cs
@@ -5,9 +5,7 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterfaceV2;
-using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Screens.Edit.Timing
 {
@@ -38,8 +36,7 @@ protected override void LoadComplete()
             kiai.Current.BindValueChanged(_ => saveChanges());
             scrollSpeedSlider.Current.BindValueChanged(_ => saveChanges());
 
-            var drawableRuleset = Beatmap.BeatmapInfo.Ruleset.CreateInstance().CreateDrawableRulesetWith(Beatmap.PlayableBeatmap);
-            if (drawableRuleset is not IDrawableScrollingRuleset scrollingRuleset || scrollingRuleset.VisualisationMethod == ScrollVisualisationMethod.Constant)
+            if (!Beatmap.BeatmapInfo.Ruleset.CreateInstance().EditorShowScrollSpeed)
                 scrollSpeedSlider.Hide();
 
             void saveChanges()
@@ -59,7 +56,7 @@ protected override void OnControlPointChanged(ValueChangedEvent<EffectControlPoi
                 isRebinding = true;
 
                 kiai.Current = newEffectPoint.KiaiModeBindable;
-                scrollSpeedSlider.Current = new BindableDouble
+                scrollSpeedSlider.Current = new BindableDouble(1)
                 {
                     MinValue = 0.01,
                     MaxValue = 10,
diff --git a/osu.Game/Screens/Edit/Timing/RowAttributes/DifficultyRowAttribute.cs b/osu.Game/Screens/Edit/Timing/RowAttributes/DifficultyRowAttribute.cs
deleted file mode 100644
index 43f3739503f9..000000000000
--- a/osu.Game/Screens/Edit/Timing/RowAttributes/DifficultyRowAttribute.cs
+++ /dev/null
@@ -1,44 +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 osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Graphics.Sprites;
-
-namespace osu.Game.Screens.Edit.Timing.RowAttributes
-{
-    public partial class DifficultyRowAttribute : RowAttribute
-    {
-        private readonly BindableNumber<double> speedMultiplier;
-
-        private OsuSpriteText text = null!;
-
-        public DifficultyRowAttribute(DifficultyControlPoint difficulty)
-            : base(difficulty, "difficulty")
-        {
-            speedMultiplier = difficulty.SliderVelocityBindable.GetBoundCopy();
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Content.AddRange(new Drawable[]
-            {
-                new AttributeProgressBar(Point)
-                {
-                    Current = speedMultiplier,
-                },
-                text = new AttributeText(Point)
-                {
-                    Width = 45,
-                },
-            });
-
-            speedMultiplier.BindValueChanged(_ => updateText(), true);
-        }
-
-        private void updateText() => text.Text = $"{speedMultiplier.Value:n2}x";
-    }
-}
diff --git a/osu.Game/Screens/Edit/Timing/RowAttributes/EffectRowAttribute.cs b/osu.Game/Screens/Edit/Timing/RowAttributes/EffectRowAttribute.cs
index ad22aa81fc7b..87ee675e7f0e 100644
--- a/osu.Game/Screens/Edit/Timing/RowAttributes/EffectRowAttribute.cs
+++ b/osu.Game/Screens/Edit/Timing/RowAttributes/EffectRowAttribute.cs
@@ -15,6 +15,10 @@ public partial class EffectRowAttribute : RowAttribute
 
         private AttributeText kiaiModeBubble = null!;
         private AttributeText text = null!;
+        private AttributeProgressBar progressBar = null!;
+
+        [Resolved]
+        protected EditorBeatmap Beatmap { get; private set; } = null!;
 
         public EffectRowAttribute(EffectControlPoint effect)
             : base(effect, "effect")
@@ -28,7 +32,7 @@ private void load()
         {
             Content.AddRange(new Drawable[]
             {
-                new AttributeProgressBar(Point)
+                progressBar = new AttributeProgressBar(Point)
                 {
                     Current = scrollSpeed,
                 },
@@ -36,6 +40,12 @@ private void load()
                 kiaiModeBubble = new AttributeText(Point) { Text = "kiai" },
             });
 
+            if (!Beatmap.BeatmapInfo.Ruleset.CreateInstance().EditorShowScrollSpeed)
+            {
+                text.Hide();
+                progressBar.Hide();
+            }
+
             kiaiMode.BindValueChanged(enabled => kiaiModeBubble.FadeTo(enabled.NewValue ? 1 : 0), true);
             scrollSpeed.BindValueChanged(_ => updateText(), true);
         }
diff --git a/osu.Game/Screens/Edit/Timing/RowAttributes/SampleRowAttribute.cs b/osu.Game/Screens/Edit/Timing/RowAttributes/SampleRowAttribute.cs
deleted file mode 100644
index e86a991521cd..000000000000
--- a/osu.Game/Screens/Edit/Timing/RowAttributes/SampleRowAttribute.cs
+++ /dev/null
@@ -1,57 +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 osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Graphics.Sprites;
-
-namespace osu.Game.Screens.Edit.Timing.RowAttributes
-{
-    public partial class SampleRowAttribute : RowAttribute
-    {
-        private AttributeText sampleText = null!;
-        private OsuSpriteText volumeText = null!;
-
-        private readonly Bindable<string> sampleBank;
-        private readonly BindableNumber<int> volume;
-
-        public SampleRowAttribute(SampleControlPoint sample)
-            : base(sample, "sample")
-        {
-            sampleBank = sample.SampleBankBindable.GetBoundCopy();
-            volume = sample.SampleVolumeBindable.GetBoundCopy();
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            AttributeProgressBar progress;
-
-            Content.AddRange(new Drawable[]
-            {
-                sampleText = new AttributeText(Point),
-                progress = new AttributeProgressBar(Point),
-                volumeText = new AttributeText(Point)
-                {
-                    Width = 40,
-                },
-            });
-
-            volume.BindValueChanged(vol =>
-            {
-                progress.Current.Value = vol.NewValue / 100f;
-                updateText();
-            }, true);
-
-            sampleBank.BindValueChanged(_ => updateText(), true);
-        }
-
-        private void updateText()
-        {
-            volumeText.Text = $"{volume.Value}%";
-            sampleText.Text = $"{sampleBank.Value}";
-        }
-    }
-}
diff --git a/osu.Game/Screens/Import/FileImportScreen.cs b/osu.Game/Screens/Import/FileImportScreen.cs
index 6b7a269d12a7..1bdacae87fc7 100644
--- a/osu.Game/Screens/Import/FileImportScreen.cs
+++ b/osu.Game/Screens/Import/FileImportScreen.cs
@@ -15,6 +15,7 @@
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays;
 using osuTK;
 
 namespace osu.Game.Screens.Import
@@ -36,8 +37,8 @@ public partial class FileImportScreen : OsuScreen
         [Resolved]
         private OsuGameBase game { get; set; }
 
-        [Resolved]
-        private OsuColour colours { get; set; }
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
 
         [BackgroundDependencyLoader(true)]
         private void load()
@@ -52,11 +53,6 @@ private void load()
                 Size = new Vector2(0.9f, 0.8f),
                 Children = new Drawable[]
                 {
-                    new Box
-                    {
-                        Colour = colours.GreySeaFoamDark,
-                        RelativeSizeAxes = Axes.Both,
-                    },
                     fileSelector = new OsuFileSelector(validFileExtensions: game.HandledExtensions.ToArray())
                     {
                         RelativeSizeAxes = Axes.Both,
@@ -72,7 +68,7 @@ private void load()
                         {
                             new Box
                             {
-                                Colour = colours.GreySeaFoamDarker,
+                                Colour = colourProvider.Background4,
                                 RelativeSizeAxes = Axes.Both
                             },
                             new Container
diff --git a/osu.Game/Screens/Loader.cs b/osu.Game/Screens/Loader.cs
index 4dba512cbd15..d71ee05b2753 100644
--- a/osu.Game/Screens/Loader.cs
+++ b/osu.Game/Screens/Loader.cs
@@ -118,12 +118,20 @@ private void load(ShaderManager manager)
             {
                 loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE));
                 loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.BLUR));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE));
 
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, @"TriangleBorder"));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, @"FastCircle"));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, @"CircularProgress"));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, @"ArgonBarPath"));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, @"ArgonBarPathBackground"));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, @"SaturationSelectorBackground"));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, @"HueSelectorBackground"));
+                loadTargets.Add(manager.Load(@"LogoAnimation", @"LogoAnimation"));
+
+                // Ruleset local shader usage (should probably move somewhere else).
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, @"SpinnerGlow"));
                 loadTargets.Add(manager.Load(@"CursorTrail", FragmentShaderDescriptor.TEXTURE));
-
-                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, "TriangleBorder"));
-
-                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE));
             }
 
             protected virtual bool AllLoaded => loadTargets.All(s => s.IsLoaded);
diff --git a/osu.Game/Screens/Menu/DailyChallengeButton.cs b/osu.Game/Screens/Menu/DailyChallengeButton.cs
index e6593c9b0d5f..4dbebf0ae9ec 100644
--- a/osu.Game/Screens/Menu/DailyChallengeButton.cs
+++ b/osu.Game/Screens/Menu/DailyChallengeButton.cs
@@ -13,6 +13,7 @@
 using osu.Framework.Threading;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps.Drawables;
+using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Localisation;
@@ -46,6 +47,9 @@ public partial class DailyChallengeButton : MainMenuButton
         [Resolved]
         private INotificationOverlay? notificationOverlay { get; set; }
 
+        [Resolved]
+        private SessionStatics statics { get; set; } = null!;
+
         public DailyChallengeButton(string sampleName, Color4 colour, Action<MainMenuButton>? clickAction = null, params Key[] triggerKeys)
             : base(ButtonSystemStrings.DailyChallenge, sampleName, OsuIcon.DailyChallenge, colour, clickAction, triggerKeys)
         {
@@ -128,7 +132,7 @@ protected override void Update()
             }
         }
 
-        private long? lastNotifiedDailyChallengeRoomId;
+        private long? lastDailyChallengeRoomID;
 
         private void dailyChallengeChanged(ValueChangedEvent<DailyChallengeInfo?> _)
         {
@@ -151,13 +155,16 @@ private void dailyChallengeChanged(ValueChangedEvent<DailyChallengeInfo?> _)
                     Room = room;
                     cover.OnlineInfo = TooltipContent = room.Playlist.FirstOrDefault()?.Beatmap.BeatmapSet as APIBeatmapSet;
 
-                    // We only want to notify the user if a new challenge recently went live.
-                    if (room.StartDate.Value != null
-                        && Math.Abs((DateTimeOffset.Now - room.StartDate.Value!.Value).TotalSeconds) < 1800
-                        && room.RoomID.Value != lastNotifiedDailyChallengeRoomId)
+                    if (room.StartDate.Value != null && room.RoomID.Value != lastDailyChallengeRoomID)
                     {
-                        lastNotifiedDailyChallengeRoomId = room.RoomID.Value;
-                        notificationOverlay?.Post(new NewDailyChallengeNotification(room));
+                        lastDailyChallengeRoomID = room.RoomID.Value;
+
+                        // new challenge is live, reset intro played static.
+                        statics.SetValue(Static.DailyChallengeIntroPlayed, false);
+
+                        // we only want to notify the user if the new challenge just went live.
+                        if (Math.Abs((DateTimeOffset.Now - room.StartDate.Value!.Value).TotalSeconds) < 1800)
+                            notificationOverlay?.Post(new NewDailyChallengeNotification(room));
                     }
 
                     updateCountdown();
diff --git a/osu.Game/Screens/Menu/MainMenu.cs b/osu.Game/Screens/Menu/MainMenu.cs
index dfe5460aee96..346bdcb75117 100644
--- a/osu.Game/Screens/Menu/MainMenu.cs
+++ b/osu.Game/Screens/Menu/MainMenu.cs
@@ -54,8 +54,6 @@ public partial class MainMenu : OsuScreen, IHandlePresentBeatmap, IKeyBindingHan
 
         public override bool? AllowGlobalTrackControl => true;
 
-        private Screen songSelect;
-
         private MenuSideFlashes sideFlashes;
 
         protected ButtonSystem Buttons;
@@ -150,7 +148,10 @@ private void load(BeatmapListingOverlay beatmapListing, SettingsOverlay settings
                             OnPlaylists = () => this.Push(new Playlists()),
                             OnDailyChallenge = room =>
                             {
-                                this.Push(new DailyChallengeIntro(room));
+                                if (statics.Get<bool>(Static.DailyChallengeIntroPlayed))
+                                    this.Push(new DailyChallenge(room));
+                                else
+                                    this.Push(new DailyChallengeIntro(room));
                             },
                             OnExit = () =>
                             {
@@ -220,26 +221,11 @@ private void load(BeatmapListingOverlay beatmapListing, SettingsOverlay settings
             Buttons.OnBeatmapListing = () => beatmapListing?.ToggleVisibility();
 
             reappearSampleSwoosh = audio.Samples.Get(@"Menu/reappear-swoosh");
-
-            preloadSongSelect();
         }
 
         public void ReturnToOsuLogo() => Buttons.State = ButtonSystemState.Initial;
 
-        private void preloadSongSelect()
-        {
-            if (songSelect == null)
-                LoadComponentAsync(songSelect = new PlaySongSelect());
-        }
-
-        private void loadSoloSongSelect() => this.Push(consumeSongSelect());
-
-        private Screen consumeSongSelect()
-        {
-            var s = songSelect;
-            songSelect = null;
-            return s;
-        }
+        private void loadSoloSongSelect() => this.Push(new PlaySongSelect());
 
         public override void OnEntering(ScreenTransitionEvent e)
         {
@@ -373,9 +359,6 @@ public override void OnResuming(ScreenTransitionEvent e)
 
             ApplyToBackground(b => (b as BackgroundScreenDefault)?.Next());
 
-            // we may have consumed our preloaded instance, so let's make another.
-            preloadSongSelect();
-
             musicController.EnsurePlayingSomething();
 
             // Cycle tip on resuming
diff --git a/osu.Game/Screens/Menu/StarFountain.cs b/osu.Game/Screens/Menu/StarFountain.cs
index dd5171c6be2c..92e9dd6df907 100644
--- a/osu.Game/Screens/Menu/StarFountain.cs
+++ b/osu.Game/Screens/Menu/StarFountain.cs
@@ -21,9 +21,11 @@ public partial class StarFountain : SkinReloadableDrawable
         [BackgroundDependencyLoader]
         private void load()
         {
-            InternalChild = spewer = new StarFountainSpewer();
+            InternalChild = spewer = CreateSpewer();
         }
 
+        protected virtual StarFountainSpewer CreateSpewer() => new StarFountainSpewer();
+
         public void Shoot(int direction) => spewer.Shoot(direction);
 
         protected override void SkinChanged(ISkinSource skin)
@@ -38,17 +40,23 @@ public partial class StarFountainSpewer : ParticleSpewer
             private const int particle_duration_max = 1000;
 
             private double? lastShootTime;
-            private int lastShootDirection;
+
+            protected int LastShootDirection { get; private set; }
 
             protected override float ParticleGravity => 800;
 
-            private const double shoot_duration = 800;
+            protected virtual double ShootDuration => 800;
 
             [Resolved]
             private ISkinSource skin { get; set; } = null!;
 
             public StarFountainSpewer()
-                : base(null, 240, particle_duration_max)
+                : this(240)
+            {
+            }
+
+            protected StarFountainSpewer(int perSecond)
+                : base(null, perSecond, particle_duration_max)
             {
             }
 
@@ -67,16 +75,16 @@ protected override FallingParticle CreateParticle()
                     StartAngle = getRandomVariance(4),
                     EndAngle = getRandomVariance(2),
                     EndScale = 2.2f + getRandomVariance(0.4f),
-                    Velocity = new Vector2(getCurrentAngle(), -1400 + getRandomVariance(100)),
+                    Velocity = new Vector2(GetCurrentAngle(), -1400 + getRandomVariance(100)),
                 };
             }
 
-            private float getCurrentAngle()
+            protected virtual float GetCurrentAngle()
             {
-                const float x_velocity_from_direction = 500;
                 const float x_velocity_random_variance = 60;
+                const float x_velocity_from_direction = 500;
 
-                return lastShootDirection * x_velocity_from_direction * (float)(1 - 2 * (Clock.CurrentTime - lastShootTime!.Value) / shoot_duration) + getRandomVariance(x_velocity_random_variance);
+                return LastShootDirection * x_velocity_from_direction * (float)(1 - 2 * (Clock.CurrentTime - lastShootTime!.Value) / ShootDuration) + getRandomVariance(x_velocity_random_variance);
             }
 
             private ScheduledDelegate? deactivateDelegate;
@@ -86,10 +94,10 @@ public void Shoot(int direction)
                 Active.Value = true;
 
                 deactivateDelegate?.Cancel();
-                deactivateDelegate = Scheduler.AddDelayed(() => Active.Value = false, shoot_duration);
+                deactivateDelegate = Scheduler.AddDelayed(() => Active.Value = false, ShootDuration);
 
                 lastShootTime = Clock.CurrentTime;
-                lastShootDirection = direction;
+                LastShootDirection = direction;
             }
 
             private static float getRandomVariance(float variance) => RNG.NextSingle(-variance, variance);
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeIntro.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeIntro.cs
index e59031f66355..7f0f26097c8a 100644
--- a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeIntro.cs
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeIntro.cs
@@ -70,6 +70,9 @@ public partial class DailyChallengeIntro : OsuScreen
         [Resolved]
         private MusicController musicController { get; set; } = null!;
 
+        [Resolved]
+        private SessionStatics statics { get; set; } = null!;
+
         private Sample? dateWindupSample;
         private Sample? dateImpactSample;
         private Sample? beatmapWindupSample;
@@ -93,14 +96,15 @@ public DailyChallengeIntro(Room room)
         protected override BackgroundScreen CreateBackground() => new DailyChallengeIntroBackgroundScreen(colourProvider);
 
         [BackgroundDependencyLoader]
-        private void load(BeatmapDifficultyCache difficultyCache, BeatmapModelDownloader beatmapDownloader, OsuConfigManager config, AudioManager audio)
+        private void load(RulesetStore rulesets, BeatmapDifficultyCache difficultyCache, BeatmapModelDownloader beatmapDownloader, OsuConfigManager config, AudioManager audio)
         {
             const float horizontal_info_size = 500f;
 
-            Ruleset ruleset = Ruleset.Value.CreateInstance();
-
             StarRatingDisplay starRatingDisplay;
 
+            IBeatmapInfo beatmap = item.Beatmap;
+            Ruleset ruleset = rulesets.GetRuleset(item.Beatmap.Ruleset.ShortName)!.CreateInstance();
+
             InternalChildren = new Drawable[]
             {
                 beatmapAvailabilityTracker,
@@ -242,13 +246,13 @@ private void load(BeatmapDifficultyCache difficultyCache, BeatmapModelDownloader
                                                     Origin = Anchor.TopCentre,
                                                     Shear = new Vector2(-OsuGame.SHEAR, 0f),
                                                     MaxWidth = horizontal_info_size,
-                                                    Text = item.Beatmap.BeatmapSet!.Metadata.GetDisplayTitleRomanisable(false),
+                                                    Text = beatmap.BeatmapSet!.Metadata.GetDisplayTitleRomanisable(false),
                                                     Padding = new MarginPadding { Horizontal = 5f },
                                                     Font = OsuFont.GetFont(size: 26),
                                                 },
                                                 new TruncatingSpriteText
                                                 {
-                                                    Text = $"Difficulty: {item.Beatmap.DifficultyName}",
+                                                    Text = $"Difficulty: {beatmap.DifficultyName}",
                                                     Font = OsuFont.GetFont(size: 20, italics: true),
                                                     MaxWidth = horizontal_info_size,
                                                     Shear = new Vector2(-OsuGame.SHEAR, 0f),
@@ -257,7 +261,7 @@ private void load(BeatmapDifficultyCache difficultyCache, BeatmapModelDownloader
                                                 },
                                                 new TruncatingSpriteText
                                                 {
-                                                    Text = $"by {item.Beatmap.Metadata.Author.Username}",
+                                                    Text = $"by {beatmap.Metadata.Author.Username}",
                                                     Font = OsuFont.GetFont(size: 16, italics: true),
                                                     MaxWidth = horizontal_info_size,
                                                     Shear = new Vector2(-OsuGame.SHEAR, 0f),
@@ -309,14 +313,14 @@ private void load(BeatmapDifficultyCache difficultyCache, BeatmapModelDownloader
                 }
             };
 
-            starDifficulty = difficultyCache.GetBindableDifficulty(item.Beatmap);
+            starDifficulty = difficultyCache.GetBindableDifficulty(beatmap);
             starDifficulty.BindValueChanged(star =>
             {
                 if (star.NewValue != null)
                     starRatingDisplay.Current.Value = star.NewValue.Value;
             }, true);
 
-            LoadComponentAsync(new OnlineBeatmapSetCover(item.Beatmap.BeatmapSet as IBeatmapSetOnlineInfo)
+            LoadComponentAsync(new OnlineBeatmapSetCover(beatmap.BeatmapSet as IBeatmapSetOnlineInfo)
             {
                 RelativeSizeAxes = Axes.Both,
                 Anchor = Anchor.Centre,
@@ -334,8 +338,8 @@ private void load(BeatmapDifficultyCache difficultyCache, BeatmapModelDownloader
 
             if (config.Get<bool>(OsuSetting.AutomaticallyDownloadMissingBeatmaps))
             {
-                if (!beatmapManager.IsAvailableLocally(new BeatmapSetInfo { OnlineID = item.Beatmap.BeatmapSet!.OnlineID }))
-                    beatmapDownloader.Download(item.Beatmap.BeatmapSet!, config.Get<bool>(OsuSetting.PreferNoVideo));
+                if (!beatmapManager.IsAvailableLocally(new BeatmapSetInfo { OnlineID = beatmap.BeatmapSet!.OnlineID }))
+                    beatmapDownloader.Download(beatmap.BeatmapSet!, config.Get<bool>(OsuSetting.PreferNoVideo));
             }
 
             dateWindupSample = audio.Samples.Get(@"DailyChallenge/date-windup");
@@ -461,6 +465,8 @@ private void beginAnimation()
                         {
                             Schedule(() =>
                             {
+                                statics.SetValue(Static.DailyChallengeIntroPlayed, true);
+
                                 if (this.IsCurrentScreen())
                                     this.Push(new DailyChallenge(room));
                             });
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/NewDailyChallengeNotification.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/NewDailyChallengeNotification.cs
index ea19828a2106..7ae6992bec75 100644
--- a/osu.Game/Screens/OnlinePlay/DailyChallenge/NewDailyChallengeNotification.cs
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/NewDailyChallengeNotification.cs
@@ -5,6 +5,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps.Drawables.Cards;
+using osu.Game.Configuration;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays.Notifications;
@@ -25,13 +26,17 @@ public NewDailyChallengeNotification(Room room)
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuGame? game)
+        private void load(OsuGame? game, SessionStatics statics)
         {
             Text = DailyChallengeStrings.ChallengeLiveNotification;
             Content.Add(card = new BeatmapCardNano((APIBeatmapSet)room.Playlist.Single().Beatmap.BeatmapSet!));
             Activated = () =>
             {
-                game?.PerformFromScreen(s => s.Push(new DailyChallenge(room)), [typeof(MainMenu)]);
+                if (statics.Get<bool>(Static.DailyChallengeIntroPlayed))
+                    game?.PerformFromScreen(s => s.Push(new DailyChallenge(room)), [typeof(MainMenu)]);
+                else
+                    game?.PerformFromScreen(s => s.Push(new DailyChallengeIntro(room)), [typeof(MainMenu)]);
+
                 return true;
             };
         }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerSpectateButton.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerSpectateButton.cs
index 1d308ed39cb5..ea7ab2dce34d 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerSpectateButton.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerSpectateButton.cs
@@ -1,14 +1,18 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
+using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
 using osuTK;
 
 namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
@@ -16,12 +20,12 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
     public partial class MultiplayerSpectateButton : MultiplayerRoomComposite
     {
         [Resolved]
-        private OngoingOperationTracker ongoingOperationTracker { get; set; }
+        private OngoingOperationTracker ongoingOperationTracker { get; set; } = null!;
 
         [Resolved]
-        private OsuColour colours { get; set; }
+        private OsuColour colours { get; set; } = null!;
 
-        private IBindable<bool> operationInProgress;
+        private IBindable<bool> operationInProgress = null!;
 
         private readonly RoundedButton button;
 
@@ -46,10 +50,20 @@ private void onClick()
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OsuConfigManager config)
         {
             operationInProgress = ongoingOperationTracker.InProgress.GetBoundCopy();
             operationInProgress.BindValueChanged(_ => updateState());
+
+            automaticallyDownload = config.GetBindable<bool>(OsuSetting.AutomaticallyDownloadMissingBeatmaps);
+            automaticallyDownload.BindValueChanged(_ => Scheduler.AddOnce(checkForAutomaticDownload));
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            CurrentPlaylistItem.BindValueChanged(_ => Scheduler.AddOnce(checkForAutomaticDownload), true);
         }
 
         protected override void OnRoomUpdated()
@@ -77,6 +91,64 @@ private void updateState()
             button.Enabled.Value = Client.Room != null
                                    && Client.Room.State != MultiplayerRoomState.Closed
                                    && !operationInProgress.Value;
+
+            Scheduler.AddOnce(checkForAutomaticDownload);
+        }
+
+        #region Automatic download handling
+
+        [Resolved]
+        private BeatmapLookupCache beatmapLookupCache { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapModelDownloader beatmapDownloader { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapManager beatmaps { get; set; } = null!;
+
+        private Bindable<bool> automaticallyDownload = null!;
+
+        private CancellationTokenSource? downloadCheckCancellation;
+
+        private void checkForAutomaticDownload()
+        {
+            PlaylistItem? currentItem = CurrentPlaylistItem.Value;
+
+            downloadCheckCancellation?.Cancel();
+
+            if (currentItem == null)
+                return;
+
+            if (!automaticallyDownload.Value)
+                return;
+
+            // While we can support automatic downloads when not spectating, there are some usability concerns.
+            // - In host rotate mode, this could potentially be unwanted by some users (even though they want automatic downloads everywhere else).
+            // - When first joining a room, the expectation should be that the user is checking out the room, and they may not immediately want to download the selected beatmap.
+            //
+            // Rather than over-complicating this flow, let's only auto-download when spectating for the time being.
+            // A potential path forward would be to have a local auto-download checkbox above the playlist item list area.
+            if (Client.LocalUser?.State != MultiplayerUserState.Spectating)
+                return;
+
+            // 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
+                .GetBeatmapAsync(currentItem.Beatmap.OnlineID, (downloadCheckCancellation = new CancellationTokenSource()).Token)
+                .ContinueWith(resolved => Schedule(() =>
+                {
+                    var beatmapSet = resolved.GetResultSafely()?.BeatmapSet;
+
+                    if (beatmapSet == null)
+                        return;
+
+                    if (beatmaps.IsAvailableLocally(new BeatmapSetInfo { OnlineID = beatmapSet.OnlineID }))
+                        return;
+
+                    beatmapDownloader.Download(beatmapSet);
+                }));
         }
+
+        #endregion
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Multiplayer.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Multiplayer.cs
index 7d27725775c1..bf316bb3da5b 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Multiplayer.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Multiplayer.cs
@@ -108,7 +108,10 @@ protected override void Dispose(bool isDisposing)
             base.Dispose(isDisposing);
 
             if (client.IsNotNull())
+            {
                 client.RoomUpdated -= onRoomUpdated;
+                client.GameplayAborted -= onGameplayAborted;
+            }
         }
     }
 }
diff --git a/osu.Game/Screens/Play/Break/LetterboxOverlay.cs b/osu.Game/Screens/Play/Break/LetterboxOverlay.cs
index c4e2dbf403ce..9308a02b0731 100644
--- a/osu.Game/Screens/Play/Break/LetterboxOverlay.cs
+++ b/osu.Game/Screens/Play/Break/LetterboxOverlay.cs
@@ -11,12 +11,12 @@ namespace osu.Game.Screens.Play.Break
 {
     public partial class LetterboxOverlay : CompositeDrawable
     {
-        private const int height = 350;
-
         private static readonly Color4 transparent_black = new Color4(0, 0, 0, 0);
 
         public LetterboxOverlay()
         {
+            const int height = 150;
+
             RelativeSizeAxes = Axes.Both;
             InternalChildren = new Drawable[]
             {
diff --git a/osu.Game/Screens/Play/BreakOverlay.cs b/osu.Game/Screens/Play/BreakOverlay.cs
index ece3105b4223..1fdb9402bce8 100644
--- a/osu.Game/Screens/Play/BreakOverlay.cs
+++ b/osu.Game/Screens/Play/BreakOverlay.cs
@@ -1,23 +1,27 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
-using System.Collections.Generic;
+using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play.Break;
+using osu.Game.Utils;
 
 namespace osu.Game.Screens.Play
 {
-    public partial class BreakOverlay : Container
+    public partial class BreakOverlay : BeatSyncedContainer
     {
         /// <summary>
         /// The duration of the break overlay fading.
@@ -25,26 +29,14 @@ public partial class BreakOverlay : Container
         public const double BREAK_FADE_DURATION = BreakPeriod.MIN_BREAK_DURATION / 2;
 
         private const float remaining_time_container_max_size = 0.3f;
-        private const int vertical_margin = 25;
+        private const int vertical_margin = 15;
 
         private readonly Container fadeContainer;
 
-        private IReadOnlyList<BreakPeriod> breaks;
-
-        public IReadOnlyList<BreakPeriod> Breaks
-        {
-            get => breaks;
-            set
-            {
-                breaks = value;
-
-                if (IsLoaded)
-                    initializeBreaks();
-            }
-        }
-
         public override bool RemoveCompletedTransforms => false;
 
+        public BreakTracker BreakTracker { get; init; } = null!;
+
         private readonly Container remainingTimeAdjustmentBox;
         private readonly Container remainingTimeBox;
         private readonly RemainingTimeCounter remainingTimeCounter;
@@ -52,11 +44,19 @@ public IReadOnlyList<BreakPeriod> Breaks
         private readonly ScoreProcessor scoreProcessor;
         private readonly BreakInfo info;
 
+        private readonly IBindable<Period?> currentPeriod = new Bindable<Period?>();
+
         public BreakOverlay(bool letterboxing, ScoreProcessor scoreProcessor)
         {
             this.scoreProcessor = scoreProcessor;
             RelativeSizeAxes = Axes.Both;
 
+            MinimumBeatLength = 200;
+
+            // Doesn't play well with pause/unpause.
+            // This might mean that some beats don't animate if the user is running <60fps, but we'll deal with that if anyone notices.
+            AllowMistimedEventFiring = false;
+
             Child = fadeContainer = new Container
             {
                 Alpha = 0,
@@ -69,6 +69,30 @@ public BreakOverlay(bool letterboxing, ScoreProcessor scoreProcessor)
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
                     },
+                    new CircularContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Width = 80,
+                        Height = 4,
+                        Masking = true,
+                        EdgeEffect = new EdgeEffectParameters
+                        {
+                            Type = EdgeEffectType.Shadow,
+                            Radius = 260,
+                            Colour = OsuColour.Gray(0.2f).Opacity(0.8f),
+                            Roundness = 12
+                        },
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                Alpha = 0,
+                                AlwaysPresent = true,
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                        }
+                    },
                     remainingTimeAdjustmentBox = new Container
                     {
                         Anchor = Anchor.Centre,
@@ -89,13 +113,13 @@ public BreakOverlay(bool letterboxing, ScoreProcessor scoreProcessor)
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.BottomCentre,
-                        Margin = new MarginPadding { Bottom = vertical_margin },
+                        Y = -vertical_margin,
                     },
                     info = new BreakInfo
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.TopCentre,
-                        Margin = new MarginPadding { Top = vertical_margin },
+                        Y = vertical_margin,
                     },
                     breakArrows = new BreakArrows
                     {
@@ -109,56 +133,76 @@ public BreakOverlay(bool letterboxing, ScoreProcessor scoreProcessor)
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            initializeBreaks();
 
-            if (scoreProcessor != null)
-            {
-                info.AccuracyDisplay.Current.BindTo(scoreProcessor.Accuracy);
-                ((IBindable<ScoreRank>)info.GradeDisplay.Current).BindTo(scoreProcessor.Rank);
-            }
+            info.AccuracyDisplay.Current.BindTo(scoreProcessor.Accuracy);
+            ((IBindable<ScoreRank>)info.GradeDisplay.Current).BindTo(scoreProcessor.Rank);
+
+            currentPeriod.BindTo(BreakTracker.CurrentPeriod);
+            currentPeriod.BindValueChanged(updateDisplay, true);
         }
 
+        private float remainingTimeForCurrentPeriod =>
+            currentPeriod.Value == null ? 0 : (float)Math.Max(0, (currentPeriod.Value.Value.End - Time.Current - BREAK_FADE_DURATION) / currentPeriod.Value.Value.Duration);
+
         protected override void Update()
         {
             base.Update();
 
             remainingTimeBox.Height = Math.Min(8, remainingTimeBox.DrawWidth);
+
+            // Keep things simple by resetting beat synced transforms on a rewind.
+            if (Clock.ElapsedFrameTime < 0)
+            {
+                remainingTimeBox.ClearTransforms(targetMember: nameof(Width));
+                remainingTimeBox.Width = remainingTimeForCurrentPeriod;
+            }
+        }
+
+        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
+        {
+            base.OnNewBeat(beatIndex, timingPoint, effectPoint, amplitudes);
+
+            if (currentPeriod.Value == null)
+                return;
+
+            float timeBoxTargetWidth = (float)Math.Max(0, (remainingTimeForCurrentPeriod - timingPoint.BeatLength / currentPeriod.Value.Value.Duration));
+            remainingTimeBox.ResizeWidthTo(timeBoxTargetWidth, timingPoint.BeatLength * 2, Easing.OutQuint);
         }
 
-        private void initializeBreaks()
+        private void updateDisplay(ValueChangedEvent<Period?> period)
         {
             FinishTransforms(true);
             Scheduler.CancelDelayedTasks();
 
-            if (breaks == null) return; // we need breaks.
+            if (period.NewValue == null)
+                return;
 
-            foreach (var b in breaks)
+            var b = period.NewValue.Value;
+
+            using (BeginAbsoluteSequence(b.Start))
             {
-                if (!b.HasEffect)
-                    continue;
+                fadeContainer.FadeIn(BREAK_FADE_DURATION);
+                breakArrows.Show(BREAK_FADE_DURATION);
 
-                using (BeginAbsoluteSequence(b.StartTime))
-                {
-                    fadeContainer.FadeIn(BREAK_FADE_DURATION);
-                    breakArrows.Show(BREAK_FADE_DURATION);
+                remainingTimeAdjustmentBox
+                    .ResizeWidthTo(remaining_time_container_max_size, BREAK_FADE_DURATION, Easing.OutQuint)
+                    .Delay(b.Duration - BREAK_FADE_DURATION)
+                    .ResizeWidthTo(0);
 
-                    remainingTimeAdjustmentBox
-                        .ResizeWidthTo(remaining_time_container_max_size, BREAK_FADE_DURATION, Easing.OutQuint)
-                        .Delay(b.Duration - BREAK_FADE_DURATION)
-                        .ResizeWidthTo(0);
+                remainingTimeBox.ResizeWidthTo(remainingTimeForCurrentPeriod);
 
-                    remainingTimeBox
-                        .ResizeWidthTo(0, b.Duration - BREAK_FADE_DURATION)
-                        .Then()
-                        .ResizeWidthTo(1);
+                remainingTimeCounter.CountTo(b.Duration).CountTo(0, b.Duration);
 
-                    remainingTimeCounter.CountTo(b.Duration).CountTo(0, b.Duration);
+                remainingTimeCounter.MoveToX(-50)
+                                    .MoveToX(0, BREAK_FADE_DURATION, Easing.OutQuint);
 
-                    using (BeginDelayedSequence(b.Duration - BREAK_FADE_DURATION))
-                    {
-                        fadeContainer.FadeOut(BREAK_FADE_DURATION);
-                        breakArrows.Hide(BREAK_FADE_DURATION);
-                    }
+                info.MoveToX(50)
+                    .MoveToX(0, BREAK_FADE_DURATION, Easing.OutQuint);
+
+                using (BeginDelayedSequence(b.Duration - BREAK_FADE_DURATION))
+                {
+                    fadeContainer.FadeOut(BREAK_FADE_DURATION);
+                    breakArrows.Hide(BREAK_FADE_DURATION);
                 }
             }
         }
diff --git a/osu.Game/Screens/Play/BreakTracker.cs b/osu.Game/Screens/Play/BreakTracker.cs
index 20ef1dc4bfb0..3c3f31053a0d 100644
--- a/osu.Game/Screens/Play/BreakTracker.cs
+++ b/osu.Game/Screens/Play/BreakTracker.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
@@ -18,7 +16,7 @@ public partial class BreakTracker : Component
         private readonly ScoreProcessor scoreProcessor;
         private readonly double gameplayStartTime;
 
-        private PeriodTracker breaks;
+        private PeriodTracker breaks = new PeriodTracker(Enumerable.Empty<Period>());
 
         /// <summary>
         /// Whether the gameplay is currently in a break.
@@ -27,6 +25,8 @@ public partial class BreakTracker : Component
 
         private readonly BindableBool isBreakTime = new BindableBool(true);
 
+        public readonly Bindable<Period?> CurrentPeriod = new Bindable<Period?>();
+
         public IReadOnlyList<BreakPeriod> Breaks
         {
             set
@@ -39,7 +39,7 @@ public IReadOnlyList<BreakPeriod> Breaks
             }
         }
 
-        public BreakTracker(double gameplayStartTime = 0, ScoreProcessor scoreProcessor = null)
+        public BreakTracker(double gameplayStartTime, ScoreProcessor scoreProcessor)
         {
             this.gameplayStartTime = gameplayStartTime;
             this.scoreProcessor = scoreProcessor;
@@ -55,9 +55,16 @@ private void updateBreakTime()
         {
             double time = Clock.CurrentTime;
 
-            isBreakTime.Value = breaks?.IsInAny(time) == true
-                                || time < gameplayStartTime
-                                || scoreProcessor?.HasCompleted.Value == true;
+            if (breaks.IsInAny(time, out var currentBreak))
+            {
+                CurrentPeriod.Value = currentBreak;
+                isBreakTime.Value = true;
+            }
+            else
+            {
+                CurrentPeriod.Value = null;
+                isBreakTime.Value = time < gameplayStartTime || scoreProcessor.HasCompleted.Value;
+            }
         }
     }
 }
diff --git a/osu.Game/Screens/Play/DimmableStoryboard.cs b/osu.Game/Screens/Play/DimmableStoryboard.cs
index 40cc0f66ad73..84d99ea86380 100644
--- a/osu.Game/Screens/Play/DimmableStoryboard.cs
+++ b/osu.Game/Screens/Play/DimmableStoryboard.cs
@@ -3,7 +3,9 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
@@ -24,6 +26,21 @@ public partial class DimmableStoryboard : UserDimContainer
         private readonly Storyboard storyboard;
         private readonly IReadOnlyList<Mod> mods;
 
+        /// <summary>
+        /// In certain circumstances, the storyboard cannot be hidden entirely even if it is fully dimmed. Such circumstances include:
+        /// <list type="bullet">
+        /// <item>
+        /// cases where the storyboard has an overlay layer sprite, as it should continue to display fully dimmed
+        /// <i>in front of</i> the playfield (https://github.com/ppy/osu/issues/29867),
+        /// </item>
+        /// <item>
+        /// cases where the storyboard includes samples - as they are played back via drawable samples,
+        /// they must be present for the playback to occur (https://github.com/ppy/osu/issues/9315).
+        /// </item>
+        /// </list>
+        /// </summary>
+        private readonly Lazy<bool> storyboardMustAlwaysBePresent;
+
         private DrawableStoryboard drawableStoryboard;
 
         /// <summary>
@@ -38,6 +55,8 @@ public DimmableStoryboard(Storyboard storyboard, IReadOnlyList<Mod> mods)
         {
             this.storyboard = storyboard;
             this.mods = mods;
+
+            storyboardMustAlwaysBePresent = new Lazy<bool>(() => storyboard.GetLayer(@"Overlay").Elements.Any() || storyboard.Layers.Any(l => l.Elements.OfType<StoryboardSampleInfo>().Any()));
         }
 
         [BackgroundDependencyLoader]
@@ -54,7 +73,7 @@ protected override void LoadComplete()
             base.LoadComplete();
         }
 
-        protected override bool ShowDimContent => IgnoreUserSettings.Value || (ShowStoryboard.Value && DimLevel < 1);
+        protected override bool ShowDimContent => IgnoreUserSettings.Value || (ShowStoryboard.Value && (DimLevel < 1 || storyboardMustAlwaysBePresent.Value));
 
         private void initializeStoryboard(bool async)
         {
diff --git a/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs b/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs
index ebebfebfb3f9..92ac863e983f 100644
--- a/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs
@@ -9,6 +9,7 @@
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Localisation.HUD;
+using osu.Game.Localisation.SkinComponents;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Screens.Play.HUD
@@ -29,6 +30,9 @@ public partial class ArgonSongProgress : SongProgress
         [SettingSource(typeof(SongProgressStrings), nameof(SongProgressStrings.ShowTime), nameof(SongProgressStrings.ShowTimeDescription))]
         public Bindable<bool> ShowTime { get; } = new BindableBool(true);
 
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour), nameof(SkinnableComponentStrings.ColourDescription))]
+        public BindableColour4 AccentColour { get; } = new BindableColour4(Colour4.White);
+
         [Resolved]
         private Player? player { get; set; }
 
@@ -94,6 +98,7 @@ protected override void LoadComplete()
             Interactive.BindValueChanged(_ => bar.Interactive = Interactive.Value, true);
             ShowGraph.BindValueChanged(_ => updateGraphVisibility(), true);
             ShowTime.BindValueChanged(_ => info.FadeTo(ShowTime.Value ? 1 : 0, 200, Easing.In), true);
+            AccentColour.BindValueChanged(_ => Colour = AccentColour.Value, true);
         }
 
         protected override void UpdateObjects(IEnumerable<HitObject> objects)
diff --git a/osu.Game/Screens/Play/HUD/ArgonWedgePiece.cs b/osu.Game/Screens/Play/HUD/ArgonWedgePiece.cs
index 3c2e3e05eaa9..46a658cd1c3f 100644
--- a/osu.Game/Screens/Play/HUD/ArgonWedgePiece.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonWedgePiece.cs
@@ -9,6 +9,7 @@
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Configuration;
+using osu.Game.Localisation.SkinComponents;
 using osu.Game.Skinning;
 using osuTK;
 
@@ -21,6 +22,9 @@ public partial class ArgonWedgePiece : CompositeDrawable, ISerialisableDrawable
         [SettingSource("Inverted shear")]
         public BindableBool InvertShear { get; } = new BindableBool();
 
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour), nameof(SkinnableComponentStrings.ColourDescription))]
+        public BindableColour4 AccentColour { get; } = new BindableColour4(Color4Extensions.FromHex("#66CCFF"));
+
         public ArgonWedgePiece()
         {
             CornerRadius = 10f;
@@ -37,7 +41,6 @@ private void load()
             InternalChild = new Box
             {
                 RelativeSizeAxes = Axes.Both,
-                Colour = ColourInfo.GradientVertical(Color4Extensions.FromHex("#66CCFF").Opacity(0.0f), Color4Extensions.FromHex("#66CCFF").Opacity(0.25f)),
             };
         }
 
@@ -46,6 +49,7 @@ protected override void LoadComplete()
             base.LoadComplete();
 
             InvertShear.BindValueChanged(v => Shear = new Vector2(0.8f, 0f) * (v.NewValue ? -1 : 1), true);
+            AccentColour.BindValueChanged(c => InternalChild.Colour = ColourInfo.GradientVertical(AccentColour.Value.Opacity(0.0f), AccentColour.Value.Opacity(0.25f)), true);
         }
     }
 }
diff --git a/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs b/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs
index 6b2bb2b71836..4e41901ee3b4 100644
--- a/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs
+++ b/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs
@@ -10,6 +10,7 @@
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Localisation.HUD;
+using osu.Game.Localisation.SkinComponents;
 using osu.Game.Rulesets.Objects;
 using osuTK;
 
@@ -36,6 +37,9 @@ public partial class DefaultSongProgress : SongProgress
         [SettingSource(typeof(SongProgressStrings), nameof(SongProgressStrings.ShowTime), nameof(SongProgressStrings.ShowTimeDescription))]
         public Bindable<bool> ShowTime { get; } = new BindableBool(true);
 
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour), nameof(SkinnableComponentStrings.ColourDescription))]
+        public BindableColour4 AccentColour { get; } = new BindableColour4(Colour4.White);
+
         [Resolved]
         private Player? player { get; set; }
 
@@ -86,6 +90,7 @@ protected override void LoadComplete()
             Interactive.BindValueChanged(_ => updateBarVisibility(), true);
             ShowGraph.BindValueChanged(_ => updateGraphVisibility(), true);
             ShowTime.BindValueChanged(_ => updateTimeVisibility(), true);
+            AccentColour.BindValueChanged(_ => Colour = AccentColour.Value, true);
 
             base.LoadComplete();
         }
diff --git a/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs b/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs
index 6d045e5f01cb..89d083eca994 100644
--- a/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs
+++ b/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs
@@ -30,6 +30,8 @@ public partial class HoldForMenuButton : FillFlowContainer
     {
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
+        public override bool PropagatePositionalInputSubTree => alwaysShow.Value || touchActive.Value;
+
         public readonly Bindable<bool> IsPaused = new Bindable<bool>();
 
         public readonly Bindable<bool> ReplayLoaded = new Bindable<bool>();
@@ -40,6 +42,8 @@ public partial class HoldForMenuButton : FillFlowContainer
 
         private OsuSpriteText text;
 
+        private Bindable<bool> alwaysShow;
+
         public HoldForMenuButton()
         {
             Direction = FillDirection.Horizontal;
@@ -50,7 +54,7 @@ public HoldForMenuButton()
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(Player player)
+        private void load(Player player, OsuConfigManager config)
         {
             Children = new Drawable[]
             {
@@ -71,6 +75,8 @@ private void load(Player player)
             };
 
             AutoSizeAxes = Axes.Both;
+
+            alwaysShow = config.GetBindable<bool>(OsuSetting.AlwaysShowHoldForMenuButton);
         }
 
         [Resolved]
@@ -117,9 +123,14 @@ protected override void Update()
         {
             base.Update();
 
+            // While the button is hovered or still animating, keep fully visible.
             if (text.Alpha > 0 || button.Progress.Value > 0 || button.IsHovered)
                 Alpha = 1;
-            else
+            // When touch input is detected, keep visible at a constant opacity.
+            else if (touchActive.Value)
+                Alpha = 0.5f;
+            // Otherwise, if the user chooses, show it when the mouse is nearby.
+            else if (alwaysShow.Value)
             {
                 float minAlpha = touchActive.Value ? .08f : 0;
 
@@ -127,6 +138,8 @@ protected override void Update()
                     Math.Clamp(Clock.ElapsedFrameTime, 0, 200),
                     Alpha, Math.Clamp(1 - positionalAdjust, minAlpha, 1), 0, 200, Easing.OutQuint);
             }
+            else
+                Alpha = 0;
         }
 
         private partial class HoldButton : HoldToConfirmContainer, IKeyBindingHandler<GlobalAction>
diff --git a/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCount.cs b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCount.cs
new file mode 100644
index 000000000000..ad70e519a26d
--- /dev/null
+++ b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCount.cs
@@ -0,0 +1,18 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Localisation;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Screens.Play.HUD.JudgementCounter
+{
+    public struct JudgementCount
+    {
+        public LocalisableString DisplayName { get; set; }
+
+        public HitResult[] Types { get; set; }
+
+        public BindableInt ResultCount { get; set; }
+    }
+}
diff --git a/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCountController.cs b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCountController.cs
index 8134c97bac3b..c00cb3487bb1 100644
--- a/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCountController.cs
+++ b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCountController.cs
@@ -6,7 +6,6 @@
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Localisation;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
@@ -53,10 +52,29 @@ protected override void LoadComplete()
         {
             base.LoadComplete();
 
+            scoreProcessor.OnResetFromReplayFrame += updateAllCountsFromReplayFrame;
             scoreProcessor.NewJudgement += judgement => updateCount(judgement, false);
             scoreProcessor.JudgementReverted += judgement => updateCount(judgement, true);
         }
 
+        private bool hasUpdatedCountsFromReplayFrame;
+
+        private void updateAllCountsFromReplayFrame()
+        {
+            if (hasUpdatedCountsFromReplayFrame)
+                return;
+
+            foreach (var kvp in scoreProcessor.Statistics)
+            {
+                if (!results.TryGetValue(kvp.Key, out var count))
+                    continue;
+
+                count.ResultCount.Value = kvp.Value;
+            }
+
+            hasUpdatedCountsFromReplayFrame = true;
+        }
+
         private void updateCount(JudgementResult judgement, bool revert)
         {
             if (!results.TryGetValue(judgement.Type, out var count))
@@ -67,14 +85,5 @@ private void updateCount(JudgementResult judgement, bool revert)
             else
                 count.ResultCount.Value++;
         }
-
-        public struct JudgementCount
-        {
-            public LocalisableString DisplayName { get; set; }
-
-            public HitResult[] Types { get; set; }
-
-            public BindableInt ResultCount { get; set; }
-        }
     }
 }
diff --git a/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounter.cs b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounter.cs
index 45ed8d749bda..d69416f34a0f 100644
--- a/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounter.cs
+++ b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounter.cs
@@ -9,7 +9,6 @@
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Rulesets;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Screens.Play.HUD.JudgementCounter
@@ -19,16 +18,16 @@ public partial class JudgementCounter : VisibilityContainer
         public BindableBool ShowName = new BindableBool();
         public Bindable<FillDirection> Direction = new Bindable<FillDirection>();
 
-        public readonly JudgementCountController.JudgementCount Result;
+        public readonly JudgementCount Result;
 
-        public JudgementCounter(JudgementCountController.JudgementCount result) => Result = result;
+        public JudgementCounter(JudgementCount result) => Result = result;
 
         public OsuSpriteText ResultName = null!;
         private FillFlowContainer flowContainer = null!;
         private JudgementRollingCounter counter = null!;
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, IBindable<RulesetInfo> ruleset)
+        private void load(OsuColour colours)
         {
             AutoSizeAxes = Axes.Both;
 
diff --git a/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounterDisplay.cs b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounterDisplay.cs
index 25e546420567..bc953435b772 100644
--- a/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounterDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounterDisplay.cs
@@ -126,7 +126,7 @@ private FillDirection getFillDirection(Direction flow)
             }
         }
 
-        private JudgementCounter createCounter(JudgementCountController.JudgementCount info) =>
+        private JudgementCounter createCounter(JudgementCount info) =>
             new JudgementCounter(info)
             {
                 State = { Value = Visibility.Hidden },
diff --git a/osu.Game/Screens/Play/HUD/PlayerAvatar.cs b/osu.Game/Screens/Play/HUD/PlayerAvatar.cs
index 06d0f7bc9a29..8e4406c2c173 100644
--- a/osu.Game/Screens/Play/HUD/PlayerAvatar.cs
+++ b/osu.Game/Screens/Play/HUD/PlayerAvatar.cs
@@ -39,14 +39,23 @@ public partial class PlayerAvatar : CompositeDrawable, ISerialisableDrawable
 
         private IBindable<APIUser>? apiUser;
 
+        private readonly Container cornerContainer;
+
         public PlayerAvatar()
         {
             Size = new Vector2(default_size);
 
-            InternalChild = avatar = new UpdateableAvatar(isInteractive: false)
+            InternalChild = cornerContainer = new Container
             {
+                Masking = true,
                 RelativeSizeAxes = Axes.Both,
-                Masking = true
+                Child = avatar = new UpdateableAvatar(isInteractive: false)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    FillMode = FillMode.Fill,
+                }
             };
         }
 
@@ -66,7 +75,7 @@ protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            CornerRadius.BindValueChanged(e => avatar.CornerRadius = e.NewValue * default_size, true);
+            CornerRadius.BindValueChanged(e => cornerContainer.CornerRadius = e.NewValue * default_size, true);
         }
 
         public bool UsesFixedAnchor { get; set; }
diff --git a/osu.Game/Screens/Play/HUDOverlay.cs b/osu.Game/Screens/Play/HUDOverlay.cs
index ef3bb7c04a0f..ac1b9ce34fa8 100644
--- a/osu.Game/Screens/Play/HUDOverlay.cs
+++ b/osu.Game/Screens/Play/HUDOverlay.cs
@@ -95,10 +95,10 @@ protected override bool ShouldBeConsideredForInput(Drawable child)
 
         private readonly BindableBool holdingForHUD = new BindableBool();
 
-        private readonly SkinComponentsContainer mainComponents;
+        private readonly SkinnableContainer mainComponents;
 
         [CanBeNull]
-        private readonly SkinComponentsContainer rulesetComponents;
+        private readonly SkinnableContainer rulesetComponents;
 
         /// <summary>
         /// A flow which sits at the left side of the screen to house leaderboard (and related) components.
@@ -109,7 +109,7 @@ protected override bool ShouldBeConsideredForInput(Drawable child)
         private readonly List<Drawable> hideTargets;
 
         /// <summary>
-        /// The container for skin components attached to <see cref="SkinComponentsContainerLookup.TargetArea.Playfield"/>
+        /// The container for skin components attached to <see cref="GlobalSkinnableContainers.Playfield"/>
         /// </summary>
         internal readonly Drawable PlayfieldSkinLayer;
 
@@ -132,7 +132,7 @@ public HUDOverlay([CanBeNull] DrawableRuleset drawableRuleset, IReadOnlyList<Mod
                     ? (rulesetComponents = new HUDComponentsContainer(drawableRuleset.Ruleset.RulesetInfo) { AlwaysPresent = true, })
                     : Empty(),
                 PlayfieldSkinLayer = drawableRuleset != null
-                    ? new SkinComponentsContainer(new SkinComponentsContainerLookup(SkinComponentsContainerLookup.TargetArea.Playfield, drawableRuleset.Ruleset.RulesetInfo)) { AlwaysPresent = true, }
+                    ? new SkinnableContainer(new GlobalSkinnableContainerLookup(GlobalSkinnableContainers.Playfield, drawableRuleset.Ruleset.RulesetInfo)) { AlwaysPresent = true, }
                     : Empty(),
                 topRightElements = new FillFlowContainer
                 {
@@ -280,7 +280,7 @@ protected override void Update()
             else
                 bottomRightElements.Y = 0;
 
-            void processDrawables(SkinComponentsContainer components)
+            void processDrawables(SkinnableContainer components)
             {
                 // Avoid using foreach due to missing GetEnumerator implementation.
                 // See https://github.com/ppy/osu-framework/blob/e10051e6643731e393b09de40a3a3d209a545031/osu.Framework/Bindables/IBindableList.cs#L41-L44.
@@ -440,7 +440,7 @@ public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
             }
         }
 
-        private partial class HUDComponentsContainer : SkinComponentsContainer
+        private partial class HUDComponentsContainer : SkinnableContainer
         {
             private Bindable<ScoringMode> scoringMode;
 
@@ -448,7 +448,7 @@ private partial class HUDComponentsContainer : SkinComponentsContainer
             private OsuConfigManager config { get; set; }
 
             public HUDComponentsContainer([CanBeNull] RulesetInfo ruleset = null)
-                : base(new SkinComponentsContainerLookup(SkinComponentsContainerLookup.TargetArea.MainHUDComponents, ruleset))
+                : base(new GlobalSkinnableContainerLookup(GlobalSkinnableContainers.MainHUDComponents, ruleset))
             {
                 RelativeSizeAxes = Axes.Both;
             }
diff --git a/osu.Game/Screens/Play/KiaiGameplayFountains.cs b/osu.Game/Screens/Play/KiaiGameplayFountains.cs
new file mode 100644
index 000000000000..7659c61123d2
--- /dev/null
+++ b/osu.Game/Screens/Play/KiaiGameplayFountains.cs
@@ -0,0 +1,94 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable disable
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics.Containers;
+using osu.Game.Screens.Menu;
+
+namespace osu.Game.Screens.Play
+{
+    public partial class KiaiGameplayFountains : BeatSyncedContainer
+    {
+        private StarFountain leftFountain = null!;
+        private StarFountain rightFountain = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            Children = new[]
+            {
+                leftFountain = new GameplayStarFountain
+                {
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                    X = 75,
+                },
+                rightFountain = new GameplayStarFountain
+                {
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.BottomRight,
+                    X = -75,
+                },
+            };
+        }
+
+        private bool isTriggered;
+
+        private double? lastTrigger;
+
+        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
+        {
+            base.OnNewBeat(beatIndex, timingPoint, effectPoint, amplitudes);
+
+            if (effectPoint.KiaiMode && !isTriggered)
+            {
+                bool isNearEffectPoint = Math.Abs(BeatSyncSource.Clock.CurrentTime - effectPoint.Time) < 500;
+                if (isNearEffectPoint)
+                    Shoot();
+            }
+
+            isTriggered = effectPoint.KiaiMode;
+        }
+
+        public void Shoot()
+        {
+            if (lastTrigger != null && Clock.CurrentTime - lastTrigger < 500)
+                return;
+
+            leftFountain.Shoot(1);
+            rightFountain.Shoot(-1);
+            lastTrigger = Clock.CurrentTime;
+        }
+
+        public partial class GameplayStarFountain : StarFountain
+        {
+            protected override StarFountainSpewer CreateSpewer() => new GameplayStarFountainSpewer();
+
+            private partial class GameplayStarFountainSpewer : StarFountainSpewer
+            {
+                protected override double ShootDuration => 400;
+
+                public GameplayStarFountainSpewer()
+                    : base(perSecond: 180)
+                {
+                }
+
+                protected override float GetCurrentAngle()
+                {
+                    const float x_velocity_from_direction = 450;
+                    const float x_velocity_to_direction = 600;
+
+                    return LastShootDirection * RNG.NextSingle(x_velocity_from_direction, x_velocity_to_direction);
+                }
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Play/Player.cs b/osu.Game/Screens/Play/Player.cs
index 9a3d83782f59..2a66c3d5d303 100644
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@@ -405,8 +405,20 @@ private void load(OsuConfigManager config, OsuGameBase game, CancellationToken c
 
         protected virtual GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart) => new MasterGameplayClockContainer(beatmap, gameplayStart);
 
-        private Drawable createUnderlayComponents() =>
-            DimmableStoryboard = new DimmableStoryboard(GameplayState.Storyboard, GameplayState.Mods) { RelativeSizeAxes = Axes.Both };
+        private Drawable createUnderlayComponents()
+        {
+            var container = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    DimmableStoryboard = new DimmableStoryboard(GameplayState.Storyboard, GameplayState.Mods) { RelativeSizeAxes = Axes.Both },
+                    new KiaiGameplayFountains(),
+                },
+            };
+
+            return container;
+        }
 
         private Drawable createGameplayComponents(IWorkingBeatmap working) => new ScalingContainer(ScalingMode.Gameplay)
         {
@@ -434,15 +446,6 @@ private Drawable createOverlayComponents(IWorkingBeatmap working)
                 Children = new[]
                 {
                     DimmableStoryboard.OverlayLayerContainer.CreateProxy(),
-                    BreakOverlay = new BreakOverlay(working.Beatmap.BeatmapInfo.LetterboxInBreaks, ScoreProcessor)
-                    {
-                        Clock = DrawableRuleset.FrameStableClock,
-                        ProcessCustomClock = false,
-                        Breaks = working.Beatmap.Breaks
-                    },
-                    // display the cursor above some HUD elements.
-                    DrawableRuleset.Cursor?.CreateProxy() ?? new Container(),
-                    DrawableRuleset.ResumeOverlay?.CreateProxy() ?? new Container(),
                     HUDOverlay = new HUDOverlay(DrawableRuleset, GameplayState.Mods, Configuration.AlwaysShowLeaderboard)
                     {
                         HoldToQuit =
@@ -461,6 +464,14 @@ private Drawable createOverlayComponents(IWorkingBeatmap working)
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre
                     },
+                    BreakOverlay = new BreakOverlay(working.Beatmap.BeatmapInfo.LetterboxInBreaks, ScoreProcessor)
+                    {
+                        Clock = DrawableRuleset.FrameStableClock,
+                        ProcessCustomClock = false,
+                        BreakTracker = breakTracker,
+                    },
+                    // display the cursor above some HUD elements.
+                    DrawableRuleset.Cursor?.CreateProxy() ?? new Container(),
                     skipIntroOverlay = new SkipOverlay(DrawableRuleset.GameplayStartTime)
                     {
                         RequestSkip = performUserRequestedSkip
@@ -470,6 +481,7 @@ private Drawable createOverlayComponents(IWorkingBeatmap working)
                         RequestSkip = () => progressToResults(false),
                         Alpha = 0
                     },
+                    DrawableRuleset.ResumeOverlay?.CreateProxy() ?? new Container(),
                     PauseOverlay = new PauseOverlay
                     {
                         OnResume = Resume,
diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index 12048ecbbe9e..7682bba9a619 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -573,6 +573,9 @@ protected override void Dispose(bool isDisposing)
                 // if the player never got pushed, we should explicitly dispose it.
                 DisposalTask = LoadTask?.ContinueWith(_ => CurrentPlayer?.Dispose());
             }
+
+            highPerformanceSession?.Dispose();
+            highPerformanceSession = null;
         }
 
         #endregion
diff --git a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
index 7668d3e63529..f312fb0ec5a9 100644
--- a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
+++ b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
@@ -104,8 +104,6 @@ protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            ReferenceScore.BindValueChanged(scoreChanged, true);
-
             beatmapOffsetSubscription = realm.SubscribeToPropertyChanged(
                 r => r.Find<BeatmapInfo>(beatmap.Value.BeatmapInfo.ID)?.UserSettings,
                 settings => settings.Offset,
@@ -124,6 +122,7 @@ protected override void LoadComplete()
                 });
 
             Current.BindValueChanged(currentChanged);
+            ReferenceScore.BindValueChanged(scoreChanged, true);
         }
 
         private void currentChanged(ValueChangedEvent<double> offset)
diff --git a/osu.Game/Screens/Play/ReplayPlayer.cs b/osu.Game/Screens/Play/ReplayPlayer.cs
index ff60dbc0d0d1..0c125264a1a1 100644
--- a/osu.Game/Screens/Play/ReplayPlayer.cs
+++ b/osu.Game/Screens/Play/ReplayPlayer.cs
@@ -55,6 +55,16 @@ public ReplayPlayer(Func<IBeatmap, IReadOnlyList<Mod>, Score> createScore, Playe
             this.createScore = createScore;
         }
 
+        /// <summary>
+        /// Add a settings group to the HUD overlay. Intended to be used by rulesets to add replay-specific settings.
+        /// </summary>
+        /// <param name="settings">The settings group to be shown.</param>
+        public void AddSettings(PlayerSettingsGroup settings) => Schedule(() =>
+        {
+            settings.Expanded.Value = false;
+            HUDOverlay.PlayerSettingsOverlay.Add(settings);
+        });
+
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
diff --git a/osu.Game/Screens/Play/SkipOverlay.cs b/osu.Game/Screens/Play/SkipOverlay.cs
index 29b2e5229b24..362677ca5cad 100644
--- a/osu.Game/Screens/Play/SkipOverlay.cs
+++ b/osu.Game/Screens/Play/SkipOverlay.cs
@@ -9,6 +9,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Audio.Track;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -16,6 +17,7 @@
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Utils;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -26,7 +28,7 @@
 
 namespace osu.Game.Screens.Play
 {
-    public partial class SkipOverlay : CompositeDrawable, IKeyBindingHandler<GlobalAction>
+    public partial class SkipOverlay : BeatSyncedContainer, IKeyBindingHandler<GlobalAction>
     {
         /// <summary>
         /// The total number of successful skips performed by this overlay.
@@ -36,10 +38,9 @@ public partial class SkipOverlay : CompositeDrawable, IKeyBindingHandler<GlobalA
         private readonly double startTime;
 
         public Action RequestSkip;
-
         private Button button;
         private ButtonContainer buttonContainer;
-        private Box remainingTimeBox;
+        private Circle remainingTimeBox;
 
         private FadeContainer fadeContainer;
         private double displayTime;
@@ -51,7 +52,6 @@ public partial class SkipOverlay : CompositeDrawable, IKeyBindingHandler<GlobalA
         private IGameplayClock gameplayClock { get; set; }
 
         internal bool IsButtonVisible => fadeContainer.State == Visibility.Visible && buttonContainer.State.Value == Visibility.Visible;
-
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
         /// <summary>
@@ -87,13 +87,13 @@ private void load(OsuColour colours)
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
                         },
-                        remainingTimeBox = new Box
+                        remainingTimeBox = new Circle
                         {
                             Height = 5,
-                            RelativeSizeAxes = Axes.X,
-                            Colour = colours.Yellow,
                             Anchor = Anchor.BottomCentre,
                             Origin = Anchor.BottomCentre,
+                            Colour = colours.Yellow,
+                            RelativeSizeAxes = Axes.X
                         }
                     }
                 }
@@ -210,6 +210,18 @@ public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
         {
         }
 
+        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
+        {
+            base.OnNewBeat(beatIndex, timingPoint, effectPoint, amplitudes);
+
+            if (fadeOutBeginTime <= gameplayClock.CurrentTime)
+                return;
+
+            float progress = (float)(gameplayClock.CurrentTime - displayTime) / (float)(fadeOutBeginTime - displayTime);
+            float newWidth = 1 - Math.Clamp(progress, 0, 1);
+            remainingTimeBox.ResizeWidthTo(newWidth, timingPoint.BeatLength * 2, Easing.OutQuint);
+        }
+
         public partial class FadeContainer : Container, IStateful<Visibility>
         {
             [CanBeNull]
diff --git a/osu.Game/Screens/Play/SoloSpectatorScreen.cs b/osu.Game/Screens/Play/SoloSpectatorScreen.cs
index 95eb2d4376ed..269bc3bb92a7 100644
--- a/osu.Game/Screens/Play/SoloSpectatorScreen.cs
+++ b/osu.Game/Screens/Play/SoloSpectatorScreen.cs
@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -13,12 +14,11 @@
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables.Cards;
 using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterfaceV2;
 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.Online.Spectator;
 using osu.Game.Overlays;
@@ -34,7 +34,7 @@ namespace osu.Game.Screens.Play
     public partial class SoloSpectatorScreen : SpectatorScreen, IPreviewTrackOwner
     {
         [Resolved]
-        private IAPIProvider api { get; set; } = null!;
+        private BeatmapLookupCache beatmapLookupCache { get; set; } = null!;
 
         [Resolved]
         private PreviewTrackManager previewTrackManager { get; set; } = null!;
@@ -60,7 +60,7 @@ public partial class SoloSpectatorScreen : SpectatorScreen, IPreviewTrackOwner
         /// </summary>
         private SpectatorGameplayState? immediateSpectatorGameplayState;
 
-        private GetBeatmapSetRequest? onlineBeatmapRequest;
+        private ScheduledDelegate? beatmapFetchCallback;
 
         private APIBeatmapSet? beatmapSet;
 
@@ -210,7 +210,7 @@ private void resetStartState() => Schedule(() =>
         private void clearDisplay()
         {
             watchButton.Enabled.Value = false;
-            onlineBeatmapRequest?.Cancel();
+            beatmapFetchCallback?.Cancel();
             beatmapPanelContainer.Clear();
             previewTrackManager.StopAnyPlaying(this);
         }
@@ -244,15 +244,17 @@ private void showBeatmapPanel(SpectatorState state)
         {
             Debug.Assert(state.BeatmapID != null);
 
-            onlineBeatmapRequest = new GetBeatmapSetRequest(state.BeatmapID.Value, BeatmapSetLookupType.BeatmapId);
-            onlineBeatmapRequest.Success += beatmapSet => Schedule(() =>
+            beatmapLookupCache.GetBeatmapAsync(state.BeatmapID.Value).ContinueWith(t => beatmapFetchCallback = Schedule(() =>
             {
-                this.beatmapSet = beatmapSet;
-                beatmapPanelContainer.Child = new BeatmapCardNormal(this.beatmapSet, allowExpansion: false);
-                checkForAutomaticDownload();
-            });
+                var beatmap = t.GetResultSafely();
 
-            api.Queue(onlineBeatmapRequest);
+                if (beatmap?.BeatmapSet == null)
+                    return;
+
+                beatmapSet = beatmap.BeatmapSet;
+                beatmapPanelContainer.Child = new BeatmapCardNormal(beatmapSet, allowExpansion: false);
+                checkForAutomaticDownload();
+            }));
         }
 
         private void checkForAutomaticDownload()
diff --git a/osu.Game/Screens/Play/SubmittingPlayer.cs b/osu.Game/Screens/Play/SubmittingPlayer.cs
index 6c5f7fab9e82..24c5b2c3d419 100644
--- a/osu.Game/Screens/Play/SubmittingPlayer.cs
+++ b/osu.Game/Screens/Play/SubmittingPlayer.cs
@@ -234,9 +234,12 @@ private void submitFromFailOrQuit()
         {
             if (LoadedBeatmapSuccessfully)
             {
+                // compare: https://github.com/ppy/osu/blob/ccf1acce56798497edfaf92d3ece933469edcf0a/osu.Game/Screens/Play/Player.cs#L848-L851
+                var scoreCopy = Score.DeepClone();
+
                 Task.Run(async () =>
                 {
-                    await submitScore(Score.DeepClone()).ConfigureAwait(false);
+                    await submitScore(scoreCopy).ConfigureAwait(false);
                     spectatorClient.EndPlaying(GameplayState);
                 }).FireAndForget();
             }
@@ -274,6 +277,16 @@ private Task submitScore(Score score)
                 return Task.CompletedTask;
             }
 
+            // if the user never hit anything, this score should not be counted in any way.
+            if (!score.ScoreInfo.Statistics.Any(s => s.Key.IsHit() && s.Value > 0))
+            {
+                Logger.Log("No hits registered, skipping score submission");
+                return Task.CompletedTask;
+            }
+
+            // mind the timing of this.
+            // once `scoreSubmissionSource` is created, it is presumed that submission is taking place in the background,
+            // so all exceptional circumstances that would disallow submission must be handled above.
             lock (scoreSubmissionLock)
             {
                 if (scoreSubmissionSource != null)
@@ -282,10 +295,6 @@ private Task submitScore(Score score)
                 scoreSubmissionSource = new TaskCompletionSource<bool>();
             }
 
-            // if the user never hit anything, this score should not be counted in any way.
-            if (!score.ScoreInfo.Statistics.Any(s => s.Key.IsHit() && s.Value > 0))
-                return Task.CompletedTask;
-
             Logger.Log($"Beginning score submission (token:{token.Value})...");
             var request = CreateSubmissionRequest(score, token.Value);
 
diff --git a/osu.Game/Screens/Ranking/CollectionButton.cs b/osu.Game/Screens/Ranking/CollectionButton.cs
new file mode 100644
index 000000000000..869c6a7ff43f
--- /dev/null
+++ b/osu.Game/Screens/Ranking/CollectionButton.cs
@@ -0,0 +1,81 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+using osuTK;
+using Realms;
+
+namespace osu.Game.Screens.Ranking
+{
+    public partial class CollectionButton : GrayButton, IHasPopover
+    {
+        private readonly BeatmapInfo beatmapInfo;
+        private readonly Bindable<bool> isInAnyCollection;
+
+        [Resolved]
+        private RealmAccess realmAccess { get; set; } = null!;
+
+        private IDisposable? collectionSubscription;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        public CollectionButton(BeatmapInfo beatmapInfo)
+            : base(FontAwesome.Solid.Book)
+        {
+            this.beatmapInfo = beatmapInfo;
+            isInAnyCollection = new Bindable<bool>(false);
+
+            Size = new Vector2(75, 30);
+
+            TooltipText = "collections";
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Action = this.ShowPopover;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            collectionSubscription = realmAccess.RegisterForNotifications(r => r.All<BeatmapCollection>(), collectionsChanged);
+
+            isInAnyCollection.BindValueChanged(_ => updateState(), true);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            collectionSubscription?.Dispose();
+        }
+
+        private void collectionsChanged(IRealmCollection<BeatmapCollection> sender, ChangeSet? changes)
+        {
+            isInAnyCollection.Value = sender.AsEnumerable().Any(c => c.BeatmapMD5Hashes.Contains(beatmapInfo.MD5Hash));
+        }
+
+        private void updateState()
+        {
+            Background.FadeColour(isInAnyCollection.Value ? colours.Green : colours.Gray4, 500, Easing.InOutExpo);
+        }
+
+        public Popover GetPopover() => new CollectionPopover(beatmapInfo);
+    }
+}
diff --git a/osu.Game/Screens/Ranking/CollectionPopover.cs b/osu.Game/Screens/Ranking/CollectionPopover.cs
new file mode 100644
index 000000000000..ffc448d7a92c
--- /dev/null
+++ b/osu.Game/Screens/Ranking/CollectionPopover.cs
@@ -0,0 +1,68 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.Database;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+
+namespace osu.Game.Screens.Ranking
+{
+    public partial class CollectionPopover : OsuPopover
+    {
+        private readonly BeatmapInfo beatmapInfo;
+
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
+        [Resolved]
+        private ManageCollectionsDialog? manageCollectionsDialog { get; set; }
+
+        public CollectionPopover(BeatmapInfo beatmapInfo)
+            : base(false)
+        {
+            this.beatmapInfo = beatmapInfo;
+
+            Body.CornerRadius = 4;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new[]
+            {
+                new OsuMenu(Direction.Vertical, true)
+                {
+                    Items = items,
+                    MaxHeight = 375,
+                },
+            };
+        }
+
+        protected override void OnFocusLost(FocusLostEvent e)
+        {
+            base.OnFocusLost(e);
+            Hide();
+        }
+
+        private OsuMenuItem[] items
+        {
+            get
+            {
+                var collectionItems = realm.Realm.All<BeatmapCollection>()
+                                           .OrderBy(c => c.Name)
+                                           .AsEnumerable()
+                                           .Select(c => new CollectionToggleMenuItem(c.ToLive(realm), beatmapInfo)).Cast<OsuMenuItem>().ToList();
+
+                collectionItems.Add(new OsuMenuItem("Manage...", MenuItemType.Standard, () => manageCollectionsDialog?.Show()));
+
+                return collectionItems.ToArray();
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Ranking/FavouriteButton.cs b/osu.Game/Screens/Ranking/FavouriteButton.cs
new file mode 100644
index 000000000000..019b80dde980
--- /dev/null
+++ b/osu.Game/Screens/Ranking/FavouriteButton.cs
@@ -0,0 +1,156 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Logging;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables.Cards;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Resources.Localisation.Web;
+using osuTK;
+
+namespace osu.Game.Screens.Ranking
+{
+    public partial class FavouriteButton : GrayButton
+    {
+        public readonly BeatmapSetInfo BeatmapSetInfo;
+        private APIBeatmapSet? beatmapSet;
+        private readonly Bindable<BeatmapSetFavouriteState> current;
+
+        private PostBeatmapFavouriteRequest? favouriteRequest;
+        private LoadingLayer loading = null!;
+
+        private readonly IBindable<APIUser> localUser = new Bindable<APIUser>();
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        public FavouriteButton(BeatmapSetInfo beatmapSetInfo)
+            : base(FontAwesome.Regular.Heart)
+        {
+            BeatmapSetInfo = beatmapSetInfo;
+            current = new BindableWithCurrent<BeatmapSetFavouriteState>(new BeatmapSetFavouriteState(false, 0));
+
+            Size = new Vector2(75, 30);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(loading = new LoadingLayer(true, false));
+
+            Action = toggleFavouriteStatus;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            current.BindValueChanged(_ => updateState(), true);
+
+            localUser.BindTo(api.LocalUser);
+            localUser.BindValueChanged(_ => updateUser(), true);
+        }
+
+        private void getBeatmapSet()
+        {
+            GetBeatmapSetRequest beatmapSetRequest = new GetBeatmapSetRequest(BeatmapSetInfo.OnlineID);
+
+            loading.Show();
+            beatmapSetRequest.Success += beatmapSet =>
+            {
+                this.beatmapSet = beatmapSet;
+                current.Value = new BeatmapSetFavouriteState(this.beatmapSet.HasFavourited, this.beatmapSet.FavouriteCount);
+
+                loading.Hide();
+                Enabled.Value = true;
+            };
+            beatmapSetRequest.Failure += e =>
+            {
+                Logger.Log($"Favourite button failed to fetch beatmap info: {e}", LoggingTarget.Network);
+
+                Schedule(() =>
+                {
+                    loading.Hide();
+                    Enabled.Value = false;
+                    TooltipText = "this beatmap cannot be favourited";
+                });
+            };
+            api.Queue(beatmapSetRequest);
+        }
+
+        private void toggleFavouriteStatus()
+        {
+            if (beatmapSet == null)
+                return;
+
+            Enabled.Value = false;
+            loading.Show();
+
+            var actionType = current.Value.Favourited ? BeatmapFavouriteAction.UnFavourite : BeatmapFavouriteAction.Favourite;
+
+            favouriteRequest?.Cancel();
+            favouriteRequest = new PostBeatmapFavouriteRequest(beatmapSet.OnlineID, actionType);
+
+            favouriteRequest.Success += () =>
+            {
+                bool favourited = actionType == BeatmapFavouriteAction.Favourite;
+
+                current.Value = new BeatmapSetFavouriteState(favourited, current.Value.FavouriteCount + (favourited ? 1 : -1));
+
+                Enabled.Value = true;
+                loading.Hide();
+            };
+            favouriteRequest.Failure += e =>
+            {
+                Logger.Error(e, $"Failed to {actionType.ToString().ToLowerInvariant()} beatmap: {e.Message}");
+
+                Schedule(() =>
+                {
+                    Enabled.Value = true;
+                    loading.Hide();
+                });
+            };
+
+            api.Queue(favouriteRequest);
+        }
+
+        private void updateUser()
+        {
+            if (!(localUser.Value is GuestUser) && BeatmapSetInfo.OnlineID > 0)
+                getBeatmapSet();
+            else
+            {
+                Enabled.Value = false;
+                current.Value = new BeatmapSetFavouriteState(false, 0);
+                updateState();
+                TooltipText = BeatmapsetsStrings.ShowDetailsFavouriteLogin;
+            }
+        }
+
+        private void updateState()
+        {
+            if (current.Value.Favourited)
+            {
+                Background.Colour = colours.Green;
+                Icon.Icon = FontAwesome.Solid.Heart;
+                TooltipText = BeatmapsetsStrings.ShowDetailsUnfavourite;
+            }
+            else
+            {
+                Background.Colour = colours.Gray4;
+                Icon.Icon = FontAwesome.Regular.Heart;
+                TooltipText = BeatmapsetsStrings.ShowDetailsFavourite;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Ranking/ResultsScreen.cs b/osu.Game/Screens/Ranking/ResultsScreen.cs
index e89ed194ac94..0209fbd39c8b 100644
--- a/osu.Game/Screens/Ranking/ResultsScreen.cs
+++ b/osu.Game/Screens/Ranking/ResultsScreen.cs
@@ -12,6 +12,7 @@
 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.Input.Bindings;
 using osu.Framework.Input.Events;
@@ -76,7 +77,7 @@ public abstract partial class ResultsScreen : ScreenWithBeatmapBackground, IKeyB
 
         /// <summary>
         /// Whether the user's personal statistics should be shown on the extended statistics panel
-        /// after clicking the score panel associated with the <see cref="ResultsScreen.Score"/> being presented.
+        /// after clicking the score panel associated with the <see cref="Score"/> being presented.
         /// Requires <see cref="Score"/> to be present.
         /// </summary>
         public bool ShowUserStatistics { get; init; }
@@ -97,73 +98,77 @@ private void load(AudioManager audio)
 
             popInSample = audio.Samples.Get(@"UI/overlay-pop-in");
 
-            InternalChild = new GridContainer
+            InternalChild = new PopoverContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Content = new[]
+                Child = new GridContainer
                 {
-                    new Drawable[]
+                    RelativeSizeAxes = Axes.Both,
+                    Content = new[]
                     {
-                        VerticalScrollContent = new VerticalScrollContainer
+                        new Drawable[]
                         {
-                            RelativeSizeAxes = Axes.Both,
-                            ScrollbarVisible = false,
-                            Child = new Container
+                            VerticalScrollContent = new VerticalScrollContainer
                             {
                                 RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
+                                ScrollbarVisible = false,
+                                Child = new Container
                                 {
-                                    StatisticsPanel = createStatisticsPanel().With(panel =>
+                                    RelativeSizeAxes = Axes.Both,
+                                    Children = new Drawable[]
                                     {
-                                        panel.RelativeSizeAxes = Axes.Both;
-                                        panel.Score.BindTarget = SelectedScore;
-                                    }),
-                                    ScorePanelList = new ScorePanelList
+                                        StatisticsPanel = createStatisticsPanel().With(panel =>
+                                        {
+                                            panel.RelativeSizeAxes = Axes.Both;
+                                            panel.Score.BindTarget = SelectedScore;
+                                        }),
+                                        ScorePanelList = new ScorePanelList
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            SelectedScore = { BindTarget = SelectedScore },
+                                            PostExpandAction = () => StatisticsPanel.ToggleVisibility()
+                                        },
+                                        detachedPanelContainer = new Container<ScorePanel>
+                                        {
+                                            RelativeSizeAxes = Axes.Both
+                                        },
+                                    }
+                                }
+                            },
+                        },
+                        new[]
+                        {
+                            bottomPanel = new Container
+                            {
+                                Anchor = Anchor.BottomLeft,
+                                Origin = Anchor.BottomLeft,
+                                RelativeSizeAxes = Axes.X,
+                                Height = TwoLayerButton.SIZE_EXTENDED.Y,
+                                Alpha = 0,
+                                Children = new Drawable[]
+                                {
+                                    new Box
                                     {
                                         RelativeSizeAxes = Axes.Both,
-                                        SelectedScore = { BindTarget = SelectedScore },
-                                        PostExpandAction = () => StatisticsPanel.ToggleVisibility()
+                                        Colour = Color4Extensions.FromHex("#333")
                                     },
-                                    detachedPanelContainer = new Container<ScorePanel>
+                                    buttons = new FillFlowContainer
                                     {
-                                        RelativeSizeAxes = Axes.Both
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                        AutoSizeAxes = Axes.Both,
+                                        Spacing = new Vector2(5),
+                                        Direction = FillDirection.Horizontal
                                     },
                                 }
                             }
-                        },
+                        }
                     },
-                    new[]
+                    RowDimensions = new[]
                     {
-                        bottomPanel = new Container
-                        {
-                            Anchor = Anchor.BottomLeft,
-                            Origin = Anchor.BottomLeft,
-                            RelativeSizeAxes = Axes.X,
-                            Height = TwoLayerButton.SIZE_EXTENDED.Y,
-                            Alpha = 0,
-                            Children = new Drawable[]
-                            {
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = Color4Extensions.FromHex("#333")
-                                },
-                                buttons = new FillFlowContainer
-                                {
-                                    Anchor = Anchor.Centre,
-                                    Origin = Anchor.Centre,
-                                    AutoSizeAxes = Axes.Both,
-                                    Spacing = new Vector2(5),
-                                    Direction = FillDirection.Horizontal
-                                }
-                            }
-                        }
+                        new Dimension(),
+                        new Dimension(GridSizeMode.AutoSize)
                     }
-                },
-                RowDimensions = new[]
-                {
-                    new Dimension(),
-                    new Dimension(GridSizeMode.AutoSize)
                 }
             };
 
@@ -202,6 +207,12 @@ private void load(AudioManager audio)
                     },
                 });
             }
+
+            if (Score?.BeatmapInfo != null)
+                buttons.Add(new CollectionButton(Score.BeatmapInfo));
+
+            if (Score?.BeatmapInfo?.BeatmapSet != null && Score.BeatmapInfo.BeatmapSet.OnlineID > 0)
+                buttons.Add(new FavouriteButton(Score.BeatmapInfo.BeatmapSet));
         }
 
         protected override void LoadComplete()
diff --git a/osu.Game/Screens/Ranking/Statistics/UserStatisticsPanel.cs b/osu.Game/Screens/Ranking/Statistics/UserStatisticsPanel.cs
index fa3bb1a37591..4e9c07ab7bbb 100644
--- a/osu.Game/Screens/Ranking/Statistics/UserStatisticsPanel.cs
+++ b/osu.Game/Screens/Ranking/Statistics/UserStatisticsPanel.cs
@@ -37,7 +37,7 @@ private void load(UserStatisticsWatcher? userStatisticsWatcher)
                 {
                     if (update.NewValue?.Score.MatchesOnlineID(achievedScore) == true)
                         DisplayedUserStatisticsUpdate.Value = update.NewValue;
-                });
+                }, true);
             }
         }
 
diff --git a/osu.Game/Screens/Select/BeatmapCarousel.cs b/osu.Game/Screens/Select/BeatmapCarousel.cs
index b0f198d48634..d9359cfec34a 100644
--- a/osu.Game/Screens/Select/BeatmapCarousel.cs
+++ b/osu.Game/Screens/Select/BeatmapCarousel.cs
@@ -3,8 +3,10 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -21,6 +23,7 @@
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Database;
+using osu.Game.Extensions;
 using osu.Game.Graphics.Containers;
 using osu.Game.Input.Bindings;
 using osu.Game.Screens.Select.Carousel;
@@ -76,8 +79,6 @@ public partial class BeatmapCarousel : CompositeDrawable, IKeyBindingHandler<Glo
 
         private CarouselBeatmapSet? selectedBeatmapSet;
 
-        private List<BeatmapSetInfo> originalBeatmapSetsDetached = new List<BeatmapSetInfo>();
-
         /// <summary>
         /// Raised when the <see cref="SelectedBeatmapInfo"/> is changed.
         /// </summary>
@@ -109,28 +110,40 @@ public partial class BeatmapCarousel : CompositeDrawable, IKeyBindingHandler<Glo
         [Cached]
         protected readonly CarouselScrollContainer Scroll;
 
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
+        [Resolved]
+        private DetachedBeatmapStore? detachedBeatmapStore { get; set; }
+
+        private IBindableList<BeatmapSetInfo>? detachedBeatmapSets;
+
         private readonly NoResultsPlaceholder noResultsPlaceholder;
 
         private IEnumerable<CarouselBeatmapSet> beatmapSets => root.Items.OfType<CarouselBeatmapSet>();
 
-        // todo: only used for testing, maybe remove.
-        private bool loadedTestBeatmaps;
-
-        public IEnumerable<BeatmapSetInfo> BeatmapSets
+        internal IEnumerable<BeatmapSetInfo> BeatmapSets
         {
             get => beatmapSets.Select(g => g.BeatmapSet);
             set
             {
-                loadedTestBeatmaps = true;
-                Schedule(() => loadBeatmapSets(value));
+                if (LoadState != LoadState.NotLoaded)
+                    throw new InvalidOperationException("If not using a realm source, beatmap sets must be set before load.");
+
+                detachedBeatmapSets = new BindableList<BeatmapSetInfo>(value);
+                Schedule(loadNewRoot);
             }
         }
 
-        private void loadBeatmapSets(IEnumerable<BeatmapSetInfo> beatmapSets)
+        private void loadNewRoot()
         {
-            originalBeatmapSetsDetached = beatmapSets.Detach();
+            beatmapsSplitOut = activeCriteria.SplitOutDifficulties;
 
-            if (selectedBeatmapSet != null && !originalBeatmapSetsDetached.Contains(selectedBeatmapSet.BeatmapSet))
+            // Ensure no changes are made to the list while we are initialising items.
+            // We'll catch up on changes via subscriptions anyway.
+            BeatmapSetInfo[] loadableSets = detachedBeatmapSets!.ToArray();
+
+            if (selectedBeatmapSet != null && !loadableSets.Contains(selectedBeatmapSet.BeatmapSet, EqualityComparer<BeatmapSetInfo>.Default))
                 selectedBeatmapSet = null;
 
             var selectedBeatmapBefore = selectedBeatmap?.BeatmapInfo;
@@ -139,7 +152,7 @@ private void loadBeatmapSets(IEnumerable<BeatmapSetInfo> beatmapSets)
 
             if (beatmapsSplitOut)
             {
-                var carouselBeatmapSets = originalBeatmapSetsDetached.SelectMany(s => s.Beatmaps).Select(b =>
+                var carouselBeatmapSets = loadableSets.SelectMany(s => s.Beatmaps).Select(b =>
                 {
                     return createCarouselSet(new BeatmapSetInfo(new[] { b })
                     {
@@ -153,25 +166,18 @@ private void loadBeatmapSets(IEnumerable<BeatmapSetInfo> beatmapSets)
             }
             else
             {
-                var carouselBeatmapSets = originalBeatmapSetsDetached.Select(createCarouselSet).OfType<CarouselBeatmapSet>();
+                var carouselBeatmapSets = loadableSets.Select(createCarouselSet).OfType<CarouselBeatmapSet>();
 
                 newRoot.AddItems(carouselBeatmapSets);
             }
 
             root = newRoot;
+            root.Filter(activeCriteria);
 
             Scroll.Clear(false);
             itemsCache.Invalidate();
             ScrollToSelected();
 
-            applyActiveCriteria(false);
-
-            if (loadedTestBeatmaps)
-            {
-                invalidateAfterChange();
-                BeatmapSetsLoaded = true;
-            }
-
             // Restore selection
             if (selectedBeatmapBefore != null && newRoot.BeatmapSetsByID.TryGetValue(selectedBeatmapBefore.BeatmapSet!.ID, out var newSelectionCandidates))
             {
@@ -180,6 +186,12 @@ private void loadBeatmapSets(IEnumerable<BeatmapSetInfo> beatmapSets)
                 if (found != null)
                     found.State.Value = CarouselItemState.Selected;
             }
+
+            Schedule(() =>
+            {
+                invalidateAfterChange();
+                BeatmapSetsLoaded = true;
+            });
         }
 
         private readonly List<CarouselItem> visibleItems = new List<CarouselItem>();
@@ -195,7 +207,6 @@ private void loadBeatmapSets(IEnumerable<BeatmapSetInfo> beatmapSets)
 
         private CarouselRoot root;
 
-        private IDisposable? subscriptionSets;
         private IDisposable? subscriptionBeatmaps;
 
         private readonly DrawablePool<DrawableCarouselBeatmapSet> setPool = new DrawablePool<DrawableCarouselBeatmapSet>(100);
@@ -205,7 +216,7 @@ private void loadBeatmapSets(IEnumerable<BeatmapSetInfo> beatmapSets)
 
         private int visibleSetsCount;
 
-        public BeatmapCarousel()
+        public BeatmapCarousel(FilterCriteria initialCriterial)
         {
             root = new CarouselRoot(this);
             InternalChild = new Container
@@ -227,10 +238,12 @@ public BeatmapCarousel()
                     noResultsPlaceholder = new NoResultsPlaceholder()
                 }
             };
+
+            activeCriteria = initialCriterial;
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config, AudioManager audio)
+        private void load(OsuConfigManager config, AudioManager audio, CancellationToken? cancellationToken)
         {
             spinSample = audio.Samples.Get("SongSelect/random-spin");
             randomSelectSample = audio.Samples.Get(@"SongSelect/select-random");
@@ -241,97 +254,61 @@ private void load(OsuConfigManager config, AudioManager audio)
             RightClickScrollingEnabled.ValueChanged += enabled => Scroll.RightMouseScrollbar = enabled.NewValue;
             RightClickScrollingEnabled.TriggerChange();
 
-            if (!loadedTestBeatmaps)
+            if (detachedBeatmapStore != null && detachedBeatmapSets == null)
             {
                 // This is performing an unnecessary second lookup on realm (in addition to the subscription), but for performance reasons
                 // we require it to be separate: the subscription's initial callback (with `ChangeSet` of `null`) will run on the update
                 // thread. If we attempt to detach beatmaps in this callback the game will fall over (it takes time).
-                realm.Run(r => loadBeatmapSets(getBeatmapSets(r)));
+                detachedBeatmapSets = detachedBeatmapStore.GetDetachedBeatmaps(cancellationToken);
+                detachedBeatmapSets.BindCollectionChanged(beatmapSetsChanged);
+                loadNewRoot();
             }
         }
 
-        [Resolved]
-        private RealmAccess realm { get; set; } = null!;
-
-        /// <summary>
-        /// Track GUIDs of all sets in realm to allow handling deletions.
-        /// </summary>
-        private readonly List<Guid> realmBeatmapSets = new List<Guid>();
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            subscriptionSets = realm.RegisterForNotifications(getBeatmapSets, beatmapSetsChanged);
             subscriptionBeatmaps = realm.RegisterForNotifications(r => r.All<BeatmapInfo>().Where(b => !b.Hidden), beatmapsChanged);
         }
 
-        private readonly HashSet<Guid> setsRequiringUpdate = new HashSet<Guid>();
-        private readonly HashSet<Guid> setsRequiringRemoval = new HashSet<Guid>();
+        private readonly HashSet<BeatmapSetInfo> setsRequiringUpdate = new HashSet<BeatmapSetInfo>();
+        private readonly HashSet<BeatmapSetInfo> setsRequiringRemoval = new HashSet<BeatmapSetInfo>();
 
-        private void beatmapSetsChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet? changes)
+        private void beatmapSetsChanged(object? beatmaps, NotifyCollectionChangedEventArgs changed)
         {
-            // If loading test beatmaps, avoid overwriting with realm subscription callbacks.
-            if (loadedTestBeatmaps)
-                return;
+            IEnumerable<BeatmapSetInfo>? newBeatmapSets = changed.NewItems?.Cast<BeatmapSetInfo>();
 
-            if (changes == null)
+            switch (changed.Action)
             {
-                realmBeatmapSets.Clear();
-                realmBeatmapSets.AddRange(sender.Select(r => r.ID));
+                case NotifyCollectionChangedAction.Add:
+                    HashSet<Guid> newBeatmapSetIDs = newBeatmapSets!.Select(s => s.ID).ToHashSet();
 
-                if (originalBeatmapSetsDetached.Count > 0 && sender.Count == 0)
-                {
-                    // Usually we'd reset stuff here, but doing so triggers a silly flow which ends up deadlocking realm.
-                    // Additionally, user should not be at song select when realm is blocking all operations in the first place.
-                    //
-                    // Note that due to the catch-up logic below, once operations are restored we will still be in a roughly
-                    // correct state. The only things that this return will change is the carousel will not empty *during* the blocking
-                    // operation.
-                    return;
-                }
-
-                // Do a full two-way check for missing (or incorrectly present) beatmaps.
-                // Let's assume that the worst that can happen is deletions or additions.
-                setsRequiringRemoval.Clear();
-                setsRequiringUpdate.Clear();
-
-                foreach (Guid id in realmBeatmapSets)
-                {
-                    if (!root.BeatmapSetsByID.ContainsKey(id))
-                        setsRequiringUpdate.Add(id);
-                }
-
-                foreach (Guid id in root.BeatmapSetsByID.Keys)
-                {
-                    if (!realmBeatmapSets.Contains(id))
-                        setsRequiringRemoval.Add(id);
-                }
-            }
-            else
-            {
-                foreach (int i in changes.DeletedIndices.OrderDescending())
-                {
-                    Guid id = realmBeatmapSets[i];
-
-                    setsRequiringRemoval.Add(id);
-                    setsRequiringUpdate.Remove(id);
+                    setsRequiringRemoval.RemoveWhere(s => newBeatmapSetIDs.Contains(s.ID));
+                    setsRequiringUpdate.AddRange(newBeatmapSets!);
+                    break;
 
-                    realmBeatmapSets.RemoveAt(i);
-                }
+                case NotifyCollectionChangedAction.Remove:
+                    IEnumerable<BeatmapSetInfo> oldBeatmapSets = changed.OldItems!.Cast<BeatmapSetInfo>();
+                    HashSet<Guid> oldBeatmapSetIDs = oldBeatmapSets.Select(s => s.ID).ToHashSet();
 
-                foreach (int i in changes.InsertedIndices)
-                {
-                    Guid id = sender[i].ID;
+                    setsRequiringUpdate.RemoveWhere(s => oldBeatmapSetIDs.Contains(s.ID));
+                    setsRequiringRemoval.AddRange(oldBeatmapSets);
+                    break;
 
-                    setsRequiringRemoval.Remove(id);
-                    setsRequiringUpdate.Add(id);
+                case NotifyCollectionChangedAction.Replace:
+                    setsRequiringUpdate.AddRange(newBeatmapSets!);
+                    break;
 
-                    realmBeatmapSets.Insert(i, id);
-                }
+                case NotifyCollectionChangedAction.Move:
+                    setsRequiringUpdate.AddRange(newBeatmapSets!);
+                    break;
 
-                foreach (int i in changes.NewModifiedIndices)
-                    setsRequiringUpdate.Add(sender[i].ID);
+                case NotifyCollectionChangedAction.Reset:
+                    setsRequiringRemoval.Clear();
+                    setsRequiringUpdate.Clear();
+                    loadNewRoot();
+                    break;
             }
 
             Scheduler.AddOnce(processBeatmapChanges);
@@ -345,9 +322,9 @@ private void processBeatmapChanges()
         {
             try
             {
-                foreach (var set in setsRequiringRemoval) removeBeatmapSet(set);
+                foreach (var set in setsRequiringRemoval) removeBeatmapSet(set.ID);
 
-                foreach (var set in setsRequiringUpdate) updateBeatmapSet(fetchFromID(set)!);
+                foreach (var set in setsRequiringUpdate) updateBeatmapSet(set);
 
                 if (setsRequiringRemoval.Count > 0 && SelectedBeatmapInfo != null)
                 {
@@ -365,7 +342,7 @@ private void processBeatmapChanges()
                         // This relies on the full update operation being in a single transaction, so please don't change that.
                         foreach (var set in setsRequiringUpdate)
                         {
-                            foreach (var beatmapInfo in fetchFromID(set)!.Beatmaps)
+                            foreach (var beatmapInfo in set.Beatmaps)
                             {
                                 if (!((IBeatmapMetadataInfo)beatmapInfo.Metadata).Equals(SelectedBeatmapInfo.Metadata)) continue;
 
@@ -380,7 +357,7 @@ private void processBeatmapChanges()
 
                         // If a direct selection couldn't be made, it's feasible that the difficulty name (or beatmap metadata) changed.
                         // Let's attempt to follow set-level selection anyway.
-                        SelectBeatmap(fetchFromID(setsRequiringUpdate.First())!.Beatmaps.First());
+                        SelectBeatmap(setsRequiringUpdate.First().Beatmaps.First());
                     }
                 }
             }
@@ -425,8 +402,6 @@ private void beatmapsChanged(IRealmCollection<BeatmapInfo> sender, ChangeSet? ch
                 invalidateAfterChange();
         }
 
-        private IQueryable<BeatmapSetInfo> getBeatmapSets(Realm realm) => realm.All<BeatmapSetInfo>().Where(s => !s.DeletePending && !s.Protected);
-
         public void RemoveBeatmapSet(BeatmapSetInfo beatmapSet) => Schedule(() =>
         {
             removeBeatmapSet(beatmapSet.ID);
@@ -438,8 +413,6 @@ private void removeBeatmapSet(Guid beatmapSetID)
             if (!root.BeatmapSetsByID.TryGetValue(beatmapSetID, out var existingSets))
                 return;
 
-            originalBeatmapSetsDetached.RemoveAll(set => set.ID == beatmapSetID);
-
             foreach (var set in existingSets)
             {
                 foreach (var beatmap in set.Beatmaps)
@@ -450,24 +423,14 @@ private void removeBeatmapSet(Guid beatmapSetID)
             }
         }
 
-        public void UpdateBeatmapSet(BeatmapSetInfo beatmapSet)
+        public void UpdateBeatmapSet(BeatmapSetInfo beatmapSet) => Schedule(() =>
         {
-            beatmapSet = beatmapSet.Detach();
-
-            Schedule(() =>
-            {
-                updateBeatmapSet(beatmapSet);
-                invalidateAfterChange();
-            });
-        }
+            updateBeatmapSet(beatmapSet);
+            invalidateAfterChange();
+        });
 
         private void updateBeatmapSet(BeatmapSetInfo beatmapSet)
         {
-            beatmapSet = beatmapSet.Detach();
-
-            originalBeatmapSetsDetached.RemoveAll(set => set.ID == beatmapSet.ID);
-            originalBeatmapSetsDetached.Add(beatmapSet);
-
             var newSets = new List<CarouselBeatmapSet>();
 
             if (beatmapsSplitOut)
@@ -696,7 +659,7 @@ private void select(CarouselItem? item)
             item.State.Value = CarouselItemState.Selected;
         }
 
-        private FilterCriteria activeCriteria = new FilterCriteria();
+        private FilterCriteria activeCriteria;
 
         protected ScheduledDelegate? PendingFilter;
 
@@ -733,17 +696,17 @@ public void FlushPendingFilterOperations()
             }
         }
 
-        public void Filter(FilterCriteria? newCriteria, bool debounce = true)
+        public void Filter(FilterCriteria? newCriteria)
         {
             if (newCriteria != null)
                 activeCriteria = newCriteria;
 
-            applyActiveCriteria(debounce);
+            applyActiveCriteria(true);
         }
 
         private bool beatmapsSplitOut;
 
-        private void applyActiveCriteria(bool debounce, bool alwaysResetScrollPosition = true)
+        private void applyActiveCriteria(bool debounce)
         {
             PendingFilter?.Cancel();
             PendingFilter = null;
@@ -765,16 +728,14 @@ void perform()
 
                 if (activeCriteria.SplitOutDifficulties != beatmapsSplitOut)
                 {
-                    beatmapsSplitOut = activeCriteria.SplitOutDifficulties;
-                    loadBeatmapSets(originalBeatmapSetsDetached);
+                    loadNewRoot();
                     return;
                 }
 
                 root.Filter(activeCriteria);
                 itemsCache.Invalidate();
 
-                if (alwaysResetScrollPosition || !Scroll.UserScrolling)
-                    ScrollToSelected(true);
+                ScrollToSelected(true);
 
                 FilterApplied?.Invoke();
             }
@@ -896,8 +857,9 @@ protected override void Update()
                     // Add those items within the previously found index range that should be displayed.
                     foreach (var item in toDisplay)
                     {
-                        var panel = setPool.Get(p => p.Item = item);
+                        var panel = setPool.Get();
 
+                        panel.Item = item;
                         panel.Y = item.CarouselYPosition;
 
                         Scroll.Add(panel);
@@ -939,8 +901,8 @@ protected override void Update()
 
                 if (item is DrawableCarouselBeatmapSet set)
                 {
-                    foreach (var diff in set.DrawableBeatmaps)
-                        updateItem(diff, item);
+                    for (int i = 0; i < set.DrawableBeatmaps.Count; i++)
+                        updateItem(set.DrawableBeatmaps[i], item);
                 }
             }
         }
@@ -1073,7 +1035,7 @@ private void updateYPositions()
             itemsCache.Validate();
 
             // update and let external consumers know about selection loss.
-            if (BeatmapSetsLoaded)
+            if (BeatmapSetsLoaded && AllowSelection)
             {
                 bool selectionLost = selectedBeatmapSet != null && selectedBeatmapSet.State.Value != CarouselItemState.Selected;
 
@@ -1140,7 +1102,7 @@ private static float offsetX(float dist, float halfHeight)
         }
 
         /// <summary>
-        /// Update a item's x position and multiplicative alpha based on its y position and
+        /// Update an item's x position and multiplicative alpha based on its y position and
         /// the current scroll position.
         /// </summary>
         /// <param name="item">The item to be updated.</param>
@@ -1315,7 +1277,6 @@ protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
 
-            subscriptionSets?.Dispose();
             subscriptionBeatmaps?.Dispose();
         }
     }
diff --git a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
index f725d98342cb..359e0f6c783e 100644
--- a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
+++ b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
@@ -25,6 +25,7 @@
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets;
@@ -79,6 +80,12 @@ public partial class DrawableCarouselBeatmap : DrawableCarouselItem, IHasContext
         [Resolved]
         private IBindable<IReadOnlyList<Mod>> mods { get; set; } = null!;
 
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private OsuGame? game { get; set; }
+
         private IBindable<StarDifficulty?> starDifficultyBindable = null!;
         private CancellationTokenSource? starDifficultyCancellationSource;
 
@@ -288,6 +295,9 @@ public MenuItem[] ContextMenuItems
 
                 items.Add(new OsuMenuItem("Collections") { Items = collectionItems });
 
+                if (beatmapInfo.GetOnlineURL(api, ruleset.Value) is string url)
+                    items.Add(new OsuMenuItem("Copy link", MenuItemType.Standard, () => game?.CopyUrlToClipboard(url)));
+
                 if (hideRequested != null)
                     items.Add(new OsuMenuItem(CommonStrings.ButtonsHide.ToSentence(), MenuItemType.Destructive, () => hideRequested(beatmapInfo)));
 
diff --git a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs
index bd659d742385..eba40994e22e 100644
--- a/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs
+++ b/osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmapSet.cs
@@ -8,6 +8,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -19,7 +20,9 @@
 using osu.Game.Collections;
 using osu.Game.Database;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
 using osu.Game.Overlays;
+using osu.Game.Rulesets;
 
 namespace osu.Game.Screens.Select.Carousel
 {
@@ -39,7 +42,16 @@ public partial class DrawableCarouselBeatmapSet : DrawableCarouselItem, IHasCont
         [Resolved]
         private RealmAccess realm { get; set; } = null!;
 
-        public IEnumerable<DrawableCarouselItem> DrawableBeatmaps => beatmapContainer?.IsLoaded != true ? Enumerable.Empty<DrawableCarouselItem>() : beatmapContainer.AliveChildren;
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private OsuGame? game { get; set; }
+
+        [Resolved]
+        private IBindable<RulesetInfo> ruleset { get; set; } = null!;
+
+        public IReadOnlyList<DrawableCarouselItem> DrawableBeatmaps => beatmapContainer?.IsLoaded != true ? Array.Empty<DrawableCarouselItem>() : beatmapContainer;
 
         private Container<DrawableCarouselItem>? beatmapContainer;
 
@@ -287,6 +299,9 @@ public MenuItem[] ContextMenuItems
                 if (beatmapSet.Beatmaps.Any(b => b.Hidden))
                     items.Add(new OsuMenuItem("Restore all hidden", MenuItemType.Standard, () => restoreHiddenRequested(beatmapSet)));
 
+                if (beatmapSet.GetOnlineURL(api, ruleset.Value) is string url)
+                    items.Add(new OsuMenuItem("Copy link", MenuItemType.Standard, () => game?.CopyUrlToClipboard(url)));
+
                 if (dialogOverlay != null)
                     items.Add(new OsuMenuItem("Delete...", MenuItemType.Destructive, () => dialogOverlay.Push(new BeatmapDeleteDialog(beatmapSet))));
                 return items.ToArray();
diff --git a/osu.Game/Screens/Select/FilterQueryParser.cs b/osu.Game/Screens/Select/FilterQueryParser.cs
index 40fd289be620..6c9a95a250fb 100644
--- a/osu.Game/Screens/Select/FilterQueryParser.cs
+++ b/osu.Game/Screens/Select/FilterQueryParser.cs
@@ -62,10 +62,31 @@ private static bool tryParseKeywordCriteria(FilterCriteria criteria, string key,
                 case "length":
                     return tryUpdateLengthRange(criteria, op, value);
 
-                case "played":
                 case "lastplayed":
                     return tryUpdateDateAgoRange(ref criteria.LastPlayed, op, value);
 
+                case "played":
+                    if (!tryParseBool(value, out bool played))
+                        return false;
+
+                    // Unplayed beatmaps are filtered on DateTimeOffset.MinValue.
+
+                    if (played)
+                    {
+                        criteria.LastPlayed.Min = DateTimeOffset.MinValue;
+                        criteria.LastPlayed.Max = DateTimeOffset.MaxValue;
+                        criteria.LastPlayed.IsLowerInclusive = false;
+                    }
+                    else
+                    {
+                        criteria.LastPlayed.Min = DateTimeOffset.MinValue;
+                        criteria.LastPlayed.Max = DateTimeOffset.MinValue;
+                        criteria.LastPlayed.IsLowerInclusive = true;
+                        criteria.LastPlayed.IsUpperInclusive = true;
+                    }
+
+                    return true;
+
                 case "divisor":
                     return TryUpdateCriteriaRange(ref criteria.BeatDivisor, op, value, tryParseInt);
 
@@ -133,6 +154,25 @@ private static bool tryParseDoubleWithPoint(string value, out double result) =>
         private static bool tryParseInt(string value, out int result) =>
             int.TryParse(value, NumberStyles.None, CultureInfo.InvariantCulture, out result);
 
+        private static bool tryParseBool(string value, out bool result)
+        {
+            switch (value)
+            {
+                case "1":
+                case "yes":
+                    result = true;
+                    return true;
+
+                case "0":
+                case "no":
+                    result = false;
+                    return true;
+
+                default:
+                    return bool.TryParse(value, out result);
+            }
+        }
+
         private static bool tryParseEnum<TEnum>(string value, out TEnum result) where TEnum : struct
         {
             // First try an exact match.
diff --git a/osu.Game/Screens/Select/ModSpeedHotkeyHandler.cs b/osu.Game/Screens/Select/ModSpeedHotkeyHandler.cs
index af64002bcfeb..c4cd44705e85 100644
--- a/osu.Game/Screens/Select/ModSpeedHotkeyHandler.cs
+++ b/osu.Game/Screens/Select/ModSpeedHotkeyHandler.cs
@@ -27,6 +27,7 @@ public partial class ModSpeedHotkeyHandler : Component
         private OnScreenDisplay? onScreenDisplay { get; set; }
 
         private ModRateAdjust? lastActiveRateAdjustMod;
+        private ModSettingChangeTracker? settingChangeTracker;
 
         protected override void LoadComplete()
         {
@@ -34,10 +35,19 @@ protected override void LoadComplete()
 
             selectedMods.BindValueChanged(val =>
             {
-                lastActiveRateAdjustMod = val.NewValue.OfType<ModRateAdjust>().SingleOrDefault() ?? lastActiveRateAdjustMod;
+                storeLastActiveRateAdjustMod();
+
+                settingChangeTracker?.Dispose();
+                settingChangeTracker = new ModSettingChangeTracker(val.NewValue);
+                settingChangeTracker.SettingChanged += _ => storeLastActiveRateAdjustMod();
             }, true);
         }
 
+        private void storeLastActiveRateAdjustMod()
+        {
+            lastActiveRateAdjustMod = (ModRateAdjust?)selectedMods.Value.OfType<ModRateAdjust>().SingleOrDefault()?.DeepClone() ?? lastActiveRateAdjustMod;
+        }
+
         public bool ChangeSpeed(double delta, IEnumerable<Mod> availableMods)
         {
             double targetSpeed = (selectedMods.Value.OfType<ModRateAdjust>().SingleOrDefault()?.SpeedChange.Value ?? 1) + delta;
diff --git a/osu.Game/Screens/Select/SongSelect.cs b/osu.Game/Screens/Select/SongSelect.cs
index 2ee5a6f3cbf2..18608d61e972 100644
--- a/osu.Game/Screens/Select/SongSelect.cs
+++ b/osu.Game/Screens/Select/SongSelect.cs
@@ -127,6 +127,8 @@ public abstract partial class SongSelect : ScreenWithBeatmapBackground, IKeyBind
         private Sample sampleChangeDifficulty = null!;
         private Sample sampleChangeBeatmap = null!;
 
+        private bool pendingFilterApplication;
+
         private Container carouselContainer = null!;
 
         protected BeatmapDetailArea BeatmapDetails { get; private set; } = null!;
@@ -162,20 +164,6 @@ private void load(AudioManager audio, OsuColour colours, ManageCollectionsDialog
                 ApplyToBackground(applyBlurToBackground);
             });
 
-            LoadComponentAsync(Carousel = new BeatmapCarousel
-            {
-                AllowSelection = false, // delay any selection until our bindables are ready to make a good choice.
-                Anchor = Anchor.CentreRight,
-                Origin = Anchor.CentreRight,
-                RelativeSizeAxes = Axes.Both,
-                BleedTop = FilterControl.HEIGHT,
-                BleedBottom = Select.Footer.HEIGHT,
-                SelectionChanged = updateSelectedBeatmap,
-                BeatmapSetsChanged = carouselBeatmapsLoaded,
-                FilterApplied = () => Scheduler.AddOnce(updateVisibleBeatmapCount),
-                GetRecommendedBeatmap = s => recommender?.GetRecommendedBeatmap(s),
-            }, c => carouselContainer.Child = c);
-
             // initial value transfer is required for FilterControl (it uses our re-cached bindables in its async load for the initial filter).
             transferRulesetValue();
 
@@ -227,7 +215,6 @@ private void load(AudioManager audio, OsuColour colours, ManageCollectionsDialog
                         {
                             RelativeSizeAxes = Axes.X,
                             Height = FilterControl.HEIGHT,
-                            FilterChanged = ApplyFilterToCarousel,
                         },
                         new GridContainer // used for max width implementation
                         {
@@ -321,13 +308,43 @@ private void load(AudioManager audio, OsuColour colours, ManageCollectionsDialog
                         }
                     }
                 },
-                new SkinComponentsContainer(new SkinComponentsContainerLookup(SkinComponentsContainerLookup.TargetArea.SongSelect))
+                new SkinnableContainer(new GlobalSkinnableContainerLookup(GlobalSkinnableContainers.SongSelect))
                 {
                     RelativeSizeAxes = Axes.Both,
                 },
                 modSpeedHotkeyHandler = new ModSpeedHotkeyHandler(),
             });
 
+            // Important to load this after the filter control is loaded (so we have initial filter criteria prepared).
+            LoadComponentAsync(Carousel = new BeatmapCarousel(FilterControl.CreateCriteria())
+            {
+                AllowSelection = false, // delay any selection until our bindables are ready to make a good choice.
+                Anchor = Anchor.CentreRight,
+                Origin = Anchor.CentreRight,
+                RelativeSizeAxes = Axes.Both,
+                BleedTop = FilterControl.HEIGHT,
+                BleedBottom = Select.Footer.HEIGHT,
+                SelectionChanged = updateSelectedBeatmap,
+                BeatmapSetsChanged = carouselBeatmapsLoaded,
+                FilterApplied = () => Scheduler.AddOnce(updateVisibleBeatmapCount),
+                GetRecommendedBeatmap = s => recommender?.GetRecommendedBeatmap(s),
+            }, c => carouselContainer.Child = c);
+
+            FilterControl.FilterChanged = criteria =>
+            {
+                // If a filter operation is applied when we're in a state that doesn't allow selection,
+                // we might end up in an unexpected state. This is because currently carousel panels are in charge
+                // of updating the global selection (which is very hard to deal with).
+                //
+                // For now let's just avoid filtering when selection isn't allowed locally.
+                // This should be nuked from existence when we get around to fixing the complexity of song select <-> beatmap carousel.
+                // The debounce part of BeatmapCarousel's filtering should probably also be removed and handled locally.
+                if (Carousel.AllowSelection)
+                    Carousel.Filter(criteria);
+                else
+                    pendingFilterApplication = true;
+            };
+
             if (ShowSongSelectFooter)
             {
                 AddRangeInternal(new Drawable[]
@@ -401,14 +418,6 @@ protected override bool OnScroll(ScrollEvent e)
 
         protected virtual ModSelectOverlay CreateModSelectOverlay() => new SoloModSelectOverlay();
 
-        protected virtual void ApplyFilterToCarousel(FilterCriteria criteria)
-        {
-            // if not the current screen, we want to get carousel in a good presentation state before displaying (resume or enter).
-            bool shouldDebounce = this.IsCurrentScreen();
-
-            Carousel.Filter(criteria, shouldDebounce);
-        }
-
         private DependencyContainer dependencies = null!;
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
@@ -434,7 +443,8 @@ public void Edit(BeatmapInfo? beatmapInfo = null)
 
             // Forced refetch is important here to guarantee correct invalidation across all difficulties.
             Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmapInfo ?? beatmapInfoNoDebounce, true);
-            this.Push(new EditorLoader());
+
+            FinaliseSelection(customStartAction: () => this.Push(new EditorLoader()));
         }
 
         /// <summary>
@@ -706,6 +716,12 @@ public override void OnResuming(ScreenTransitionEvent e)
 
             Carousel.AllowSelection = true;
 
+            if (pendingFilterApplication)
+            {
+                Carousel.Filter(FilterControl.CreateCriteria());
+                pendingFilterApplication = false;
+            }
+
             BeatmapDetails.Refresh();
 
             beginLooping();
@@ -992,7 +1008,8 @@ private bool transferRulesetValue()
 
             // if we have a pending filter operation, we want to run it now.
             // it could change selection (ie. if the ruleset has been changed).
-            Carousel.FlushPendingFilterOperations();
+            if (IsLoaded)
+                Carousel.FlushPendingFilterOperations();
 
             return true;
         }
diff --git a/osu.Game/Skinning/ArgonSkin.cs b/osu.Game/Skinning/ArgonSkin.cs
index c66df82e0d28..771d10d73b0e 100644
--- a/osu.Game/Skinning/ArgonSkin.cs
+++ b/osu.Game/Skinning/ArgonSkin.cs
@@ -96,14 +96,10 @@ public ArgonSkin(SkinInfo skin, IStorageResourceProvider resources)
 
             switch (lookup)
             {
-                case SkinComponentsContainerLookup containerLookup:
-
-                    if (base.GetDrawableComponent(lookup) is UserConfiguredLayoutContainer c)
-                        return c;
-
-                    switch (containerLookup.Target)
+                case GlobalSkinnableContainerLookup containerLookup:
+                    switch (containerLookup.Lookup)
                     {
-                        case SkinComponentsContainerLookup.TargetArea.SongSelect:
+                        case GlobalSkinnableContainers.SongSelect:
                             var songSelectComponents = new DefaultSkinComponentsContainer(_ =>
                             {
                                 // do stuff when we need to.
@@ -111,7 +107,7 @@ public ArgonSkin(SkinInfo skin, IStorageResourceProvider resources)
 
                             return songSelectComponents;
 
-                        case SkinComponentsContainerLookup.TargetArea.MainHUDComponents:
+                        case GlobalSkinnableContainers.MainHUDComponents:
                             if (containerLookup.Ruleset != null)
                             {
                                 return new Container
diff --git a/osu.Game/Skinning/Components/BeatmapAttributeText.cs b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
index c467b2e94621..6e1d655cef6f 100644
--- a/osu.Game/Skinning/Components/BeatmapAttributeText.cs
+++ b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
@@ -123,6 +123,8 @@ private void updateLabel()
         }
 
         protected override void SetFont(FontUsage font) => text.Font = font.With(size: 40);
+
+        protected override void SetTextColour(Colour4 textColour) => text.Colour = textColour;
     }
 
     // WARNING: DO NOT ADD ANY VALUES TO THIS ENUM ANYWHERE ELSE THAN AT THE END.
diff --git a/osu.Game/Skinning/Components/BoxElement.cs b/osu.Game/Skinning/Components/BoxElement.cs
index 34d389728cb1..7f052a8523ae 100644
--- a/osu.Game/Skinning/Components/BoxElement.cs
+++ b/osu.Game/Skinning/Components/BoxElement.cs
@@ -27,6 +27,9 @@ public partial class BoxElement : CompositeDrawable, ISerialisableDrawable
             Precision = 0.01f
         };
 
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Colour), nameof(SkinnableComponentStrings.ColourDescription))]
+        public BindableColour4 AccentColour { get; } = new BindableColour4(Colour4.White);
+
         public BoxElement()
         {
             Size = new Vector2(400, 80);
@@ -43,6 +46,13 @@ public BoxElement()
             Masking = true;
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AccentColour.BindValueChanged(_ => Colour = AccentColour.Value, true);
+        }
+
         protected override void Update()
         {
             base.Update();
diff --git a/osu.Game/Skinning/Components/PlayerName.cs b/osu.Game/Skinning/Components/PlayerName.cs
index 21bf615bc61c..5b6ded0cc5f7 100644
--- a/osu.Game/Skinning/Components/PlayerName.cs
+++ b/osu.Game/Skinning/Components/PlayerName.cs
@@ -53,5 +53,7 @@ private void load()
         }
 
         protected override void SetFont(FontUsage font) => text.Font = font.With(size: 40);
+
+        protected override void SetTextColour(Colour4 textColour) => text.Colour = textColour;
     }
 }
diff --git a/osu.Game/Skinning/Components/TextElement.cs b/osu.Game/Skinning/Components/TextElement.cs
index 936f6a529b4b..6e875c559094 100644
--- a/osu.Game/Skinning/Components/TextElement.cs
+++ b/osu.Game/Skinning/Components/TextElement.cs
@@ -36,5 +36,7 @@ public TextElement()
         }
 
         protected override void SetFont(FontUsage font) => text.Font = font.With(size: 40);
+
+        protected override void SetTextColour(Colour4 textColour) => text.Colour = textColour;
     }
 }
diff --git a/osu.Game/Skinning/FontAdjustableSkinComponent.cs b/osu.Game/Skinning/FontAdjustableSkinComponent.cs
index 8f3a1d41c610..0821edf7fcde 100644
--- a/osu.Game/Skinning/FontAdjustableSkinComponent.cs
+++ b/osu.Game/Skinning/FontAdjustableSkinComponent.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Configuration;
@@ -20,11 +21,16 @@ public abstract partial class FontAdjustableSkinComponent : Container, ISerialis
         [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Font), nameof(SkinnableComponentStrings.FontDescription))]
         public Bindable<Typeface> Font { get; } = new Bindable<Typeface>(Typeface.Torus);
 
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.TextColour), nameof(SkinnableComponentStrings.TextColourDescription))]
+        public BindableColour4 TextColour { get; } = new BindableColour4(Colour4.White);
+
         /// <summary>
         /// Implement to apply the user font selection to one or more components.
         /// </summary>
         protected abstract void SetFont(FontUsage font);
 
+        protected abstract void SetTextColour(Colour4 textColour);
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -37,6 +43,8 @@ protected override void LoadComplete()
                 FontUsage f = OsuFont.GetFont(e.NewValue, weight: fontWeight);
                 SetFont(f);
             }, true);
+
+            TextColour.BindValueChanged(e => SetTextColour(e.NewValue), true);
         }
     }
 }
diff --git a/osu.Game/Skinning/GameplaySkinComponentLookup.cs b/osu.Game/Skinning/GameplaySkinComponentLookup.cs
deleted file mode 100644
index c317a17e2137..000000000000
--- a/osu.Game/Skinning/GameplaySkinComponentLookup.cs
+++ /dev/null
@@ -1,28 +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 osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Skinning
-{
-    /// <summary>
-    /// A lookup type intended for use for skinnable gameplay components (not HUD level components).
-    /// </summary>
-    /// <remarks>
-    /// The most common usage of this class is for ruleset-specific skinning implementations, but it can also be used directly
-    /// (see <see cref="DrawableJudgement"/>'s usage for <see cref="HitResult"/>) where ruleset-agnostic elements are required.
-    /// </remarks>
-    /// <typeparam name="T">An enum lookup type.</typeparam>
-    public class GameplaySkinComponentLookup<T> : ISkinComponentLookup
-        where T : Enum
-    {
-        public readonly T Component;
-
-        public GameplaySkinComponentLookup(T component)
-        {
-            Component = component;
-        }
-    }
-}
diff --git a/osu.Game/Skinning/SkinComponentsContainerLookup.cs b/osu.Game/Skinning/GlobalSkinnableContainerLookup.cs
similarity index 55%
rename from osu.Game/Skinning/SkinComponentsContainerLookup.cs
rename to osu.Game/Skinning/GlobalSkinnableContainerLookup.cs
index 34358c3f0693..6d78981f0a67 100644
--- a/osu.Game/Skinning/SkinComponentsContainerLookup.cs
+++ b/osu.Game/Skinning/GlobalSkinnableContainerLookup.cs
@@ -2,21 +2,20 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.ComponentModel;
 using osu.Framework.Extensions;
 using osu.Game.Rulesets;
 
 namespace osu.Game.Skinning
 {
     /// <summary>
-    /// Represents a lookup of a collection of elements that make up a particular skinnable <see cref="TargetArea"/> of the game.
+    /// Represents a lookup of a collection of elements that make up a particular skinnable <see cref="GlobalSkinnableContainers"/> of the game.
     /// </summary>
-    public class SkinComponentsContainerLookup : ISkinComponentLookup, IEquatable<SkinComponentsContainerLookup>
+    public class GlobalSkinnableContainerLookup : ISkinComponentLookup, IEquatable<GlobalSkinnableContainerLookup>
     {
         /// <summary>
         /// The target area / layer of the game for which skin components will be returned.
         /// </summary>
-        public readonly TargetArea Target;
+        public readonly GlobalSkinnableContainers Lookup;
 
         /// <summary>
         /// The ruleset for which skin components should be returned.
@@ -24,25 +23,25 @@ public class SkinComponentsContainerLookup : ISkinComponentLookup, IEquatable<Sk
         /// </summary>
         public readonly RulesetInfo? Ruleset;
 
-        public SkinComponentsContainerLookup(TargetArea target, RulesetInfo? ruleset = null)
+        public GlobalSkinnableContainerLookup(GlobalSkinnableContainers lookup, RulesetInfo? ruleset = null)
         {
-            Target = target;
+            Lookup = lookup;
             Ruleset = ruleset;
         }
 
         public override string ToString()
         {
-            if (Ruleset == null) return Target.GetDescription();
+            if (Ruleset == null) return Lookup.GetDescription();
 
-            return $"{Target.GetDescription()} (\"{Ruleset.Name}\" only)";
+            return $"{Lookup.GetDescription()} (\"{Ruleset.Name}\" only)";
         }
 
-        public bool Equals(SkinComponentsContainerLookup? other)
+        public bool Equals(GlobalSkinnableContainerLookup? other)
         {
             if (ReferenceEquals(null, other)) return false;
             if (ReferenceEquals(this, other)) return true;
 
-            return Target == other.Target && (ReferenceEquals(Ruleset, other.Ruleset) || Ruleset?.Equals(other.Ruleset) == true);
+            return Lookup == other.Lookup && (ReferenceEquals(Ruleset, other.Ruleset) || Ruleset?.Equals(other.Ruleset) == true);
         }
 
         public override bool Equals(object? obj)
@@ -51,27 +50,12 @@ public override bool Equals(object? obj)
             if (ReferenceEquals(this, obj)) return true;
             if (obj.GetType() != GetType()) return false;
 
-            return Equals((SkinComponentsContainerLookup)obj);
+            return Equals((GlobalSkinnableContainerLookup)obj);
         }
 
         public override int GetHashCode()
         {
-            return HashCode.Combine((int)Target, Ruleset);
-        }
-
-        /// <summary>
-        /// Represents a particular area or part of a game screen whose layout can be customised using the skin editor.
-        /// </summary>
-        public enum TargetArea
-        {
-            [Description("HUD")]
-            MainHUDComponents,
-
-            [Description("Song select")]
-            SongSelect,
-
-            [Description("Playfield")]
-            Playfield
+            return HashCode.Combine((int)Lookup, Ruleset);
         }
     }
 }
diff --git a/osu.Game/Skinning/GlobalSkinnableContainers.cs b/osu.Game/Skinning/GlobalSkinnableContainers.cs
new file mode 100644
index 000000000000..02f915895f37
--- /dev/null
+++ b/osu.Game/Skinning/GlobalSkinnableContainers.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 System.ComponentModel;
+
+namespace osu.Game.Skinning
+{
+    /// <summary>
+    /// Represents a particular area or part of a game screen whose layout can be customised using the skin editor.
+    /// </summary>
+    public enum GlobalSkinnableContainers
+    {
+        [Description("HUD")]
+        MainHUDComponents,
+
+        [Description("Song select")]
+        SongSelect,
+
+        [Description("Playfield")]
+        Playfield
+    }
+}
diff --git a/osu.Game/Skinning/ISkinComponentLookup.cs b/osu.Game/Skinning/ISkinComponentLookup.cs
index 25ee086707ca..af2b512331b3 100644
--- a/osu.Game/Skinning/ISkinComponentLookup.cs
+++ b/osu.Game/Skinning/ISkinComponentLookup.cs
@@ -12,7 +12,7 @@ namespace osu.Game.Skinning
     /// to scope particular lookup variations. Using this, a ruleset or skin implementation could make its own lookup
     /// type to scope away from more global contexts.
     ///
-    /// More commonly, a ruleset could make use of <see cref="GameplaySkinComponentLookup{T}"/> to do a simple lookup based on
+    /// More commonly, a ruleset could make use of <see cref="SkinComponentLookup{T}"/> to do a simple lookup based on
     /// a provided enum.
     /// </remarks>
     public interface ISkinComponentLookup
diff --git a/osu.Game/Skinning/LegacyBeatmapSkin.cs b/osu.Game/Skinning/LegacyBeatmapSkin.cs
index 9cd072b60754..656c0e046f59 100644
--- a/osu.Game/Skinning/LegacyBeatmapSkin.cs
+++ b/osu.Game/Skinning/LegacyBeatmapSkin.cs
@@ -50,11 +50,11 @@ private static IResourceStore<byte[]> createRealmBackedStore(BeatmapInfo beatmap
 
         public override Drawable? GetDrawableComponent(ISkinComponentLookup lookup)
         {
-            if (lookup is SkinComponentsContainerLookup containerLookup)
+            if (lookup is GlobalSkinnableContainerLookup containerLookup)
             {
-                switch (containerLookup.Target)
+                switch (containerLookup.Lookup)
                 {
-                    case SkinComponentsContainerLookup.TargetArea.MainHUDComponents:
+                    case GlobalSkinnableContainers.MainHUDComponents:
                         // this should exist in LegacySkin instead, but there isn't a fallback skin for LegacySkins yet.
                         // therefore keep the check here until fallback default legacy skin is supported.
                         if (!this.HasFont(LegacyFont.Score))
diff --git a/osu.Game/Skinning/LegacyComboCounter.cs b/osu.Game/Skinning/LegacyComboCounter.cs
deleted file mode 100644
index 7003e0d3c83a..000000000000
--- a/osu.Game/Skinning/LegacyComboCounter.cs
+++ /dev/null
@@ -1,203 +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 osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Skinning
-{
-    /// <summary>
-    /// Uses the 'x' symbol and has a pop-out effect while rolling over.
-    /// </summary>
-    public abstract partial class LegacyComboCounter : CompositeDrawable, ISerialisableDrawable
-    {
-        public Bindable<int> Current { get; } = new BindableInt { MinValue = 0 };
-
-        private const double fade_out_duration = 100;
-
-        /// <summary>
-        /// Duration in milliseconds for the counter roll-up animation for each element.
-        /// </summary>
-        private const double rolling_duration = 20;
-
-        protected readonly LegacySpriteText PopOutCountText;
-        protected readonly LegacySpriteText DisplayedCountText;
-
-        private int previousValue;
-
-        private int displayedCount;
-
-        private bool isRolling;
-
-        private readonly Container counterContainer;
-
-        public bool UsesFixedAnchor { get; set; }
-
-        protected LegacyComboCounter()
-        {
-            AutoSizeAxes = Axes.Both;
-
-            InternalChildren = new[]
-            {
-                counterContainer = new Container
-                {
-                    AlwaysPresent = true,
-                    Children = new[]
-                    {
-                        PopOutCountText = new LegacySpriteText(LegacyFont.Combo)
-                        {
-                            Alpha = 0,
-                            Blending = BlendingParameters.Additive,
-                            BypassAutoSizeAxes = Axes.Both,
-                        },
-                        DisplayedCountText = new LegacySpriteText(LegacyFont.Combo)
-                        {
-                            Alpha = 0,
-                            AlwaysPresent = true,
-                            BypassAutoSizeAxes = Axes.Both,
-                        },
-                    }
-                }
-            };
-        }
-
-        /// <summary>
-        /// Value shown at the current moment.
-        /// </summary>
-        public virtual int DisplayedCount
-        {
-            get => displayedCount;
-            private set
-            {
-                if (displayedCount.Equals(value))
-                    return;
-
-                if (isRolling)
-                    onDisplayedCountRolling(value);
-                else if (displayedCount + 1 == value)
-                    onDisplayedCountIncrement(value);
-                else
-                    onDisplayedCountChange(value);
-
-                displayedCount = value;
-            }
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(ScoreProcessor scoreProcessor)
-        {
-            Current.BindTo(scoreProcessor.Combo);
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            DisplayedCountText.Text = FormatCount(Current.Value);
-            PopOutCountText.Text = FormatCount(Current.Value);
-
-            Current.BindValueChanged(combo => updateCount(combo.NewValue == 0), true);
-
-            counterContainer.Size = DisplayedCountText.Size;
-        }
-
-        private void updateCount(bool rolling)
-        {
-            int prev = previousValue;
-            previousValue = Current.Value;
-
-            if (!IsLoaded)
-                return;
-
-            if (!rolling)
-            {
-                FinishTransforms(false, nameof(DisplayedCount));
-
-                isRolling = false;
-                DisplayedCount = prev;
-
-                if (prev + 1 == Current.Value)
-                    OnCountIncrement();
-                else
-                    OnCountChange();
-            }
-            else
-            {
-                OnCountRolling();
-                isRolling = true;
-            }
-        }
-
-        /// <summary>
-        /// Raised when the counter should display the new value with transitions.
-        /// </summary>
-        protected virtual void OnCountIncrement()
-        {
-            if (DisplayedCount < Current.Value - 1)
-                DisplayedCount++;
-
-            DisplayedCount++;
-        }
-
-        /// <summary>
-        /// Raised when the counter should roll to the new combo value (usually roll back to zero).
-        /// </summary>
-        protected virtual void OnCountRolling()
-        {
-            // Hides displayed count if was increasing from 0 to 1 but didn't finish
-            if (DisplayedCount == 0 && Current.Value == 0)
-                DisplayedCountText.FadeOut(fade_out_duration);
-
-            transformRoll(DisplayedCount, Current.Value);
-        }
-
-        /// <summary>
-        /// Raised when the counter should display the new combo value without any transitions.
-        /// </summary>
-        protected virtual void OnCountChange()
-        {
-            if (Current.Value == 0)
-                DisplayedCountText.FadeOut();
-
-            DisplayedCount = Current.Value;
-        }
-
-        private void onDisplayedCountRolling(int newValue)
-        {
-            if (newValue == 0)
-                DisplayedCountText.FadeOut(fade_out_duration);
-
-            DisplayedCountText.Text = FormatCount(newValue);
-            counterContainer.Size = DisplayedCountText.Size;
-        }
-
-        private void onDisplayedCountChange(int newValue)
-        {
-            DisplayedCountText.FadeTo(newValue == 0 ? 0 : 1);
-            DisplayedCountText.Text = FormatCount(newValue);
-
-            counterContainer.Size = DisplayedCountText.Size;
-        }
-
-        private void onDisplayedCountIncrement(int newValue)
-        {
-            DisplayedCountText.Text = FormatCount(newValue);
-
-            counterContainer.Size = DisplayedCountText.Size;
-        }
-
-        private void transformRoll(int currentValue, int newValue) =>
-            this.TransformTo(nameof(DisplayedCount), newValue, getProportionalDuration(currentValue, newValue));
-
-        protected virtual string FormatCount(int count) => $@"{count}";
-
-        private double getProportionalDuration(int currentValue, int newValue)
-        {
-            double difference = currentValue > newValue ? currentValue - newValue : newValue - currentValue;
-            return difference * rolling_duration;
-        }
-    }
-}
diff --git a/osu.Game/Skinning/LegacyDefaultComboCounter.cs b/osu.Game/Skinning/LegacyDefaultComboCounter.cs
index 6c81b1f959a5..7de4aee65635 100644
--- a/osu.Game/Skinning/LegacyDefaultComboCounter.cs
+++ b/osu.Game/Skinning/LegacyDefaultComboCounter.cs
@@ -1,8 +1,12 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Threading;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Scoring;
 using osuTK;
 
 namespace osu.Game.Skinning
@@ -10,73 +14,265 @@ namespace osu.Game.Skinning
     /// <summary>
     /// Uses the 'x' symbol and has a pop-out effect while rolling over.
     /// </summary>
-    public partial class LegacyDefaultComboCounter : LegacyComboCounter
+    public partial class LegacyDefaultComboCounter : CompositeDrawable, ISerialisableDrawable
     {
+        public Bindable<int> Current { get; } = new BindableInt { MinValue = 0 };
+
+        private uint scheduledPopOutCurrentId;
+
         private const double big_pop_out_duration = 300;
+
         private const double small_pop_out_duration = 100;
 
-        private ScheduledDelegate? scheduledPopOut;
+        private const double fade_out_duration = 100;
+
+        /// <summary>
+        /// Duration in milliseconds for the counter roll-up animation for each element.
+        /// </summary>
+        private const double rolling_duration = 20;
+
+        private readonly Drawable popOutCount;
+
+        private readonly Drawable displayedCountSpriteText;
+
+        private int previousValue;
+
+        private int displayedCount;
+
+        private bool isRolling;
+
+        private readonly Container counterContainer;
+
+        public bool UsesFixedAnchor { get; set; }
 
         public LegacyDefaultComboCounter()
         {
+            AutoSizeAxes = Axes.Both;
+
+            Anchor = Anchor.BottomLeft;
+            Origin = Anchor.BottomLeft;
+
             Margin = new MarginPadding(10);
 
-            PopOutCountText.Anchor = Anchor.BottomLeft;
-            DisplayedCountText.Anchor = Anchor.BottomLeft;
+            Scale = new Vector2(1.28f);
+
+            InternalChildren = new[]
+            {
+                counterContainer = new Container
+                {
+                    AlwaysPresent = true,
+                    Children = new[]
+                    {
+                        popOutCount = new LegacySpriteText(LegacyFont.Combo)
+                        {
+                            Alpha = 0,
+                            Blending = BlendingParameters.Additive,
+                            Anchor = Anchor.BottomLeft,
+                            BypassAutoSizeAxes = Axes.Both,
+                        },
+                        displayedCountSpriteText = new LegacySpriteText(LegacyFont.Combo)
+                        {
+                            Alpha = 0,
+                            AlwaysPresent = true,
+                            Anchor = Anchor.BottomLeft,
+                            BypassAutoSizeAxes = Axes.Both,
+                        },
+                    }
+                }
+            };
+        }
+
+        /// <summary>
+        /// Value shown at the current moment.
+        /// </summary>
+        public virtual int DisplayedCount
+        {
+            get => displayedCount;
+            private set
+            {
+                if (displayedCount.Equals(value))
+                    return;
+
+                if (isRolling)
+                    onDisplayedCountRolling(value);
+                else if (displayedCount + 1 == value)
+                    onDisplayedCountIncrement(value);
+                else
+                    onDisplayedCountChange(value);
+
+                displayedCount = value;
+            }
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ScoreProcessor scoreProcessor)
+        {
+            Current.BindTo(scoreProcessor.Combo);
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
+            ((IHasText)displayedCountSpriteText).Text = formatCount(Current.Value);
+            ((IHasText)popOutCount).Text = formatCount(Current.Value);
+
+            Current.BindValueChanged(combo => updateCount(combo.NewValue == 0), true);
+
+            updateLayout();
+        }
+
+        private void updateLayout()
+        {
             const float font_height_ratio = 0.625f;
             const float vertical_offset = 9;
 
-            DisplayedCountText.OriginPosition = new Vector2(0, font_height_ratio * DisplayedCountText.Height + vertical_offset);
-            DisplayedCountText.Position = new Vector2(0, -(1 - font_height_ratio) * DisplayedCountText.Height + vertical_offset);
+            displayedCountSpriteText.OriginPosition = new Vector2(0, font_height_ratio * displayedCountSpriteText.Height + vertical_offset);
+            displayedCountSpriteText.Position = new Vector2(0, -(1 - font_height_ratio) * displayedCountSpriteText.Height + vertical_offset);
+
+            popOutCount.OriginPosition = new Vector2(3, font_height_ratio * popOutCount.Height + vertical_offset); // In stable, the bigger pop out scales a bit to the left
+            popOutCount.Position = new Vector2(0, -(1 - font_height_ratio) * popOutCount.Height + vertical_offset);
 
-            PopOutCountText.OriginPosition = new Vector2(3, font_height_ratio * PopOutCountText.Height + vertical_offset); // In stable, the bigger pop out scales a bit to the left
-            PopOutCountText.Position = new Vector2(0, -(1 - font_height_ratio) * PopOutCountText.Height + vertical_offset);
+            counterContainer.Size = displayedCountSpriteText.Size;
         }
 
-        protected override void OnCountIncrement()
+        private void updateCount(bool rolling)
         {
-            DisplayedCountText.Show();
+            int prev = previousValue;
+            previousValue = Current.Value;
 
-            PopOutCountText.Text = FormatCount(Current.Value);
+            if (!IsLoaded)
+                return;
 
-            PopOutCountText.ScaleTo(1.56f)
-                           .ScaleTo(1, big_pop_out_duration);
+            if (!rolling)
+            {
+                FinishTransforms(false, nameof(DisplayedCount));
+                isRolling = false;
+                DisplayedCount = prev;
 
-            PopOutCountText.FadeTo(0.6f)
-                           .FadeOut(big_pop_out_duration);
+                if (prev + 1 == Current.Value)
+                    onCountIncrement(prev, Current.Value);
+                else
+                    onCountChange(Current.Value);
+            }
+            else
+            {
+                onCountRolling(displayedCount, Current.Value);
+                isRolling = true;
+            }
+        }
 
-            this.Delay(big_pop_out_duration - 140).Schedule(() =>
+        private void transformPopOut(int newValue)
+        {
+            ((IHasText)popOutCount).Text = formatCount(newValue);
+
+            popOutCount.ScaleTo(1.56f)
+                       .ScaleTo(1, big_pop_out_duration);
+
+            popOutCount.FadeTo(0.6f)
+                       .FadeOut(big_pop_out_duration);
+        }
+
+        private void transformNoPopOut(int newValue)
+        {
+            ((IHasText)displayedCountSpriteText).Text = formatCount(newValue);
+
+            counterContainer.Size = displayedCountSpriteText.Size;
+
+            displayedCountSpriteText.ScaleTo(1);
+        }
+
+        private void transformPopOutSmall(int newValue)
+        {
+            ((IHasText)displayedCountSpriteText).Text = formatCount(newValue);
+
+            counterContainer.Size = displayedCountSpriteText.Size;
+
+            displayedCountSpriteText.ScaleTo(1).Then()
+                                    .ScaleTo(1.1f, small_pop_out_duration / 2, Easing.In).Then()
+                                    .ScaleTo(1, small_pop_out_duration / 2, Easing.Out);
+        }
+
+        private void scheduledPopOutSmall(uint id)
+        {
+            // Too late; scheduled task invalidated
+            if (id != scheduledPopOutCurrentId)
+                return;
+
+            DisplayedCount++;
+        }
+
+        private void onCountIncrement(int currentValue, int newValue)
+        {
+            scheduledPopOutCurrentId++;
+
+            if (DisplayedCount < currentValue)
+                DisplayedCount++;
+
+            displayedCountSpriteText.Show();
+
+            transformPopOut(newValue);
+
+            uint newTaskId = scheduledPopOutCurrentId;
+
+            Scheduler.AddDelayed(delegate
             {
-                base.OnCountIncrement();
+                scheduledPopOutSmall(newTaskId);
+            }, big_pop_out_duration - 140);
+        }
+
+        private void onCountRolling(int currentValue, int newValue)
+        {
+            scheduledPopOutCurrentId++;
+
+            // Hides displayed count if was increasing from 0 to 1 but didn't finish
+            if (currentValue == 0 && newValue == 0)
+                displayedCountSpriteText.FadeOut(fade_out_duration);
+
+            transformRoll(currentValue, newValue);
+        }
 
-                DisplayedCountText.ScaleTo(1).Then()
-                                  .ScaleTo(1.1f, small_pop_out_duration / 2, Easing.In).Then()
-                                  .ScaleTo(1, small_pop_out_duration / 2, Easing.Out);
-            }, out scheduledPopOut);
+        private void onCountChange(int newValue)
+        {
+            scheduledPopOutCurrentId++;
+
+            if (newValue == 0)
+                displayedCountSpriteText.FadeOut();
+
+            DisplayedCount = newValue;
         }
 
-        protected override void OnCountRolling()
+        private void onDisplayedCountRolling(int newValue)
         {
-            scheduledPopOut?.Cancel();
-            scheduledPopOut = null;
+            if (newValue == 0)
+                displayedCountSpriteText.FadeOut(fade_out_duration);
+            else
+                displayedCountSpriteText.Show();
 
-            base.OnCountRolling();
+            transformNoPopOut(newValue);
         }
 
-        protected override void OnCountChange()
+        private void onDisplayedCountChange(int newValue)
         {
-            scheduledPopOut?.Cancel();
-            scheduledPopOut = null;
+            displayedCountSpriteText.FadeTo(newValue == 0 ? 0 : 1);
+            transformNoPopOut(newValue);
+        }
 
-            base.OnCountChange();
+        private void onDisplayedCountIncrement(int newValue)
+        {
+            displayedCountSpriteText.Show();
+            transformPopOutSmall(newValue);
         }
 
-        protected override string FormatCount(int count) => $@"{count}x";
+        private void transformRoll(int currentValue, int newValue) =>
+            this.TransformTo(nameof(DisplayedCount), newValue, getProportionalDuration(currentValue, newValue));
+
+        private string formatCount(int count) => $@"{count}x";
+
+        private double getProportionalDuration(int currentValue, int newValue)
+        {
+            double difference = currentValue > newValue ? currentValue - newValue : newValue - currentValue;
+            return difference * rolling_duration;
+        }
     }
 }
diff --git a/osu.Game/Skinning/LegacySkin.cs b/osu.Game/Skinning/LegacySkin.cs
index bbca0178d514..6faadfba9b54 100644
--- a/osu.Game/Skinning/LegacySkin.cs
+++ b/osu.Game/Skinning/LegacySkin.cs
@@ -358,13 +358,10 @@ protected override void ParseConfigurationStream(Stream stream)
         {
             switch (lookup)
             {
-                case SkinComponentsContainerLookup containerLookup:
-                    if (base.GetDrawableComponent(lookup) is UserConfiguredLayoutContainer c)
-                        return c;
-
-                    switch (containerLookup.Target)
+                case GlobalSkinnableContainerLookup containerLookup:
+                    switch (containerLookup.Lookup)
                     {
-                        case SkinComponentsContainerLookup.TargetArea.MainHUDComponents:
+                        case GlobalSkinnableContainers.MainHUDComponents:
                             if (containerLookup.Ruleset != null)
                             {
                                 return new DefaultSkinComponentsContainer(container =>
@@ -426,7 +423,7 @@ protected override void ParseConfigurationStream(Stream stream)
 
                     return null;
 
-                case GameplaySkinComponentLookup<HitResult> resultComponent:
+                case SkinComponentLookup<HitResult> resultComponent:
 
                     // kind of wasteful that we throw this away, but should do for now.
                     if (getJudgementAnimation(resultComponent.Component) != null)
diff --git a/osu.Game/Skinning/RealmBackedResourceStore.cs b/osu.Game/Skinning/RealmBackedResourceStore.cs
index cce099a26816..f41bd89b7a0d 100644
--- a/osu.Game/Skinning/RealmBackedResourceStore.cs
+++ b/osu.Game/Skinning/RealmBackedResourceStore.cs
@@ -29,7 +29,10 @@ public RealmBackedResourceStore(Live<T> source, IResourceStore<byte[]> underlyin
             invalidateCache();
             Debug.Assert(fileToStoragePathMapping != null);
 
-            realmSubscription = realm?.RegisterForNotifications(r => r.All<T>().Where(s => s.ID == source.ID), skinChanged);
+            // Required local for iOS. Will cause runtime crash if inlined.
+            Guid id = source.ID;
+
+            realmSubscription = realm?.RegisterForNotifications(r => r.All<T>().Where(s => s.ID == id), skinChanged);
         }
 
         protected override void Dispose(bool disposing)
diff --git a/osu.Game/Skinning/Skin.cs b/osu.Game/Skinning/Skin.cs
index 3a83815f0eaf..e93a10d50b64 100644
--- a/osu.Game/Skinning/Skin.cs
+++ b/osu.Game/Skinning/Skin.cs
@@ -14,6 +14,7 @@
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Framework.Logging;
@@ -43,10 +44,10 @@ public abstract class Skin : IDisposable, ISkin
 
         public SkinConfiguration Configuration { get; set; }
 
-        public IDictionary<SkinComponentsContainerLookup.TargetArea, SkinLayoutInfo> LayoutInfos => layoutInfos;
+        public IDictionary<GlobalSkinnableContainers, SkinLayoutInfo> LayoutInfos => layoutInfos;
 
-        private readonly Dictionary<SkinComponentsContainerLookup.TargetArea, SkinLayoutInfo> layoutInfos =
-            new Dictionary<SkinComponentsContainerLookup.TargetArea, SkinLayoutInfo>();
+        private readonly Dictionary<GlobalSkinnableContainers, SkinLayoutInfo> layoutInfos =
+            new Dictionary<GlobalSkinnableContainers, SkinLayoutInfo>();
 
         public abstract ISample? GetSample(ISampleInfo sampleInfo);
 
@@ -123,7 +124,7 @@ protected Skin(SkinInfo skin, IStorageResourceProvider? resources, IResourceStor
             }
 
             // skininfo files may be null for default skin.
-            foreach (SkinComponentsContainerLookup.TargetArea skinnableTarget in Enum.GetValues<SkinComponentsContainerLookup.TargetArea>())
+            foreach (GlobalSkinnableContainers skinnableTarget in Enum.GetValues<GlobalSkinnableContainers>())
             {
                 string filename = $"{skinnableTarget}.json";
 
@@ -162,19 +163,19 @@ protected virtual void ParseConfigurationStream(Stream stream)
         /// Remove all stored customisations for the provided target.
         /// </summary>
         /// <param name="targetContainer">The target container to reset.</param>
-        public void ResetDrawableTarget(SkinComponentsContainer targetContainer)
+        public void ResetDrawableTarget(SkinnableContainer targetContainer)
         {
-            LayoutInfos.Remove(targetContainer.Lookup.Target);
+            LayoutInfos.Remove(targetContainer.Lookup.Lookup);
         }
 
         /// <summary>
         /// Update serialised information for the provided target.
         /// </summary>
         /// <param name="targetContainer">The target container to serialise to this skin.</param>
-        public void UpdateDrawableTarget(SkinComponentsContainer targetContainer)
+        public void UpdateDrawableTarget(SkinnableContainer targetContainer)
         {
-            if (!LayoutInfos.TryGetValue(targetContainer.Lookup.Target, out var layoutInfo))
-                layoutInfos[targetContainer.Lookup.Target] = layoutInfo = new SkinLayoutInfo();
+            if (!LayoutInfos.TryGetValue(targetContainer.Lookup.Lookup, out var layoutInfo))
+                layoutInfos[targetContainer.Lookup.Lookup] = layoutInfo = new SkinLayoutInfo();
 
             layoutInfo.Update(targetContainer.Lookup.Ruleset, ((ISerialisableDrawableContainer)targetContainer).CreateSerialisedInfo().ToArray());
         }
@@ -187,18 +188,23 @@ public void UpdateDrawableTarget(SkinComponentsContainer targetContainer)
                 case SkinnableSprite.SpriteComponentLookup sprite:
                     return this.GetAnimation(sprite.LookupName, false, false, maxSize: sprite.MaxSize);
 
-                case SkinComponentsContainerLookup containerLookup:
-
-                    // It is important to return null if the user has not configured this yet.
-                    // This allows skin transformers the opportunity to provide default components.
-                    if (!LayoutInfos.TryGetValue(containerLookup.Target, out var layoutInfo)) return null;
-                    if (!layoutInfo.TryGetDrawableInfo(containerLookup.Ruleset, out var drawableInfos)) return null;
-
-                    return new UserConfiguredLayoutContainer
+                case UserSkinComponentLookup userLookup:
+                    switch (userLookup.Component)
                     {
-                        RelativeSizeAxes = Axes.Both,
-                        ChildrenEnumerable = drawableInfos.Select(i => i.CreateInstance())
-                    };
+                        case GlobalSkinnableContainerLookup containerLookup:
+                            // It is important to return null if the user has not configured this yet.
+                            // This allows skin transformers the opportunity to provide default components.
+                            if (!LayoutInfos.TryGetValue(containerLookup.Lookup, out var layoutInfo)) return null;
+                            if (!layoutInfo.TryGetDrawableInfo(containerLookup.Ruleset, out var drawableInfos)) return null;
+
+                            return new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                ChildrenEnumerable = drawableInfos.Select(i => i.CreateInstance())
+                            };
+                    }
+
+                    break;
             }
 
             return null;
@@ -206,7 +212,7 @@ public void UpdateDrawableTarget(SkinComponentsContainer targetContainer)
 
         #region Deserialisation & Migration
 
-        private SkinLayoutInfo? parseLayoutInfo(string jsonContent, SkinComponentsContainerLookup.TargetArea target)
+        private SkinLayoutInfo? parseLayoutInfo(string jsonContent, GlobalSkinnableContainers target)
         {
             SkinLayoutInfo? layout = null;
 
@@ -242,10 +248,34 @@ public void UpdateDrawableTarget(SkinComponentsContainer targetContainer)
                 applyMigration(layout, target, i);
 
             layout.Version = SkinLayoutInfo.LATEST_VERSION;
+
+            foreach (var kvp in layout.DrawableInfo.ToArray())
+            {
+                foreach (var di in kvp.Value)
+                {
+                    if (!isValidDrawable(di))
+                        layout.DrawableInfo[kvp.Key] = kvp.Value.Where(i => i.Type != di.Type).ToArray();
+                }
+            }
+
             return layout;
         }
 
-        private void applyMigration(SkinLayoutInfo layout, SkinComponentsContainerLookup.TargetArea target, int version)
+        private bool isValidDrawable(SerialisedDrawableInfo di)
+        {
+            if (!typeof(ISerialisableDrawable).IsAssignableFrom(di.Type))
+                return false;
+
+            foreach (var child in di.Children)
+            {
+                if (!isValidDrawable(child))
+                    return false;
+            }
+
+            return true;
+        }
+
+        private void applyMigration(SkinLayoutInfo layout, GlobalSkinnableContainers target, int version)
         {
             switch (version)
             {
@@ -253,7 +283,7 @@ private void applyMigration(SkinLayoutInfo layout, SkinComponentsContainerLookup
                 {
                     // Combo counters were moved out of the global HUD components into per-ruleset.
                     // This is to allow some rulesets to customise further (ie. mania and catch moving the combo to within their play area).
-                    if (target != SkinComponentsContainerLookup.TargetArea.MainHUDComponents ||
+                    if (target != GlobalSkinnableContainers.MainHUDComponents ||
                         !layout.TryGetDrawableInfo(null, out var globalHUDComponents) ||
                         resources == null)
                         break;
diff --git a/osu.Game/Skinning/SkinComponentLookup.cs b/osu.Game/Skinning/SkinComponentLookup.cs
new file mode 100644
index 000000000000..4da6bb0c087f
--- /dev/null
+++ b/osu.Game/Skinning/SkinComponentLookup.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 System;
+
+namespace osu.Game.Skinning
+{
+    /// <summary>
+    /// A lookup type intended for use for skinnable components.
+    /// </summary>
+    /// <typeparam name="T">An enum lookup type.</typeparam>
+    public class SkinComponentLookup<T> : ISkinComponentLookup
+        where T : Enum
+    {
+        public readonly T Component;
+
+        public SkinComponentLookup(T component)
+        {
+            Component = component;
+        }
+    }
+}
diff --git a/osu.Game/Skinning/SkinLayoutInfo.cs b/osu.Game/Skinning/SkinLayoutInfo.cs
index 22c876e5ad46..bf6c69362145 100644
--- a/osu.Game/Skinning/SkinLayoutInfo.cs
+++ b/osu.Game/Skinning/SkinLayoutInfo.cs
@@ -11,8 +11,8 @@
 namespace osu.Game.Skinning
 {
     /// <summary>
-    /// A serialisable model describing layout of a <see cref="SkinComponentsContainer"/>.
-    /// May contain multiple configurations for different rulesets, each of which should manifest their own <see cref="SkinComponentsContainer"/> as required.
+    /// A serialisable model describing layout of a <see cref="SkinnableContainer"/>.
+    /// May contain multiple configurations for different rulesets, each of which should manifest their own <see cref="SkinnableContainer"/> as required.
     /// </summary>
     [Serializable]
     public class SkinLayoutInfo
diff --git a/osu.Game/Skinning/SkinManager.cs b/osu.Game/Skinning/SkinManager.cs
index 4f816d88d206..9018c2e2c30f 100644
--- a/osu.Game/Skinning/SkinManager.cs
+++ b/osu.Game/Skinning/SkinManager.cs
@@ -131,9 +131,12 @@ public void SelectRandomSkin()
         {
             Realm.Run(r =>
             {
+                // Required local for iOS. Will cause runtime crash if inlined.
+                Guid currentSkinId = CurrentSkinInfo.Value.ID;
+
                 // choose from only user skins, removing the current selection to ensure a new one is chosen.
                 var randomChoices = r.All<SkinInfo>()
-                                     .Where(s => !s.DeletePending && s.ID != CurrentSkinInfo.Value.ID)
+                                     .Where(s => !s.DeletePending && s.ID != currentSkinId)
                                      .ToArray();
 
                 if (randomChoices.Length == 0)
diff --git a/osu.Game/Skinning/SkinComponentsContainer.cs b/osu.Game/Skinning/SkinnableContainer.cs
similarity index 89%
rename from osu.Game/Skinning/SkinComponentsContainer.cs
rename to osu.Game/Skinning/SkinnableContainer.cs
index 02ba43fd39cc..aad95ca779c2 100644
--- a/osu.Game/Skinning/SkinComponentsContainer.cs
+++ b/osu.Game/Skinning/SkinnableContainer.cs
@@ -16,17 +16,17 @@ namespace osu.Game.Skinning
     /// </summary>
     /// <remarks>
     /// This is currently used as a means of serialising skin layouts to files.
-    /// Currently, one json file in a skin will represent one <see cref="SkinComponentsContainer"/>, containing
+    /// Currently, one json file in a skin will represent one <see cref="SkinnableContainer"/>, containing
     /// the output of <see cref="ISerialisableDrawableContainer.CreateSerialisedInfo"/>.
     /// </remarks>
-    public partial class SkinComponentsContainer : SkinReloadableDrawable, ISerialisableDrawableContainer
+    public partial class SkinnableContainer : SkinReloadableDrawable, ISerialisableDrawableContainer
     {
         private Container? content;
 
         /// <summary>
         /// The lookup criteria which will be used to retrieve components from the active skin.
         /// </summary>
-        public SkinComponentsContainerLookup Lookup { get; }
+        public GlobalSkinnableContainerLookup Lookup { get; }
 
         public IBindableList<ISerialisableDrawable> Components => components;
 
@@ -38,12 +38,15 @@ public partial class SkinComponentsContainer : SkinReloadableDrawable, ISerialis
 
         private CancellationTokenSource? cancellationSource;
 
-        public SkinComponentsContainer(SkinComponentsContainerLookup lookup)
+        public SkinnableContainer(GlobalSkinnableContainerLookup lookup)
         {
             Lookup = lookup;
         }
 
-        public void Reload() => Reload(CurrentSkin.GetDrawableComponent(Lookup) as Container);
+        public void Reload() => Reload((
+                CurrentSkin.GetDrawableComponent(new UserSkinComponentLookup(Lookup))
+                ?? CurrentSkin.GetDrawableComponent(Lookup))
+            as Container);
 
         public void Reload(Container? componentsContainer)
         {
diff --git a/osu.Game/Skinning/TrianglesSkin.cs b/osu.Game/Skinning/TrianglesSkin.cs
index 7971aee794b3..d562fd325675 100644
--- a/osu.Game/Skinning/TrianglesSkin.cs
+++ b/osu.Game/Skinning/TrianglesSkin.cs
@@ -66,17 +66,14 @@ public TrianglesSkin(SkinInfo skin, IStorageResourceProvider resources)
 
             switch (lookup)
             {
-                case SkinComponentsContainerLookup containerLookup:
-                    if (base.GetDrawableComponent(lookup) is UserConfiguredLayoutContainer c)
-                        return c;
-
+                case GlobalSkinnableContainerLookup containerLookup:
                     // Only handle global level defaults for now.
                     if (containerLookup.Ruleset != null)
                         return null;
 
-                    switch (containerLookup.Target)
+                    switch (containerLookup.Lookup)
                     {
-                        case SkinComponentsContainerLookup.TargetArea.SongSelect:
+                        case GlobalSkinnableContainers.SongSelect:
                             var songSelectComponents = new DefaultSkinComponentsContainer(_ =>
                             {
                                 // do stuff when we need to.
@@ -84,7 +81,7 @@ public TrianglesSkin(SkinInfo skin, IStorageResourceProvider resources)
 
                             return songSelectComponents;
 
-                        case SkinComponentsContainerLookup.TargetArea.MainHUDComponents:
+                        case GlobalSkinnableContainers.MainHUDComponents:
                             var skinnableTargetWrapper = new DefaultSkinComponentsContainer(container =>
                             {
                                 var score = container.OfType<DefaultScoreCounter>().FirstOrDefault();
diff --git a/osu.Game/Skinning/UserConfiguredLayoutContainer.cs b/osu.Game/Skinning/UserConfiguredLayoutContainer.cs
deleted file mode 100644
index 1b5a27b53be4..000000000000
--- a/osu.Game/Skinning/UserConfiguredLayoutContainer.cs
+++ /dev/null
@@ -1,15 +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 osu.Framework.Graphics.Containers;
-
-namespace osu.Game.Skinning
-{
-    /// <summary>
-    /// This signifies that a <see cref="Skin.GetDrawableComponent"/> call resolved a configuration created
-    /// by a user in their skin. Generally this should be given priority over any local defaults or overrides.
-    /// </summary>
-    public partial class UserConfiguredLayoutContainer : Container
-    {
-    }
-}
diff --git a/osu.Game/Skinning/UserSkinComponentLookup.cs b/osu.Game/Skinning/UserSkinComponentLookup.cs
new file mode 100644
index 000000000000..1ecdc96b38c9
--- /dev/null
+++ b/osu.Game/Skinning/UserSkinComponentLookup.cs
@@ -0,0 +1,18 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Skinning
+{
+    /// <summary>
+    /// A lookup class which is only for internal use, and explicitly to get a user-level configuration.
+    /// </summary>
+    internal class UserSkinComponentLookup : ISkinComponentLookup
+    {
+        public readonly ISkinComponentLookup Component;
+
+        public UserSkinComponentLookup(ISkinComponentLookup component)
+        {
+            Component = component;
+        }
+    }
+}
diff --git a/osu.Game/Tests/PollingChatClient.cs b/osu.Game/Tests/PollingChatClient.cs
index eb29b35c1d91..75975c716b34 100644
--- a/osu.Game/Tests/PollingChatClient.cs
+++ b/osu.Game/Tests/PollingChatClient.cs
@@ -48,7 +48,7 @@ protected APIRequest CreateInitialFetchRequest(long? lastMessageId = null)
 
             fetchReq.Success += updates =>
             {
-                if (updates?.Presence != null)
+                if (updates.Presence != null)
                 {
                     foreach (var channel in updates.Presence)
                         handleChannelJoined(channel);
diff --git a/osu.Game/Tests/Visual/LegacySkinPlayerTestScene.cs b/osu.Game/Tests/Visual/LegacySkinPlayerTestScene.cs
index 2e254f5b95c3..0e1776be8e0f 100644
--- a/osu.Game/Tests/Visual/LegacySkinPlayerTestScene.cs
+++ b/osu.Game/Tests/Visual/LegacySkinPlayerTestScene.cs
@@ -45,13 +45,13 @@ public override void TearDownSteps()
 
         private void addResetTargetsStep()
         {
-            AddStep("reset targets", () => this.ChildrenOfType<SkinComponentsContainer>().ForEach(t =>
+            AddStep("reset targets", () => this.ChildrenOfType<SkinnableContainer>().ForEach(t =>
             {
                 LegacySkin.ResetDrawableTarget(t);
                 t.Reload();
             }));
 
-            AddUntilStep("wait for components to load", () => this.ChildrenOfType<SkinComponentsContainer>().All(t => t.ComponentsLoaded));
+            AddUntilStep("wait for components to load", () => this.ChildrenOfType<SkinnableContainer>().All(t => t.ComponentsLoaded));
         }
 
         public partial class SkinProvidingPlayer : TestPlayer
diff --git a/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs b/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs
index 91df38feb9be..cb05180d17c4 100644
--- a/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs
+++ b/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs
@@ -9,6 +9,7 @@
 using System.Linq;
 using Newtonsoft.Json;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
@@ -18,6 +19,7 @@
 using osu.Game.Scoring;
 using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Tests.Beatmaps;
+using osu.Game.Utils;
 
 namespace osu.Game.Tests.Visual.OnlinePlay
 {
@@ -200,7 +202,7 @@ public bool HandleRequest(APIRequest request, APIUser localUser, BeatmapManager
                 {
                     var baseBeatmap = getBeatmapSetRequest.Type == BeatmapSetLookupType.BeatmapId
                         ? beatmapManager.QueryBeatmap(b => b.OnlineID == getBeatmapSetRequest.ID)
-                        : beatmapManager.QueryBeatmap(b => b.BeatmapSet.OnlineID == getBeatmapSetRequest.ID);
+                        : beatmapManager.QueryBeatmapSet(s => s.OnlineID == getBeatmapSetRequest.ID)?.PerformRead(s => s.Beatmaps.First().Detach());
 
                     if (baseBeatmap == null)
                     {
@@ -277,11 +279,18 @@ private Room cloneRoom(Room source)
             var result = JsonConvert.DeserializeObject<Room>(JsonConvert.SerializeObject(source));
             Debug.Assert(result != null);
 
-            // Playlist item IDs aren't serialised.
+            // Playlist item IDs and beatmaps aren't serialised.
             if (source.CurrentPlaylistItem.Value != null)
+            {
+                result.CurrentPlaylistItem.Value = result.CurrentPlaylistItem.Value.With(new Optional<IBeatmapInfo>(source.CurrentPlaylistItem.Value.Beatmap));
                 result.CurrentPlaylistItem.Value.ID = source.CurrentPlaylistItem.Value.ID;
+            }
+
             for (int i = 0; i < source.Playlist.Count; i++)
+            {
+                result.Playlist[i] = result.Playlist[i].With(new Optional<IBeatmapInfo>(source.Playlist[i].Beatmap));
                 result.Playlist[i].ID = source.Playlist[i].ID;
+            }
 
             return result;
         }
diff --git a/osu.Game/Tests/Visual/OsuTestScene.cs b/osu.Game/Tests/Visual/OsuTestScene.cs
index 2b4c64dca844..09cfe5ecad0f 100644
--- a/osu.Game/Tests/Visual/OsuTestScene.cs
+++ b/osu.Game/Tests/Visual/OsuTestScene.cs
@@ -306,7 +306,9 @@ public static APIBeatmapSet CreateAPIBeatmapSet(IBeatmapInfo original)
                         StarRating = original.StarRating,
                         DifficultyName = original.DifficultyName,
                     }
-                }
+                },
+                HasFavourited = false,
+                FavouriteCount = 0,
             };
 
             foreach (var beatmap in result.Beatmaps)
diff --git a/osu.Game/Tests/Visual/PlacementBlueprintTestScene.cs b/osu.Game/Tests/Visual/PlacementBlueprintTestScene.cs
index 0027e0349297..c8d9ef8fc8df 100644
--- a/osu.Game/Tests/Visual/PlacementBlueprintTestScene.cs
+++ b/osu.Game/Tests/Visual/PlacementBlueprintTestScene.cs
@@ -19,7 +19,7 @@ namespace osu.Game.Tests.Visual
     public abstract partial class PlacementBlueprintTestScene : OsuManualInputManagerTestScene, IPlacementHandler
     {
         protected readonly Container HitObjectContainer;
-        protected PlacementBlueprint CurrentBlueprint { get; private set; }
+        protected HitObjectPlacementBlueprint CurrentBlueprint { get; private set; }
 
         protected PlacementBlueprintTestScene()
         {
@@ -87,14 +87,14 @@ protected override void Update()
             CurrentBlueprint.UpdateTimeAndPosition(SnapForBlueprint(CurrentBlueprint));
         }
 
-        protected virtual SnapResult SnapForBlueprint(PlacementBlueprint blueprint) =>
+        protected virtual SnapResult SnapForBlueprint(HitObjectPlacementBlueprint blueprint) =>
             new SnapResult(InputManager.CurrentState.Mouse.Position, null);
 
         public override void Add(Drawable drawable)
         {
             base.Add(drawable);
 
-            if (drawable is PlacementBlueprint blueprint)
+            if (drawable is HitObjectPlacementBlueprint blueprint)
             {
                 blueprint.Show();
                 blueprint.UpdateTimeAndPosition(SnapForBlueprint(blueprint));
@@ -106,6 +106,6 @@ public override void Add(Drawable drawable)
         protected virtual Container CreateHitObjectContainer() => new Container { RelativeSizeAxes = Axes.Both };
 
         protected abstract DrawableHitObject CreateHitObject(HitObject hitObject);
-        protected abstract PlacementBlueprint CreateBlueprint();
+        protected abstract HitObjectPlacementBlueprint CreateBlueprint();
     }
 }
diff --git a/osu.Game/Tests/Visual/Spectator/TestSpectatorClient.cs b/osu.Game/Tests/Visual/Spectator/TestSpectatorClient.cs
index 5aef85fa1391..c27e7f15cac4 100644
--- a/osu.Game/Tests/Visual/Spectator/TestSpectatorClient.cs
+++ b/osu.Game/Tests/Visual/Spectator/TestSpectatorClient.cs
@@ -13,6 +13,8 @@
 using osu.Game.Online.Spectator;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
@@ -99,13 +101,24 @@ public void SendEndPlay(int userId, SpectatedUserState state = SpectatedUserStat
         /// <param name="userId">The user to send frames for.</param>
         /// <param name="count">The total number of frames to send.</param>
         /// <param name="startTime">The time to start gameplay frames from.</param>
-        public void SendFramesFromUser(int userId, int count, double startTime = 0)
+        /// <param name="initialResultCount">Add a number of misses to frame header data for testing purposes.</param>
+        public void SendFramesFromUser(int userId, int count, double startTime = 0, int initialResultCount = 0)
         {
             var frames = new List<LegacyReplayFrame>();
 
             int currentFrameIndex = userNextFrameDictionary[userId];
             int lastFrameIndex = currentFrameIndex + count - 1;
 
+            var scoreProcessor = new ScoreProcessor(rulesetStore.GetRuleset(0)!.CreateInstance());
+
+            for (int i = 0; i < initialResultCount; i++)
+            {
+                scoreProcessor.ApplyResult(new JudgementResult(new HitObject(), new Judgement())
+                {
+                    Type = HitResult.Miss,
+                });
+            }
+
             for (; currentFrameIndex <= lastFrameIndex; currentFrameIndex++)
             {
                 // This is done in the next frame so that currentFrameIndex is updated to the correct value.
@@ -130,7 +143,16 @@ void flush()
                     Combo = currentFrameIndex,
                     TotalScore = (long)(currentFrameIndex * 123478 * RNG.NextDouble(0.99, 1.01)),
                     Accuracy = RNG.NextDouble(0.98, 1),
-                }, new ScoreProcessor(rulesetStore.GetRuleset(0)!.CreateInstance()), frames.ToArray());
+                    Statistics = scoreProcessor.Statistics.ToDictionary(),
+                }, scoreProcessor, frames.ToArray());
+
+                if (initialResultCount > 0)
+                {
+                    foreach (var f in frames)
+                        f.Header = bundle.Header;
+                }
+
+                scoreProcessor.ResetFromReplayFrame(frames.Last());
                 ((ISpectatorClient)this).UserSentFrames(userId, bundle);
 
                 frames.Clear();
diff --git a/osu.Game/Updater/SimpleUpdateManager.cs b/osu.Game/Updater/MobileUpdateNotifier.cs
similarity index 81%
rename from osu.Game/Updater/SimpleUpdateManager.cs
rename to osu.Game/Updater/MobileUpdateNotifier.cs
index 0f9d5b929f96..04b54df3c05d 100644
--- a/osu.Game/Updater/SimpleUpdateManager.cs
+++ b/osu.Game/Updater/MobileUpdateNotifier.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using osu.Framework;
 using osu.Framework.Allocation;
@@ -16,10 +15,10 @@
 namespace osu.Game.Updater
 {
     /// <summary>
-    /// An update manager that shows notifications if a newer release is detected.
+    /// An update manager that shows notifications if a newer release is detected for mobile platforms.
     /// Installation is left up to the user.
     /// </summary>
-    public partial class SimpleUpdateManager : UpdateManager
+    public partial class MobileUpdateNotifier : UpdateManager
     {
         private string version = null!;
 
@@ -80,19 +79,6 @@ private bool tryGetBestUrl(GitHubRelease release, [NotNullWhen(true)] out string
 
             switch (RuntimeInfo.OS)
             {
-                case RuntimeInfo.Platform.Windows:
-                    bestAsset = release.Assets?.Find(f => f.Name.EndsWith(".exe", StringComparison.Ordinal));
-                    break;
-
-                case RuntimeInfo.Platform.macOS:
-                    string arch = RuntimeInformation.OSArchitecture == Architecture.Arm64 ? "Apple.Silicon" : "Intel";
-                    bestAsset = release.Assets?.Find(f => f.Name.EndsWith($".app.{arch}.zip", StringComparison.Ordinal));
-                    break;
-
-                case RuntimeInfo.Platform.Linux:
-                    bestAsset = release.Assets?.Find(f => f.Name.EndsWith(".AppImage", StringComparison.Ordinal));
-                    break;
-
                 case RuntimeInfo.Platform.iOS:
                     if (release.Assets?.Exists(f => f.Name.EndsWith(".ipa", StringComparison.Ordinal)) == true)
                         // iOS releases are available via testflight. this link seems to work well enough for now.
diff --git a/osu.Game/Updater/UpdateManager.cs b/osu.Game/Updater/UpdateManager.cs
index bcb28d8b14e8..c114e3a8d057 100644
--- a/osu.Game/Updater/UpdateManager.cs
+++ b/osu.Game/Updater/UpdateManager.cs
@@ -176,12 +176,6 @@ public void StartDownload()
                 Text = NotificationsStrings.DownloadingUpdate;
             }
 
-            public void StartInstall()
-            {
-                Progress = 0;
-                Text = NotificationsStrings.InstallingUpdate;
-            }
-
             public void FailDownload()
             {
                 State = ProgressNotificationState.Cancelled;
diff --git a/osu.Game/Utils/BindableValueAccessor.cs b/osu.Game/Utils/BindableValueAccessor.cs
new file mode 100644
index 000000000000..a4cd35633977
--- /dev/null
+++ b/osu.Game/Utils/BindableValueAccessor.cs
@@ -0,0 +1,39 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using System.Reflection;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.TypeExtensions;
+
+namespace osu.Game.Utils
+{
+    internal static class BindableValueAccessor
+    {
+        private static readonly MethodInfo get_method = typeof(BindableValueAccessor).GetMethod(nameof(getValue), BindingFlags.Static | BindingFlags.NonPublic)!;
+        private static readonly MethodInfo set_method = typeof(BindableValueAccessor).GetMethod(nameof(setValue), BindingFlags.Static | BindingFlags.NonPublic)!;
+
+        public static object GetValue(IBindable bindable)
+        {
+            Type? bindableWithValueType = bindable.GetType().GetInterfaces().FirstOrDefault(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IBindable<>));
+            if (bindableWithValueType == null)
+                return bindable;
+
+            return get_method.MakeGenericMethod(bindableWithValueType.GenericTypeArguments[0]).Invoke(null, [bindable])!;
+        }
+
+        public static void SetValue(IBindable bindable, object value)
+        {
+            Type? bindableWithValueType = bindable.GetType().EnumerateBaseTypes().SingleOrDefault(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Bindable<>));
+            if (bindableWithValueType == null)
+                return;
+
+            set_method.MakeGenericMethod(bindableWithValueType.GenericTypeArguments[0]).Invoke(null, [bindable, value]);
+        }
+
+        private static object getValue<T>(object bindable) => ((IBindable<T>)bindable).Value!;
+
+        private static object setValue<T>(object bindable, object value) => ((Bindable<T>)bindable).Value = (T)value;
+    }
+}
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index 3738d8a7a101..eac86a9c02a7 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
+using osu.Framework.Utils;
 using osu.Game.Rulesets.Objects.Types;
 using osuTK;
 
@@ -51,6 +52,9 @@ public static Vector2 RotateVector(Vector2 vector, float angle)
         /// Given a flip direction, a surrounding quad for all selected objects, and a position,
         /// will return the flipped position in screen space coordinates.
         /// </summary>
+        /// <param name="direction">The direction to flip towards.</param>
+        /// <param name="quad">The quad surrounding all selected objects. The center of this determines the position of the axis.</param>
+        /// <param name="position">The position to flip.</param>
         public static Vector2 GetFlippedPosition(Direction direction, Quad quad, Vector2 position)
         {
             var centre = quad.Centre;
@@ -69,6 +73,20 @@ public static Vector2 GetFlippedPosition(Direction direction, Quad quad, Vector2
             return position;
         }
 
+        /// <summary>
+        /// Given a flip axis vector, a surrounding quad for all selected objects, and a position,
+        /// will return the flipped position in screen space coordinates.
+        /// </summary>
+        /// <param name="axis">The vector indicating the direction to flip towards. This is perpendicular to the mirroring axis.</param>
+        /// <param name="quad">The quad surrounding all selected objects. The center of this determines the position of the axis.</param>
+        /// <param name="position">The position to flip.</param>
+        public static Vector2 GetFlippedPosition(Vector2 axis, Quad quad, Vector2 position)
+        {
+            var centre = quad.Centre;
+
+            return position - 2 * Vector2.Dot(position - centre, axis) * axis;
+        }
+
         /// <summary>
         /// Given a scale vector, a surrounding quad for all selected objects, and a position,
         /// will return the scaled position in screen space coordinates.
@@ -93,9 +111,9 @@ public static Vector2 GetScaledPosition(Anchor reference, Vector2 scale, Quad se
         /// Given a scale multiplier, an origin, and a position,
         /// will return the scaled position in screen space coordinates.
         /// </summary>
-        public static Vector2 GetScaledPosition(Vector2 scale, Vector2 origin, Vector2 position)
+        public static Vector2 GetScaledPosition(Vector2 scale, Vector2 origin, Vector2 position, float axisRotation = 0)
         {
-            return origin + (position - origin) * scale;
+            return origin + RotateVector(RotateVector(position - origin, axisRotation) * scale, -axisRotation);
         }
 
         /// <summary>
@@ -127,7 +145,67 @@ public static Quad GetSurroundingQuad(IEnumerable<Vector2> points)
         /// </summary>
         /// <param name="hitObjects">The hit objects to calculate a quad for.</param>
         public static Quad GetSurroundingQuad(IEnumerable<IHasPosition> hitObjects) =>
-            GetSurroundingQuad(hitObjects.SelectMany(h =>
+            GetSurroundingQuad(enumerateStartAndEndPositions(hitObjects));
+
+        /// <summary>
+        /// Returns the points that make up the convex hull of the provided points.
+        /// </summary>
+        /// <param name="points">The points to calculate a convex hull.</param>
+        public static List<Vector2> GetConvexHull(IEnumerable<Vector2> points)
+        {
+            var pointsList = points.OrderBy(p => p.X).ThenBy(p => p.Y).ToList();
+
+            if (pointsList.Count < 3)
+                return pointsList;
+
+            var convexHullLower = new List<Vector2>
+            {
+                pointsList[0],
+                pointsList[1]
+            };
+            var convexHullUpper = new List<Vector2>
+            {
+                pointsList[^1],
+                pointsList[^2]
+            };
+
+            // Build the lower hull.
+            for (int i = 2; i < pointsList.Count; i++)
+            {
+                Vector2 c = pointsList[i];
+                while (convexHullLower.Count > 1 && isClockwise(convexHullLower[^2], convexHullLower[^1], c))
+                    convexHullLower.RemoveAt(convexHullLower.Count - 1);
+
+                convexHullLower.Add(c);
+            }
+
+            // Build the upper hull.
+            for (int i = pointsList.Count - 3; i >= 0; i--)
+            {
+                Vector2 c = pointsList[i];
+                while (convexHullUpper.Count > 1 && isClockwise(convexHullUpper[^2], convexHullUpper[^1], c))
+                    convexHullUpper.RemoveAt(convexHullUpper.Count - 1);
+
+                convexHullUpper.Add(c);
+            }
+
+            convexHullLower.RemoveAt(convexHullLower.Count - 1);
+            convexHullUpper.RemoveAt(convexHullUpper.Count - 1);
+
+            convexHullLower.AddRange(convexHullUpper);
+
+            return convexHullLower;
+
+            float crossProduct(Vector2 v1, Vector2 v2) => v1.X * v2.Y - v1.Y * v2.X;
+
+            bool isClockwise(Vector2 a, Vector2 b, Vector2 c) => crossProduct(b - a, c - a) >= 0;
+        }
+
+        public static List<Vector2> GetConvexHull(IEnumerable<IHasPosition> hitObjects) =>
+            GetConvexHull(enumerateStartAndEndPositions(hitObjects));
+
+        private static IEnumerable<Vector2> enumerateStartAndEndPositions(IEnumerable<IHasPosition> hitObjects) =>
+            hitObjects.SelectMany(h =>
             {
                 if (h is IHasPath path)
                 {
@@ -140,6 +218,159 @@ public static Quad GetSurroundingQuad(IEnumerable<IHasPosition> hitObjects) =>
                 }
 
                 return new[] { h.Position };
-            }));
+            });
+
+        #region Welzl helpers
+
+        // Function to check whether a point lies inside or on the boundaries of the circle
+        private static bool isInside((Vector2 Centre, float Radius) c, Vector2 p)
+        {
+            return Precision.AlmostBigger(c.Radius, Vector2.Distance(c.Centre, p));
+        }
+
+        // Function to return a unique circle that intersects three points
+        private static (Vector2, float) circleFrom(Vector2 a, Vector2 b, Vector2 c)
+        {
+            if (Precision.AlmostEquals(0, (b.Y - a.Y) * (c.X - a.X) - (b.X - a.X) * (c.Y - a.Y)))
+                return circleFrom(a, b);
+
+            // See: https://en.wikipedia.org/wiki/Circumcircle#Cartesian_coordinates
+            float d = 2 * (a.X * (b - c).Y + b.X * (c - a).Y + c.X * (a - b).Y);
+            float aSq = a.LengthSquared;
+            float bSq = b.LengthSquared;
+            float cSq = c.LengthSquared;
+
+            var centre = new Vector2(
+                aSq * (b - c).Y + bSq * (c - a).Y + cSq * (a - b).Y,
+                aSq * (c - b).X + bSq * (a - c).X + cSq * (b - a).X) / d;
+
+            return (centre, Vector2.Distance(a, centre));
+        }
+
+        // Function to return the smallest circle that intersects 2 points
+        private static (Vector2, float) circleFrom(Vector2 a, Vector2 b)
+        {
+            var centre = (a + b) / 2.0f;
+            return (centre, Vector2.Distance(a, b) / 2.0f);
+        }
+
+        // Function to check whether a circle encloses the given points
+        private static bool isValidCircle((Vector2, float) c, List<Vector2> points)
+        {
+            // Iterating through all the points to check whether the points lie inside the circle or not
+            foreach (Vector2 p in points)
+            {
+                if (!isInside(c, p)) return false;
+            }
+
+            return true;
+        }
+
+        // Function to return the minimum enclosing circle for N <= 3
+        private static (Vector2, float) minCircleTrivial(List<Vector2> points)
+        {
+            if (points.Count > 3)
+                throw new ArgumentException("Number of points must be at most 3", nameof(points));
+
+            switch (points.Count)
+            {
+                case 0:
+                    return (new Vector2(0, 0), 0);
+
+                case 1:
+                    return (points[0], 0);
+
+                case 2:
+                    return circleFrom(points[0], points[1]);
+            }
+
+            // To check if MEC can be determined by 2 points only
+            for (int i = 0; i < 3; i++)
+            {
+                for (int j = i + 1; j < 3; j++)
+                {
+                    var c = circleFrom(points[i], points[j]);
+
+                    if (isValidCircle(c, points))
+                        return c;
+                }
+            }
+
+            return circleFrom(points[0], points[1], points[2]);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Function to find the minimum enclosing circle for a collection of points.
+        /// </summary>
+        /// <returns>A tuple containing the circle centre and radius.</returns>
+        public static (Vector2, float) MinimumEnclosingCircle(IEnumerable<Vector2> points)
+        {
+            // Using Welzl's algorithm to find the minimum enclosing circle
+            // https://www.geeksforgeeks.org/minimum-enclosing-circle-using-welzls-algorithm/
+            List<Vector2> p = points.ToList();
+
+            var stack = new Stack<(Vector2?, int)>();
+            var r = new List<Vector2>(3);
+            (Vector2, float) d = (Vector2.Zero, 0);
+
+            stack.Push((null, p.Count));
+
+            while (stack.Count > 0)
+            {
+                // `n` represents the number of points in P that are not yet processed.
+                // `point` represents the point that was randomly picked to process.
+                (Vector2? point, int n) = stack.Pop();
+
+                if (!point.HasValue)
+                {
+                    // Base case when all points processed or |R| = 3
+                    if (n == 0 || r.Count == 3)
+                    {
+                        d = minCircleTrivial(r);
+                        continue;
+                    }
+
+                    // Pick a random point randomly
+                    int idx = RNG.Next(n);
+                    point = p[idx];
+
+                    // Put the picked point at the end of P since it's more efficient than
+                    // deleting from the middle of the list
+                    (p[idx], p[n - 1]) = (p[n - 1], p[idx]);
+
+                    // Schedule processing of p after we get the MEC circle d from the set of points P - {p}
+                    stack.Push((point, n));
+                    // Get the MEC circle d from the set of points P - {p}
+                    stack.Push((null, n - 1));
+                }
+                else
+                {
+                    // If d contains p, return d
+                    if (isInside(d, point.Value))
+                        continue;
+
+                    // Remove points from R that were added in a deeper recursion
+                    // |R| = |P| - |stack| - n
+                    int removeCount = r.Count - (p.Count - stack.Count - n);
+                    r.RemoveRange(r.Count - removeCount, removeCount);
+
+                    // Otherwise, must be on the boundary of the MEC
+                    r.Add(point.Value);
+                    // Return the MEC for P - {p} and R U {p}
+                    stack.Push((null, n - 1));
+                }
+            }
+
+            return d;
+        }
+
+        /// <summary>
+        /// Function to find the minimum enclosing circle for a collection of hit objects.
+        /// </summary>
+        /// <returns>A tuple containing the circle centre and radius.</returns>
+        public static (Vector2, float) MinimumEnclosingCircle(IEnumerable<IHasPosition> hitObjects) =>
+            MinimumEnclosingCircle(enumerateStartAndEndPositions(hitObjects));
     }
 }
diff --git a/osu.Game/Utils/Optional.cs b/osu.Game/Utils/Optional.cs
index 301767ba08db..f5749a513f50 100644
--- a/osu.Game/Utils/Optional.cs
+++ b/osu.Game/Utils/Optional.cs
@@ -22,7 +22,7 @@ public readonly ref struct Optional<T>
         /// </remarks>
         public readonly bool HasValue;
 
-        private Optional(T value)
+        public Optional(T value)
         {
             Value = value;
             HasValue = true;
diff --git a/osu.Game/Utils/PeriodTracker.cs b/osu.Game/Utils/PeriodTracker.cs
index ba77702247e2..2c62684ac419 100644
--- a/osu.Game/Utils/PeriodTracker.cs
+++ b/osu.Game/Utils/PeriodTracker.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
 namespace osu.Game.Utils
@@ -24,8 +25,17 @@ public PeriodTracker(IEnumerable<Period> periods)
         /// Whether the provided time is in any of the added periods.
         /// </summary>
         /// <param name="time">The time value to check.</param>
-        public bool IsInAny(double time)
+        public bool IsInAny(double time) => IsInAny(time, out _);
+
+        /// <summary>
+        /// Whether the provided time is in any of the added periods.
+        /// </summary>
+        /// <param name="time">The time value to check.</param>
+        /// <param name="period">The period which matched.</param>
+        public bool IsInAny(double time, [NotNullWhen(true)] out Period? period)
         {
+            period = null;
+
             if (periods.Count == 0)
                 return false;
 
@@ -41,7 +51,15 @@ public bool IsInAny(double time)
             }
 
             var nearest = periods[nearestIndex];
-            return time >= nearest.Start && time <= nearest.End;
+            bool isInAny = time >= nearest.Start && time <= nearest.End;
+
+            if (isInAny)
+            {
+                period = nearest;
+                return true;
+            }
+
+            return false;
         }
     }
 
@@ -57,6 +75,8 @@ public readonly struct Period
         /// </summary>
         public readonly double End;
 
+        public double Duration => End - Start;
+
         public Period(double start, double end)
         {
             if (start >= end)
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index 8633806e3765..f74d18f6e44c 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="11.5.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2024.809.2" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2024.810.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2024.927.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2024.904.0" />
     <PackageReference Include="Sentry" Version="4.3.0" />
     <!-- Held back due to 0.34.0 failing AOT compilation on ZstdSharp.dll dependency. -->
     <PackageReference Include="SharpCompress" Version="0.36.0" />
diff --git a/osu.iOS.props b/osu.iOS.props
index a94b9375c976..8acd1deff136 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="2024.809.2" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2024.927.0" />
   </ItemGroup>
 </Project>
diff --git a/osu.iOS/OsuGameIOS.cs b/osu.iOS/OsuGameIOS.cs
index 502f30215780..2a4f9b87ac6c 100644
--- a/osu.iOS/OsuGameIOS.cs
+++ b/osu.iOS/OsuGameIOS.cs
@@ -15,7 +15,7 @@ public partial class OsuGameIOS : OsuGame
     {
         public override Version AssemblyVersion => new Version(NSBundle.MainBundle.InfoDictionary["CFBundleVersion"].ToString());
 
-        protected override UpdateManager CreateUpdateManager() => new SimpleUpdateManager();
+        protected override UpdateManager CreateUpdateManager() => new MobileUpdateNotifier();
 
         protected override BatteryInfo CreateBatteryInfo() => new IOSBatteryInfo();
 
diff --git a/osu.sln.DotSettings b/osu.sln.DotSettings
index 0c52f8d82a6b..4a2ef97520d3 100644
--- a/osu.sln.DotSettings
+++ b/osu.sln.DotSettings
@@ -845,6 +845,7 @@ See the LICENCE file in the repository root for full licence text.&#xD;
 	<s:Boolean x:Key="/Default/Environment/AutoImport2/=CSHARP/BlackLists/=System_002ENumerics_002E_002A/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/AutoImport2/=CSHARP/BlackLists/=System_002ESecurity_002ECryptography_002ERSA/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/AutoImport2/=CSHARP/BlackLists/=TagLib_002EMpeg4_002EBox/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/AutoImport2/=CSHARP/BlackLists/=Vortice_002E_002A/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EFeature_002EServices_002ECodeCleanup_002EFileHeader_002EFileHeaderSettingsMigrate/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EFeature_002EServices_002EDaemon_002ESettings_002EMigration_002ESwaWarningsModeSettingsMigrate/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpAttributeForSingleLineMethodUpgrade/@EntryIndexedValue">True</s:Boolean>
@@ -852,6 +853,7 @@ See the LICENCE file in the repository root for full licence text.&#xD;
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpRenamePlacementToArrangementMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpUseContinuousIndentInsideBracesMigration/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002EMemberReordering_002EMigrations_002ECSharpFileLayoutPatternRemoveIsAttributeUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EAddAccessorOwnerDeclarationBracesMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EAlwaysTreatStructAsNotReorderableMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
@@ -1059,5 +1061,6 @@ private void load()
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Unplayed/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Unproxy/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Unranked/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=velopack/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Welford_0027s/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Zoomable/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>