diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4abd55e3f4..6fbb74dfba 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 c7ce707562..6b42258b49 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.916.0" />
+    <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.Desktop/Updater/VelopackUpdateManager.cs b/osu.Desktop/Updater/VelopackUpdateManager.cs
index ae58a8793c..7a79284533 100644
--- a/osu.Desktop/Updater/VelopackUpdateManager.cs
+++ b/osu.Desktop/Updater/VelopackUpdateManager.cs
@@ -66,7 +66,7 @@ namespace osu.Desktop.Updater
                     {
                         Activated = () =>
                         {
-                            restartToApplyUpdate();
+                            Task.Run(restartToApplyUpdate);
                             return true;
                         }
                     });
@@ -88,7 +88,11 @@ namespace osu.Desktop.Updater
                 {
                     notification = new UpdateProgressNotification
                     {
-                        CompletionClickAction = restartToApplyUpdate,
+                        CompletionClickAction = () =>
+                        {
+                            Task.Run(restartToApplyUpdate);
+                            return true;
+                        },
                     };
 
                     Schedule(() => notificationOverlay.Post(notification));
@@ -127,13 +131,10 @@ namespace osu.Desktop.Updater
             return true;
         }
 
-        private bool restartToApplyUpdate()
+        private async Task restartToApplyUpdate()
         {
-            // TODO: Migrate this to async flow whenever available (see https://github.com/ppy/osu/pull/28743#discussion_r1740505665).
-            // Currently there's an internal Thread.Sleep(300) which will cause a stutter when the user clicks to restart.
-            updateManager.WaitExitThenApplyUpdates(pendingUpdate?.TargetFullRelease);
+            await updateManager.WaitExitThenApplyUpdatesAsync(pendingUpdate?.TargetFullRelease).ConfigureAwait(false);
             Schedule(() => game.AttemptExit());
-            return true;
         }
     }
 }
diff --git a/osu.Desktop/osu.Desktop.csproj b/osu.Desktop/osu.Desktop.csproj
index bf5f26b352..342b28f5ef 100644
--- a/osu.Desktop/osu.Desktop.csproj
+++ b/osu.Desktop/osu.Desktop.csproj
@@ -26,7 +26,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="System.IO.Packaging" Version="8.0.0" />
     <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
-    <PackageReference Include="Velopack" Version="0.0.598-g933b2ab" />
+    <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 0000000000..2ab4d3369a
--- /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 aae759d934..0578010c25 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
@@ -71,7 +71,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             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 ed37ff4ef3..296d34d628 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneBananaShowerPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneBananaShowerPlacementBlueprint.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
     {
         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 75d3c3753a..80cd948e26 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneFruitPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneFruitPlacementBlueprint.cs
@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
     {
         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 d010bb02ad..8bd60078c6 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
@@ -114,7 +114,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
 
         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/Difficulty/CatchDifficultyCalculator.cs b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
index 0899212b6c..7d21409ee8 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;
@@ -44,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                 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/Edit/BananaShowerCompositionTool.cs b/osu.Game.Rulesets.Catch/Edit/BananaShowerCompositionTool.cs
index 31075db7d1..be93ba0242 100644
--- a/osu.Game.Rulesets.Catch/Edit/BananaShowerCompositionTool.cs
+++ b/osu.Game.Rulesets.Catch/Edit/BananaShowerCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Edit.Tools;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public class BananaShowerCompositionTool : HitObjectCompositionTool
+    public class BananaShowerCompositionTool : CompositionTool
     {
         public BananaShowerCompositionTool()
             : base(nameof(BananaShower))
@@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         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 1a2990e4ac..aa862375c5 100644
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/CatchPlacementBlueprint.cs
@@ -9,7 +9,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 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/CatchHitObjectComposer.cs b/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
index 83f48816f9..7323c7a91a 100644
--- a/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs
@@ -84,7 +84,7 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         protected override BeatSnapGrid CreateBeatSnapGrid() => new CatchBeatSnapGrid();
 
-        protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
+        protected override IReadOnlyList<CompositionTool> CompositionTools => new CompositionTool[]
         {
             new FruitCompositionTool(),
             new JuiceStreamCompositionTool(),
diff --git a/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs b/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs
index f776fe39c1..71c1e66903 100644
--- a/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs
+++ b/osu.Game.Rulesets.Catch/Edit/FruitCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Edit.Tools;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public class FruitCompositionTool : HitObjectCompositionTool
+    public class FruitCompositionTool : CompositionTool
     {
         public FruitCompositionTool()
             : base(nameof(Fruit))
@@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         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 cb66e2952e..7a567820f3 100644
--- a/osu.Game.Rulesets.Catch/Edit/JuiceStreamCompositionTool.cs
+++ b/osu.Game.Rulesets.Catch/Edit/JuiceStreamCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Edit.Tools;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
-    public class JuiceStreamCompositionTool : HitObjectCompositionTool
+    public class JuiceStreamCompositionTool : CompositionTool
     {
         public JuiceStreamCompositionTool()
             : base(nameof(JuiceStream))
@@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Catch.Edit
 
         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.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs b/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
index d2a44122aa..5e633c3161 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             });
         }
 
-        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 b79bcb7682..2006879ab3 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 b48f579ec0..4285ef2029 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs
@@ -6,6 +6,7 @@ using NUnit.Framework;
 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 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             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 a446f13cbf..0cb9639cd1 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs
@@ -64,6 +64,6 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
         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/Edit/Blueprints/ManiaPlacementBlueprint.cs b/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs
index 5e0512b5dc..a68bd5d6d6 100644
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs
@@ -15,7 +15,7 @@ using osuTK.Input;
 
 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 99e1ce04b1..592f8d9af7 100644
--- a/osu.Game.Rulesets.Mania/Edit/HoldNoteCompositionTool.cs
+++ b/osu.Game.Rulesets.Mania/Edit/HoldNoteCompositionTool.cs
@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Mania.Edit.Blueprints;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public class HoldNoteCompositionTool : HitObjectCompositionTool
+    public class HoldNoteCompositionTool : CompositionTool
     {
         public HoldNoteCompositionTool()
             : base("Hold")
@@ -18,6 +18,6 @@ namespace osu.Game.Rulesets.Mania.Edit
 
         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 02a4f3a022..e3b4fa2fb7 100644
--- a/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Mania.Edit
 
         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 9ae2112b30..7e0991a4d4 100644
--- a/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
@@ -104,8 +104,10 @@ namespace osu.Game.Rulesets.Mania.Edit
             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 @@ namespace osu.Game.Rulesets.Mania.Edit
                 ((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 08ee05ad3f..2e54d63525 100644
--- a/osu.Game.Rulesets.Mania/Edit/NoteCompositionTool.cs
+++ b/osu.Game.Rulesets.Mania/Edit/NoteCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Mania.Objects;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
-    public class NoteCompositionTool : HitObjectCompositionTool
+    public class NoteCompositionTool : CompositionTool
     {
         public NoteCompositionTool()
             : base(nameof(Note))
@@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Mania.Edit
 
         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.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs
index a49afd82f3..a105d860bf 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/TestScenePreciseRotation.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
index 30e0dbbf2e..d14bd1fc87 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
@@ -116,7 +116,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 () => 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/TestSceneSliderPlacementBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
index aa6a6f08d8..019565ae29 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
@@ -514,6 +514,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         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/TestSceneSpinnerPlacementBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
index 0e8673319e..d7b5cc73be 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
@@ -15,6 +15,6 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
     {
         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/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index e93475ecff..c4fcd1f760 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -81,7 +81,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             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 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 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/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs
index 20ad99baa2..78a0e36dc2 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 @@ using osuTK.Input;
 
 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/SliderPlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
index 42945295b8..6ffe27dc13 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
@@ -21,7 +21,7 @@ using osuTK.Input;
 
 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;
 
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs
index f59be0e0e9..17d2dcd75c 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 @@ using osuTK.Input;
 
 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 c41ae10b2e..d3116ede30 100644
--- a/osu.Game.Rulesets.Osu/Edit/HitCircleCompositionTool.cs
+++ b/osu.Game.Rulesets.Osu/Edit/HitCircleCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
-    public class HitCircleCompositionTool : HitObjectCompositionTool
+    public class HitCircleCompositionTool : CompositionTool
     {
         public HitCircleCompositionTool()
             : base(nameof(HitCircle))
@@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         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 4476160f81..4368a338b2 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         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(),
@@ -106,6 +106,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                     {
                         RotationHandler = BlueprintContainer.SelectionHandler.RotationHandler,
                         ScaleHandler = (OsuSelectionScaleHandler)BlueprintContainer.SelectionHandler.ScaleHandler,
+                        GridToolbox = OsuGridToolboxGroup,
                     },
                     new GenerateToolboxGroup(),
                     FreehandSliderToolboxGroup
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index 2ca7664d5d..bac0a5e273 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 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
             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 @@ namespace osu.Game.Rulesets.Osu.Edit
                     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 62a39d3702..44d1543ae4 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs
@@ -47,7 +47,6 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private OsuHitObject[]? objectsInRotation;
 
-        private Vector2? defaultOrigin;
         private Dictionary<OsuHitObject, Vector2>? originalPositions;
         private Dictionary<IHasPath, Vector2[]>? originalPathControlPointPositions;
 
@@ -61,7 +60,7 @@ namespace osu.Game.Rulesets.Osu.Edit
             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 @@ namespace osu.Game.Rulesets.Osu.Edit
             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 @@ namespace osu.Game.Rulesets.Osu.Edit
             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 f4fd48f183..fc85865dd2 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -69,6 +69,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private Dictionary<OsuHitObject, OriginalHitObjectState>? objectsInScale;
         private Vector2? defaultOrigin;
+        private List<Vector2>? originalConvexHull;
 
         public override void Begin()
         {
@@ -83,10 +84,13 @@ namespace osu.Game.Rulesets.Osu.Edit
             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 @@ namespace osu.Game.Rulesets.Osu.Edit
             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 @@ namespace osu.Game.Rulesets.Osu.Edit
         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 @@ namespace osu.Game.Rulesets.Osu.Edit
                 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 @@ namespace osu.Game.Rulesets.Osu.Edit
         /// </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 @@ namespace osu.Game.Rulesets.Osu.Edit
             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;
+            IEnumerable<Vector2> points;
 
-            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 (axisRotation == 0)
+            {
+                var selectionQuad = OriginalSurroundingQuad.Value;
+                points = new[]
+                {
+                    selectionQuad.TopLeft,
+                    selectionQuad.TopRight,
+                    selectionQuad.BottomLeft,
+                    selectionQuad.BottomRight
+                };
+            }
+            else
+                points = originalConvexHull!;
 
-            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);
+            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 3a0d3c4763..352debf500 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 @@ namespace osu.Game.Rulesets.Osu.Edit
     {
         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 @@ namespace osu.Game.Rulesets.Osu.Edit
                         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 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             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 @@ namespace osu.Game.Rulesets.Osu.Edit
 
     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 a299eebbce..33b0c14185 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.Containers;
 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 @@ namespace osu.Game.Rulesets.Osu.Edit
     {
         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 @@ namespace osu.Game.Rulesets.Osu.Edit
                         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 @@ namespace osu.Game.Rulesets.Osu.Edit
                     },
                 }
             };
+            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 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             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 @@ namespace osu.Game.Rulesets.Osu.Edit
                 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 @@ namespace osu.Game.Rulesets.Osu.Edit
             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 @@ namespace osu.Game.Rulesets.Osu.Edit
 
     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 617cc1c19b..d697a2ebe6 100644
--- a/osu.Game.Rulesets.Osu/Edit/SliderCompositionTool.cs
+++ b/osu.Game.Rulesets.Osu/Edit/SliderCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
-    public class SliderCompositionTool : HitObjectCompositionTool
+    public class SliderCompositionTool : CompositionTool
     {
         public SliderCompositionTool()
             : base(nameof(Slider))
@@ -26,6 +26,6 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         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 c8160617c9..de1506e4a9 100644
--- a/osu.Game.Rulesets.Osu/Edit/SpinnerCompositionTool.cs
+++ b/osu.Game.Rulesets.Osu/Edit/SpinnerCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
-    public class SpinnerCompositionTool : HitObjectCompositionTool
+    public class SpinnerCompositionTool : CompositionTool
     {
         public SpinnerCompositionTool()
             : base(nameof(Spinner))
@@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         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 a3547d45e5..a41412cbe3 100644
--- a/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
@@ -27,6 +27,8 @@ namespace osu.Game.Rulesets.Osu.Edit
         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 @@ namespace osu.Game.Rulesets.Osu.Edit
                 {
                     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 5f5deca1ba..b3a68ec92d 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
@@ -91,20 +91,35 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     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);
             }
-
-            void applyDimToDrawableHitObject(DrawableHitObject dho, ArmedState _) => applyDim(dho);
         }
 
+        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;
+        }
+
+        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.Taiko.Tests/VolumeAwareHitSampleInfoTest.cs b/osu.Game.Rulesets.Taiko.Tests/VolumeAwareHitSampleInfoTest.cs
new file mode 100644
index 0000000000..2b3a922067
--- /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 28323693d0..e3c550fbe9 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
@@ -14,7 +14,6 @@ using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
 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
@@ -100,7 +99,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 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 329fff5b42..7f45123bd6 100644
--- a/osu.Game.Rulesets.Taiko/Edit/Blueprints/HitPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/Blueprints/HitPlacementBlueprint.cs
@@ -10,7 +10,7 @@ using osuTK.Input;
 
 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 cd52398086..de3a4d96eb 100644
--- a/osu.Game.Rulesets.Taiko/Edit/Blueprints/TaikoSpanPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/Blueprints/TaikoSpanPlacementBlueprint.cs
@@ -17,7 +17,7 @@ using osuTK.Input;
 
 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 f332441875..ba0fda6771 100644
--- a/osu.Game.Rulesets.Taiko/Edit/DrumRollCompositionTool.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/DrumRollCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Edit
 {
-    public class DrumRollCompositionTool : HitObjectCompositionTool
+    public class DrumRollCompositionTool : CompositionTool
     {
         public DrumRollCompositionTool()
             : base(nameof(DrumRoll))
@@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Taiko.Edit
 
         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 fa50841893..f58defba83 100644
--- a/osu.Game.Rulesets.Taiko/Edit/HitCompositionTool.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/HitCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Edit
 {
-    public class HitCompositionTool : HitObjectCompositionTool
+    public class HitCompositionTool : CompositionTool
     {
         public HitCompositionTool()
             : base(nameof(Hit))
@@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Taiko.Edit
 
         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 4d4ee8effe..4ec623e29e 100644
--- a/osu.Game.Rulesets.Taiko/Edit/SwellCompositionTool.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/SwellCompositionTool.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Edit
 {
-    public class SwellCompositionTool : HitObjectCompositionTool
+    public class SwellCompositionTool : CompositionTool
     {
         public SwellCompositionTool()
             : base(nameof(Swell))
@@ -19,6 +19,6 @@ namespace osu.Game.Rulesets.Taiko.Edit
 
         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 6020f6e04c..d97a854ff7 100644
--- a/osu.Game.Rulesets.Taiko/Edit/TaikoHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/TaikoHitObjectComposer.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Taiko.Edit
         {
         }
 
-        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/VolumeAwareHitSampleInfo.cs b/osu.Game.Rulesets.Taiko/Skinning/Argon/VolumeAwareHitSampleInfo.cs
index 3ca4b5a3c7..288ffde052 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 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Argon
                     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.Tests/Utils/BindableValueAccessorTest.cs b/osu.Game.Tests/Utils/BindableValueAccessorTest.cs
new file mode 100644
index 0000000000..f09623dbfc
--- /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 0000000000..f73175bb5b
--- /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/Editing/TestSceneComposeSelectBox.cs b/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
index 28763051e3..2bf07d8e27 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
@@ -84,6 +84,7 @@ namespace osu.Game.Tests.Visual.Editing
 
                 targetContainer = getTargetContainer();
                 initialRotation = targetContainer!.Rotation;
+                DefaultOrigin = ToLocalSpace(targetContainer.ToScreenSpace(Vector2.Zero));
 
                 base.Begin();
             }
@@ -134,7 +135,7 @@ namespace osu.Game.Tests.Visual.Editing
                 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/Gameplay/TestSceneSpectator.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSpectator.cs
index 0de2b6a980..d8817e563c 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSpectator.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSpectator.cs
@@ -19,6 +19,7 @@ using osu.Game.Rulesets.UI;
 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 @@ namespace osu.Game.Tests.Visual.Gameplay
         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 @@ namespace osu.Game.Tests.Visual.Gameplay
         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/Ranking/TestSceneStatisticsPanel.cs b/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
index acfa519c81..f46f76cbb8 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.Screens.Ranking.Statistics;
 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 @@ namespace osu.Game.Tests.Visual.Ranking
             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 3ef0ffc13a..03ecd4af61 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 c70277987e..cf8a589152 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 309438e51c..9544f77940 100644
--- a/osu.Game.Tests/Visual/Settings/TestSceneSettingsSource.cs
+++ b/osu.Game.Tests/Visual/Settings/TestSceneSettingsSource.cs
@@ -5,6 +5,7 @@ using NUnit.Framework;
 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 @@ namespace osu.Game.Tests.Visual.Settings
         {
             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 @@ namespace osu.Game.Tests.Visual.Settings
 
             [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/UserInterface/TestSceneFormControls.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneFormControls.cs
index eb8a8b3fe9..2a0b0515a1 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneFormControls.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneFormControls.cs
@@ -1,9 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.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;
@@ -68,6 +70,41 @@ namespace osu.Game.Tests.Visual.UserInterface
                             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/TestSceneSettingsColour.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneSettingsColour.cs
new file mode 100644
index 0000000000..8d28116950
--- /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.Tournament/Screens/Setup/StablePathSelectScreen.cs b/osu.Game.Tournament/Screens/Setup/StablePathSelectScreen.cs
index 74404e06f8..91b03ed085 100644
--- a/osu.Game.Tournament/Screens/Setup/StablePathSelectScreen.cs
+++ b/osu.Game.Tournament/Screens/Setup/StablePathSelectScreen.cs
@@ -27,6 +27,9 @@ namespace osu.Game.Tournament.Screens.Setup
         [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 f9c93d72ff..ce5e217532 100644
--- a/osu.Game/Audio/HitSampleInfo.cs
+++ b/osu.Game/Audio/HitSampleInfo.cs
@@ -96,7 +96,7 @@ namespace osu.Game.Audio
         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 8acaebd1a8..94144e4695 100644
--- a/osu.Game/Beatmaps/BeatmapImporter.cs
+++ b/osu.Game/Beatmaps/BeatmapImporter.cs
@@ -198,8 +198,11 @@ namespace osu.Game.Beatmaps
 
             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/Configuration/SettingSourceAttribute.cs b/osu.Game/Configuration/SettingSourceAttribute.cs
index 1e425c88a6..30cda4047e 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.Graphics;
 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 @@ namespace osu.Game.Configuration
 
                         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 @@ namespace osu.Game.Configuration
                 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/Graphics/UserInterface/OsuSliderBar.cs b/osu.Game/Graphics/UserInterface/OsuSliderBar.cs
index 9cb6356cab..334fe343ae 100644
--- a/osu.Game/Graphics/UserInterface/OsuSliderBar.cs
+++ b/osu.Game/Graphics/UserInterface/OsuSliderBar.cs
@@ -46,7 +46,7 @@ namespace osu.Game.Graphics.UserInterface
         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 @@ namespace osu.Game.Graphics.UserInterface
 
             playSample(value);
 
-            TooltipText = getTooltipText(value);
+            TooltipText = GetDisplayableValue(value);
         }
 
         private void playSample(T value)
@@ -83,7 +83,7 @@ namespace osu.Game.Graphics.UserInterface
             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 0000000000..cd3199c6f5
--- /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 7665ed507f..07d84a0095 100644
--- a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelectorHiddenToggle.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/FileSelection/HiddenFilesToggleCheckbox.cs
@@ -8,20 +8,23 @@ using osu.Game.Overlays;
 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 0000000000..aeeda82bfb
--- /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 0000000000..0da4e1929f
--- /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 c0ac9f21ca..e5e1e0b7f3 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 @@ namespace osu.Game.Graphics.UserInterfaceV2
             : 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
index 797ff09800..d4cd86010f 100644
--- a/osu.Game/Graphics/UserInterfaceV2/FormCheckBox.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/FormCheckBox.cs
@@ -29,7 +29,14 @@ namespace osu.Game.Graphics.UserInterfaceV2
 
         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!;
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormDropdown.cs b/osu.Game/Graphics/UserInterfaceV2/FormDropdown.cs
new file mode 100644
index 0000000000..d47b9ac73d
--- /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/FormFileSelector.cs b/osu.Game/Graphics/UserInterfaceV2/FormFileSelector.cs
new file mode 100644
index 0000000000..55cc026d7c
--- /dev/null
+++ b/osu.Game/Graphics/UserInterfaceV2/FormFileSelector.cs
@@ -0,0 +1,277 @@
+// 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),
+                    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/FormSliderBar.cs b/osu.Game/Graphics/UserInterfaceV2/FormSliderBar.cs
new file mode 100644
index 0000000000..ac3730598f
--- /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
index 044576c635..9bbb5cba99 100644
--- a/osu.Game/Graphics/UserInterfaceV2/FormTextBox.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/FormTextBox.cs
@@ -59,8 +59,19 @@ namespace osu.Game.Graphics.UserInterfaceV2
 
         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!;
@@ -122,7 +133,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
 
                                 if (!current.Disabled && !ReadOnly)
                                 {
-                                    flashLayer.Colour = ColourInfo.GradientVertical(colourProvider.Dark1.Opacity(0), colourProvider.Dark2);
+                                    flashLayer.Colour = ColourInfo.GradientVertical(colourProvider.Dark2.Opacity(0), colourProvider.Dark2);
                                     flashLayer.FadeOutFromOne(800, Easing.OutQuint);
                                 }
                             };
diff --git a/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelector.cs b/osu.Game/Graphics/UserInterfaceV2/OsuDirectorySelector.cs
index 21f926ba42..65ffdcaa5b 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;
 
-        public OsuDirectorySelector(string initialPath = null)
+        private Box hiddenToggleBackground = 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 0917b9db97..0000000000
--- 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 932017b03e..0000000000
--- 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 7097102335..c7b559d9ed 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 @@ namespace osu.Game.Graphics.UserInterfaceV2
             }
 
             [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 @@ namespace osu.Game.Graphics.UserInterfaceV2
                 }
             }
 
-            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/Localisation/SkinComponents/SkinnableComponentStrings.cs b/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs
index d5c8d5ccec..33fda23cb0 100644
--- a/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs
+++ b/osu.Game/Localisation/SkinComponents/SkinnableComponentStrings.cs
@@ -59,6 +59,26 @@ namespace osu.Game.Localisation.SkinComponents
         /// </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/Online/BeatmapDownloadTracker.cs b/osu.Game/Online/BeatmapDownloadTracker.cs
index 3db602c353..6a2163c3a2 100644
--- a/osu.Game/Online/BeatmapDownloadTracker.cs
+++ b/osu.Game/Online/BeatmapDownloadTracker.cs
@@ -40,7 +40,10 @@ namespace osu.Game.Online
             // 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/ScoreDownloadTracker.cs b/osu.Game/Online/ScoreDownloadTracker.cs
index dfdac24d19..5f6ba15d05 100644
--- a/osu.Game/Online/ScoreDownloadTracker.cs
+++ b/osu.Game/Online/ScoreDownloadTracker.cs
@@ -46,10 +46,15 @@ namespace osu.Game.Online
             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 0ef6a94679..44ba78762a 100644
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@@ -445,10 +445,11 @@ namespace osu.Game
                     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:
diff --git a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
index f9e0c6c380..a50043f0f0 100644
--- a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
+++ b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
@@ -242,7 +242,7 @@ namespace osu.Game.Overlays.BeatmapSet
                     title.Clear();
                     artist.Clear();
 
-                    title.AddLink(titleText, LinkAction.SearchBeatmapSet, $@"title=""""{titleText}""""");
+                    title.AddLink(titleText, LinkAction.SearchBeatmapSet, LocalisableString.Interpolate($@"title=""""{titleText}"""""));
 
                     title.AddArbitraryDrawable(Empty().With(d => d.Width = 5));
                     title.AddArbitraryDrawable(externalLink = new ExternalLinkButton());
@@ -259,7 +259,7 @@ namespace osu.Game.Overlays.BeatmapSet
                         title.AddArbitraryDrawable(new SpotlightBeatmapBadge());
                     }
 
-                    artist.AddLink(artistText, LinkAction.SearchBeatmapSet, $@"artist=""""{artistText}""""");
+                    artist.AddLink(artistText, LinkAction.SearchBeatmapSet, LocalisableString.Interpolate($@"artist=""""{artistText}"""""));
 
                     if (setInfo.NewValue.TrackId != null)
                     {
diff --git a/osu.Game/Overlays/FirstRunSetup/ScreenImportFromStable.cs b/osu.Game/Overlays/FirstRunSetup/ScreenImportFromStable.cs
index 983cb0bbb4..5eb38b6e11 100644
--- a/osu.Game/Overlays/FirstRunSetup/ScreenImportFromStable.cs
+++ b/osu.Game/Overlays/FirstRunSetup/ScreenImportFromStable.cs
@@ -314,6 +314,7 @@ namespace osu.Game.Overlays.FirstRunSetup
             private partial class DirectoryChooserPopover : OsuPopover
             {
                 public DirectoryChooserPopover(Bindable<DirectoryInfo?> currentDirectory)
+                    : base(false)
                 {
                     Child = new Container
                     {
@@ -325,6 +326,13 @@ namespace osu.Game.Overlays.FirstRunSetup
                         },
                     };
                 }
+
+                [BackgroundDependencyLoader]
+                private void load(OverlayColourProvider colourProvider)
+                {
+                    Body.BorderColour = colourProvider.Highlight1;
+                    Body.BorderThickness = 2;
+                }
             }
         }
     }
diff --git a/osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs b/osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs
index e87ca32bf6..f6f8d3b336 100644
--- a/osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs
+++ b/osu.Game/Overlays/Settings/Sections/Maintenance/DirectorySelectScreen.cs
@@ -48,8 +48,11 @@ namespace osu.Game.Overlays.Settings.Sections.Maintenance
         /// </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 @@ namespace osu.Game.Overlays.Settings.Sections.Maintenance
                     new Box
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Colour = colours.GreySeaFoamDark
+                        Colour = colourProvider.Background4,
                     },
                     new GridContainer
                     {
diff --git a/osu.Game/Overlays/Settings/SettingsColour.cs b/osu.Game/Overlays/Settings/SettingsColour.cs
new file mode 100644
index 0000000000..7a091f1a54
--- /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/SkinEditor.cs b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
index d1e9676de7..6f7781ee9c 100644
--- a/osu.Game/Overlays/SkinEditor/SkinEditor.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
@@ -33,6 +33,7 @@ using osu.Game.Screens.Edit;
 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
 {
@@ -118,107 +119,111 @@ namespace osu.Game.Overlays.SkinEditor
             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)
-                                            {
-                                                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[]
-                                                {
-                                                    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
-                            {
-                                RelativeSizeAxes = Axes.X,
-                            },
-                        },
-                        new Drawable[]
-                        {
-                            new GridContainer
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                ColumnDimensions = new[]
-                                {
-                                    new Dimension(GridSizeMode.AutoSize),
-                                    new Dimension(),
-                                    new Dimension(GridSizeMode.AutoSize),
-                                },
-                                Content = new[]
-                                {
-                                    new Drawable[]
-                                    {
-                                        componentsSidebar = new EditorSidebar(),
-                                        content = new Container
-                                        {
-                                            Depth = float.MaxValue,
+                                            Anchor = Anchor.CentreLeft,
+                                            Origin = Anchor.CentreLeft,
                                             RelativeSizeAxes = Axes.Both,
+                                            Items = new[]
+                                            {
+                                                new MenuItem(CommonStrings.MenuBarFile)
+                                                {
+                                                    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[]
+                                                    {
+                                                        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),
+                                                    }
+                                                },
+                                            }
                                         },
-                                        settingsSidebar = new EditorSidebar(),
+                                        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
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                },
+                            },
+                            new Drawable[]
+                            {
+                                new GridContainer
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    ColumnDimensions = new[]
+                                    {
+                                        new Dimension(GridSizeMode.AutoSize),
+                                        new Dimension(),
+                                        new Dimension(GridSizeMode.AutoSize),
+                                    },
+                                    Content = new[]
+                                    {
+                                        new Drawable[]
+                                        {
+                                            componentsSidebar = new EditorSidebar(),
+                                            content = new Container
+                                            {
+                                                Depth = float.MaxValue,
+                                                RelativeSizeAxes = Axes.Both,
+                                            },
+                                            settingsSidebar = new EditorSidebar(),
+                                        }
                                     }
                                 }
-                            }
-                        },
+                            },
+                        }
                     }
                 }
             };
diff --git a/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs b/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
index 36b38543d1..9fd28a1cad 100644
--- a/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
@@ -46,7 +46,6 @@ namespace osu.Game.Overlays.SkinEditor
 
         private Drawable[]? objectsInRotation;
 
-        private Vector2? defaultOrigin;
         private Dictionary<Drawable, float>? originalRotations;
         private Dictionary<Drawable, Vector2>? originalPositions;
 
@@ -60,7 +59,7 @@ namespace osu.Game.Overlays.SkinEditor
             objectsInRotation = selectedItems.Cast<Drawable>().ToArray();
             originalRotations = objectsInRotation.ToDictionary(d => d, d => d.Rotation);
             originalPositions = objectsInRotation.ToDictionary(d => d, d => d.ToScreenSpace(d.OriginPosition));
-            defaultOrigin = GeometryUtils.GetSurroundingQuad(objectsInRotation.SelectMany(d => d.ScreenSpaceDrawQuad.GetVertices().ToArray())).Centre;
+            DefaultOrigin = GeometryUtils.GetSurroundingQuad(objectsInRotation.SelectMany(d => d.ScreenSpaceDrawQuad.GetVertices().ToArray())).Centre;
 
             base.Begin();
         }
@@ -70,7 +69,7 @@ namespace osu.Game.Overlays.SkinEditor
             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 @@ namespace osu.Game.Overlays.SkinEditor
                 return;
             }
 
-            var actualOrigin = origin ?? defaultOrigin.Value;
+            var actualOrigin = origin ?? DefaultOrigin.Value;
 
             foreach (var drawableItem in objectsInRotation)
             {
@@ -100,7 +99,7 @@ namespace osu.Game.Overlays.SkinEditor
             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 4bfa7fba81..6915769212 100644
--- a/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs
@@ -67,13 +67,13 @@ namespace osu.Game.Overlays.SkinEditor
 
             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/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index c2a7bec9f9..00de46b726 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -323,7 +323,7 @@ namespace osu.Game.Rulesets.Edit
         /// <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.
@@ -466,7 +466,7 @@ namespace osu.Game.Rulesets.Edit
 
         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 ba566ff5c0..641d60dbd3 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 0000000000..74025b4260
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/HitObjectPlacementBlueprint.cs
@@ -0,0 +1,126 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.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>
+        /// 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="HitObjectPlacementBlueprint"/> 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();
+
+            if (AutomaticBankAssignment)
+            {
+                // Create samples based on the sample settings of the previous hit object
+                if (lastHitObject != null)
+                {
+                    for (int i = 0; i < HitObject.Samples.Count; i++)
+                        HitObject.Samples[i] = lastHitObject.CreateHitSampleInfo(HitObject.Samples[i].Name);
+                }
+            }
+            else
+            {
+                var lastHitNormal = lastHitObject?.Samples?.FirstOrDefault(o => o.Name == HitSampleInfo.HIT_NORMAL);
+
+                if (lastHitNormal != null)
+                {
+                    // Only inherit the volume from the previous hit object
+                    for (int i = 0; i < HitObject.Samples.Count; i++)
+                        HitObject.Samples[i] = HitObject.Samples[i].With(newVolume: lastHitNormal.Volume);
+                }
+            }
+
+            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/PlacementBlueprint.cs b/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
index a50a7f4169..d2a54e8e03 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,29 +22,6 @@ namespace osu.Game.Rulesets.Edit
         /// </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>
-        /// 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>
@@ -64,13 +31,8 @@ namespace osu.Game.Rulesets.Edit
         /// </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
@@ -78,30 +40,22 @@ namespace osu.Game.Rulesets.Edit
             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)
             {
@@ -114,10 +68,17 @@ namespace osu.Game.Rulesets.Edit
                     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)
@@ -138,57 +99,6 @@ namespace osu.Game.Rulesets.Edit
         {
         }
 
-        /// <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();
-
-            if (AutomaticBankAssignment)
-            {
-                // Create samples based on the sample settings of the previous hit object
-                if (lastHitObject != null)
-                {
-                    for (int i = 0; i < HitObject.Samples.Count; i++)
-                        HitObject.Samples[i] = lastHitObject.CreateHitSampleInfo(HitObject.Samples[i].Name);
-                }
-            }
-            else
-            {
-                var lastHitNormal = lastHitObject?.Samples?.FirstOrDefault(o => o.Name == HitSampleInfo.HIT_NORMAL);
-
-                if (lastHitNormal != null)
-                {
-                    // Only inherit the volume from the previous hit object
-                    for (int i = 0; i < HitObject.Samples.Count; i++)
-                        HitObject.Samples[i] = HitObject.Samples[i].With(newVolume: lastHitNormal.Volume);
-                }
-            }
-
-            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 ba1dc817bb..f509302daa 100644
--- a/osu.Game/Rulesets/Edit/Tools/HitObjectCompositionTool.cs
+++ b/osu.Game/Rulesets/Edit/Tools/CompositionTool.cs
@@ -6,13 +6,13 @@ using osu.Framework.Localisation;
 
 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 a272e9f480..7f8889bfca 100644
--- a/osu.Game/Rulesets/Edit/Tools/SelectTool.cs
+++ b/osu.Game/Rulesets/Edit/Tools/SelectTool.cs
@@ -9,7 +9,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Edit.Tools
 {
-    public class SelectTool : HitObjectCompositionTool
+    public class SelectTool : CompositionTool
     {
         public SelectTool()
             : base("Select")
@@ -18,6 +18,6 @@ namespace osu.Game.Rulesets.Edit.Tools
 
         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/Mods/Mod.cs b/osu.Game/Rulesets/Mods/Mod.cs
index b9a937b1a2..1b21216235 100644
--- a/osu.Game/Rulesets/Mods/Mod.cs
+++ b/osu.Game/Rulesets/Mods/Mod.cs
@@ -266,8 +266,7 @@ namespace osu.Game.Rulesets.Mods
 
                 // 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/Scoring/ScoreProcessor.cs b/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
index 44ddb8c187..9752918dfb 100644
--- a/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
+++ b/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
@@ -181,6 +181,8 @@ namespace osu.Game.Rulesets.Scoring
             }
         }
 
+        public IReadOnlyDictionary<HitResult, int> Statistics => ScoreResultCounts;
+
         private bool beatmapApplied;
 
         protected readonly Dictionary<HitResult, int> ScoreResultCounts = new Dictionary<HitResult, int>();
diff --git a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
index f1294ccc3c..f0296d45aa 100644
--- a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
@@ -41,6 +41,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         public PlacementBlueprint CurrentPlacement { get; private set; }
 
+        public HitObjectPlacementBlueprint CurrentHitObjectPlacement => CurrentPlacement as HitObjectPlacementBlueprint;
+
         [Resolved(canBeNull: true)]
         private EditorScreenWithTimeline editorScreen { get; set; }
 
@@ -164,13 +166,13 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         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);
@@ -181,9 +183,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         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);
 
@@ -196,19 +198,19 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
                 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.With(newBank: bankName)).ToList();
+                CurrentHitObjectPlacement.HitObject.Samples = CurrentHitObjectPlacement.HitObject.Samples.Select(s => s.With(newBank: bankName)).ToList();
         }
 
         public readonly Bindable<TernaryState> NewCombo = new Bindable<TernaryState> { Description = "New Combo" };
@@ -386,12 +388,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
             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/SelectionBox.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs
index 0cc8a8273f..d685fe74b0 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 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 Action = action
             };
 
+            button.OperationStarted += freezeButtonPosition;
+            button.HoverLost += unfreezeButtonPosition;
+
             button.OperationStarted += operationStarted;
             button.OperationEnded += operationEnded;
+
             buttons.Add(button);
 
             return button;
@@ -357,9 +362,35 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 OperationStarted?.Invoke();
         }
 
-        private void ensureButtonsOnScreen()
+        private Vector2? frozenButtonsPosition;
+
+        private void freezeButtonPosition()
         {
-            buttons.Position = Vector2.Zero;
+            frozenButtonsPosition = buttons.ScreenSpaceDrawQuad.TopLeft;
+        }
+
+        private void unfreezeButtonPosition()
+        {
+            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 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             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 6108d44c81..e355add40b 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxButton.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxButton.cs
@@ -21,6 +21,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         public Action? Action;
 
+        public event Action? HoverLost;
+
         public SelectionBoxButton(IconUsage iconUsage, string tooltip)
         {
             this.iconUsage = iconUsage;
@@ -61,6 +63,13 @@ namespace osu.Game.Screens.Edit.Compose.Components
             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 c62e0e0d41..03d600bfa2 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs
@@ -77,6 +77,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             base.OnDrag(e);
 
+            if (rotationHandler == null || !rotationHandler.OperationInProgress.Value) return;
+
             rawCumulativeRotation += convertDragEventToAngleOfRotation(e);
 
             applyRotation(shouldSnap: e.ShiftPressed);
@@ -113,9 +115,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         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/SelectionRotationHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
index 532daaf7fa..af3b3d6489 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 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </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 c91362219c..177de9df33 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
@@ -52,10 +52,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// 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 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// 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/Setup/LabelledFileChooser.cs b/osu.Game/Screens/Edit/Setup/LabelledFileChooser.cs
index 61f33c4bdc..a113ca5407 100644
--- a/osu.Game/Screens/Edit/Setup/LabelledFileChooser.cs
+++ b/osu.Game/Screens/Edit/Setup/LabelledFileChooser.cs
@@ -18,6 +18,7 @@ using osu.Framework.Localisation;
 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 @@ namespace osu.Game.Screens.Edit.Setup
             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 @@ namespace osu.Game.Screens.Edit.Setup
                     },
                 };
             }
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider)
+            {
+                Body.BorderColour = colourProvider.Highlight1;
+                Body.BorderThickness = 2;
+            }
         }
     }
 }
diff --git a/osu.Game/Screens/Import/FileImportScreen.cs b/osu.Game/Screens/Import/FileImportScreen.cs
index 6b7a269d12..1bdacae87f 100644
--- a/osu.Game/Screens/Import/FileImportScreen.cs
+++ b/osu.Game/Screens/Import/FileImportScreen.cs
@@ -15,6 +15,7 @@ using osu.Framework.Screens;
 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 @@ namespace osu.Game.Screens.Import
         [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 @@ namespace osu.Game.Screens.Import
                 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 @@ namespace osu.Game.Screens.Import
                         {
                             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 57e3998646..d71ee05b27 100644
--- a/osu.Game/Screens/Loader.cs
+++ b/osu.Game/Screens/Loader.cs
@@ -118,13 +118,20 @@ namespace osu.Game.Screens
             {
                 loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE));
                 loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.BLUR));
-
-                loadTargets.Add(manager.Load(@"CursorTrail", FragmentShaderDescriptor.TEXTURE));
-
-                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, "TriangleBorder"));
-                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, "FastCircle"));
-
                 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));
             }
 
             protected virtual bool AllLoaded => loadTargets.All(s => s.IsLoaded);
diff --git a/osu.Game/Screens/Play/DimmableStoryboard.cs b/osu.Game/Screens/Play/DimmableStoryboard.cs
index 40cc0f66ad..84d99ea863 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 @@ namespace osu.Game.Screens.Play
         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 @@ namespace osu.Game.Screens.Play
         {
             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 @@ namespace osu.Game.Screens.Play
             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 ebebfebfb3..92ac863e98 100644
--- a/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonSongProgress.cs
@@ -9,6 +9,7 @@ using osu.Framework.Graphics.Containers;
 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 @@ namespace osu.Game.Screens.Play.HUD
         [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 @@ namespace osu.Game.Screens.Play.HUD
             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 3c2e3e05ea..46a658cd1c 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.Colour;
 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 @@ namespace osu.Game.Screens.Play.HUD
         [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 @@ namespace osu.Game.Screens.Play.HUD
             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 @@ namespace osu.Game.Screens.Play.HUD
             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 6b2bb2b718..4e41901ee3 100644
--- a/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs
+++ b/osu.Game/Screens/Play/HUD/DefaultSongProgress.cs
@@ -10,6 +10,7 @@ using osu.Framework.Utils;
 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 @@ namespace osu.Game.Screens.Play.HUD
         [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 @@ namespace osu.Game.Screens.Play.HUD
             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/JudgementCounter/JudgementCount.cs b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCount.cs
new file mode 100644
index 0000000000..ad70e519a2
--- /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 8134c97bac..c00cb3487b 100644
--- a/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCountController.cs
+++ b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCountController.cs
@@ -6,7 +6,6 @@ using System.Linq;
 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 @@ namespace osu.Game.Screens.Play.HUD.JudgementCounter
         {
             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 @@ namespace osu.Game.Screens.Play.HUD.JudgementCounter
             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 45ed8d749b..d69416f34a 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.Framework.Graphics.Containers;
 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 @@ namespace osu.Game.Screens.Play.HUD.JudgementCounter
         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 25e5464205..bc953435b7 100644
--- a/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounterDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/JudgementCounter/JudgementCounterDisplay.cs
@@ -126,7 +126,7 @@ namespace osu.Game.Screens.Play.HUD.JudgementCounter
             }
         }
 
-        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 06d0f7bc9a..8e4406c2c1 100644
--- a/osu.Game/Screens/Play/HUD/PlayerAvatar.cs
+++ b/osu.Game/Screens/Play/HUD/PlayerAvatar.cs
@@ -39,14 +39,23 @@ namespace osu.Game.Screens.Play.HUD
 
         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 @@ namespace osu.Game.Screens.Play.HUD
         {
             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/SkipOverlay.cs b/osu.Game/Screens/Play/SkipOverlay.cs
index 29b2e5229b..362677ca5c 100644
--- a/osu.Game/Screens/Play/SkipOverlay.cs
+++ b/osu.Game/Screens/Play/SkipOverlay.cs
@@ -9,6 +9,7 @@ using osu.Framework;
 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.Graphics.Sprites;
 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 @@ using osuTK.Graphics;
 
 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 @@ namespace osu.Game.Screens.Play
         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 @@ namespace osu.Game.Screens.Play
         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 @@ namespace osu.Game.Screens.Play
                             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 @@ namespace osu.Game.Screens.Play
         {
         }
 
+        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 95eb2d4376..269bc3bb92 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.Audio;
 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 @@ namespace osu.Game.Screens.Play
         /// </summary>
         private SpectatorGameplayState? immediateSpectatorGameplayState;
 
-        private GetBeatmapSetRequest? onlineBeatmapRequest;
+        private ScheduledDelegate? beatmapFetchCallback;
 
         private APIBeatmapSet? beatmapSet;
 
@@ -210,7 +210,7 @@ namespace osu.Game.Screens.Play
         private void clearDisplay()
         {
             watchButton.Enabled.Value = false;
-            onlineBeatmapRequest?.Cancel();
+            beatmapFetchCallback?.Cancel();
             beatmapPanelContainer.Clear();
             previewTrackManager.StopAnyPlaying(this);
         }
@@ -244,15 +244,17 @@ namespace osu.Game.Screens.Play
         {
             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 aea3bf6d5c..24c5b2c3d4 100644
--- a/osu.Game/Screens/Play/SubmittingPlayer.cs
+++ b/osu.Game/Screens/Play/SubmittingPlayer.cs
@@ -234,9 +234,12 @@ namespace osu.Game.Screens.Play
         {
             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();
             }
diff --git a/osu.Game/Screens/Ranking/Statistics/UserStatisticsPanel.cs b/osu.Game/Screens/Ranking/Statistics/UserStatisticsPanel.cs
index fa3bb1a375..4e9c07ab7b 100644
--- a/osu.Game/Screens/Ranking/Statistics/UserStatisticsPanel.cs
+++ b/osu.Game/Screens/Ranking/Statistics/UserStatisticsPanel.cs
@@ -37,7 +37,7 @@ namespace osu.Game.Screens.Ranking.Statistics
                 {
                     if (update.NewValue?.Score.MatchesOnlineID(achievedScore) == true)
                         DisplayedUserStatisticsUpdate.Value = update.NewValue;
-                });
+                }, true);
             }
         }
 
diff --git a/osu.Game/Skinning/Components/BeatmapAttributeText.cs b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
index c467b2e946..6e1d655cef 100644
--- a/osu.Game/Skinning/Components/BeatmapAttributeText.cs
+++ b/osu.Game/Skinning/Components/BeatmapAttributeText.cs
@@ -123,6 +123,8 @@ namespace osu.Game.Skinning.Components
         }
 
         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 34d389728c..7f052a8523 100644
--- a/osu.Game/Skinning/Components/BoxElement.cs
+++ b/osu.Game/Skinning/Components/BoxElement.cs
@@ -27,6 +27,9 @@ namespace osu.Game.Skinning.Components
             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 @@ namespace osu.Game.Skinning.Components
             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 21bf615bc6..5b6ded0cc5 100644
--- a/osu.Game/Skinning/Components/PlayerName.cs
+++ b/osu.Game/Skinning/Components/PlayerName.cs
@@ -53,5 +53,7 @@ namespace osu.Game.Skinning.Components
         }
 
         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 936f6a529b..6e875c5590 100644
--- a/osu.Game/Skinning/Components/TextElement.cs
+++ b/osu.Game/Skinning/Components/TextElement.cs
@@ -36,5 +36,7 @@ namespace osu.Game.Skinning.Components
         }
 
         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 8f3a1d41c6..0821edf7fc 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 @@ namespace osu.Game.Skinning
         [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 @@ namespace osu.Game.Skinning
                 FontUsage f = OsuFont.GetFont(e.NewValue, weight: fontWeight);
                 SetFont(f);
             }, true);
+
+            TextColour.BindValueChanged(e => SetTextColour(e.NewValue), true);
         }
     }
 }
diff --git a/osu.Game/Skinning/RealmBackedResourceStore.cs b/osu.Game/Skinning/RealmBackedResourceStore.cs
index cce099a268..f41bd89b7a 100644
--- a/osu.Game/Skinning/RealmBackedResourceStore.cs
+++ b/osu.Game/Skinning/RealmBackedResourceStore.cs
@@ -29,7 +29,10 @@ namespace osu.Game.Skinning
             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/SkinManager.cs b/osu.Game/Skinning/SkinManager.cs
index 4f816d88d2..9018c2e2c3 100644
--- a/osu.Game/Skinning/SkinManager.cs
+++ b/osu.Game/Skinning/SkinManager.cs
@@ -131,9 +131,12 @@ namespace osu.Game.Skinning
         {
             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/Tests/Visual/PlacementBlueprintTestScene.cs b/osu.Game/Tests/Visual/PlacementBlueprintTestScene.cs
index 0027e03492..c8d9ef8fc8 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 @@ namespace osu.Game.Tests.Visual
             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 @@ namespace osu.Game.Tests.Visual
         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 5aef85fa13..c27e7f15ca 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.API;
 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 @@ namespace osu.Game.Tests.Visual.Spectator
         /// <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 @@ namespace osu.Game.Tests.Visual.Spectator
                     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/Utils/BindableValueAccessor.cs b/osu.Game/Utils/BindableValueAccessor.cs
new file mode 100644
index 0000000000..a4cd356339
--- /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 3738d8a7a1..eac86a9c02 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -6,6 +6,7 @@ using System.Collections.Generic;
 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 @@ namespace osu.Game.Utils
         /// 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 @@ namespace osu.Game.Utils
             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 @@ namespace osu.Game.Utils
         /// 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 @@ namespace osu.Game.Utils
         /// </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 @@ namespace osu.Game.Utils
                 }
 
                 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/osu.Game.csproj b/osu.Game/osu.Game.csproj
index 16e4360c25..f74d18f6e4 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -35,7 +35,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="11.5.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2024.916.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. -->
diff --git a/osu.iOS.props b/osu.iOS.props
index bb20125282..8acd1deff1 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.916.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2024.927.0" />
   </ItemGroup>
 </Project>