diff --git a/.editorconfig b/.editorconfig
index c249e5e9b3..7aecde95ee 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -196,6 +196,9 @@ csharp_style_prefer_switch_expression = false:none
 
 csharp_style_namespace_declarations = block_scoped:warning
 
+#Style - C# 12 features
+csharp_style_prefer_primary_constructors = false
+
 [*.{yaml,yml}]
 insert_final_newline = true
 indent_style = space
diff --git a/.gitignore b/.gitignore
index 11fee27f28..a51ad09d6c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -265,6 +265,7 @@ __pycache__/
 .idea/**/usage.statistics.xml
 .idea/**/dictionaries
 .idea/**/shelf
+.idea/*/.idea/projectSettingsUpdater.xml
 
 # Generated files
 .idea/**/contentModel.xml
diff --git a/.idea/.idea.osu.Android/.idea/projectSettingsUpdater.xml b/.idea/.idea.osu.Android/.idea/projectSettingsUpdater.xml
deleted file mode 100644
index 4bb9f4d2a0..0000000000
--- a/.idea/.idea.osu.Android/.idea/projectSettingsUpdater.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RiderProjectSettingsUpdater">
-    <option name="vcsConfiguration" value="2" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/.idea/.idea.osu.Desktop/.idea/projectSettingsUpdater.xml b/.idea/.idea.osu.Desktop/.idea/projectSettingsUpdater.xml
deleted file mode 100644
index 4bb9f4d2a0..0000000000
--- a/.idea/.idea.osu.Desktop/.idea/projectSettingsUpdater.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RiderProjectSettingsUpdater">
-    <option name="vcsConfiguration" value="2" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/.idea/.idea.osu.iOS/.idea/projectSettingsUpdater.xml b/.idea/.idea.osu.iOS/.idea/projectSettingsUpdater.xml
deleted file mode 100644
index 4bb9f4d2a0..0000000000
--- a/.idea/.idea.osu.iOS/.idea/projectSettingsUpdater.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RiderProjectSettingsUpdater">
-    <option name="vcsConfiguration" value="2" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/.idea/.idea.osu/.idea/projectSettingsUpdater.xml b/.idea/.idea.osu/.idea/projectSettingsUpdater.xml
deleted file mode 100644
index 4bb9f4d2a0..0000000000
--- a/.idea/.idea.osu/.idea/projectSettingsUpdater.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RiderProjectSettingsUpdater">
-    <option name="vcsConfiguration" value="2" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/osu.Android.props b/osu.Android.props
index 3a20dd2fdb..349829555d 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.528.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2024.627.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.
diff --git a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneCatchEditorSaving.cs b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneCatchEditorSaving.cs
new file mode 100644
index 0000000000..53ef24e02c
--- /dev/null
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneCatchEditorSaving.cs
@@ -0,0 +1,66 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Catch.Tests.Editor
+{
+    public partial class TestSceneCatchEditorSaving : EditorSavingTestScene
+    {
+        protected override Ruleset CreateRuleset() => new CatchRuleset();
+
+        [Test]
+        public void TestCatchJuiceStreamTickCorrect()
+        {
+            AddStep("enter timing mode", () => InputManager.Key(Key.F3));
+            AddStep("add timing point", () => EditorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint()));
+            AddStep("enter compose mode", () => InputManager.Key(Key.F1));
+
+            Vector2 startPoint = Vector2.Zero;
+            float increment = 0;
+
+            AddUntilStep("wait for playfield", () => this.ChildrenOfType<CatchPlayfield>().FirstOrDefault()?.IsLoaded == true);
+            AddStep("move to centre", () =>
+            {
+                var playfield = this.ChildrenOfType<CatchPlayfield>().Single();
+                startPoint = playfield.ScreenSpaceDrawQuad.Centre + new Vector2(0, playfield.ScreenSpaceDrawQuad.Height / 3);
+                increment = playfield.ScreenSpaceDrawQuad.Height / 10;
+                InputManager.MoveMouseTo(startPoint);
+            });
+            AddStep("choose juice stream placing tool", () => InputManager.Key(Key.Number3));
+            AddStep("start placement", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("move to next", () => InputManager.MoveMouseTo(startPoint + new Vector2(2 * increment, -increment)));
+            AddStep("add node", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("move to next", () => InputManager.MoveMouseTo(startPoint + new Vector2(-2 * increment, -2 * increment)));
+            AddStep("add node", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("move to next", () => InputManager.MoveMouseTo(startPoint + new Vector2(0, -3 * increment)));
+            AddStep("end placement", () => InputManager.Click(MouseButton.Right));
+
+            AddUntilStep("juice stream placed", () => EditorBeatmap.HitObjects, () => Has.Count.EqualTo(1));
+
+            int largeDropletCount = 0, tinyDropletCount = 0;
+            AddStep("store droplet count", () =>
+            {
+                largeDropletCount = EditorBeatmap.HitObjects[0].NestedHitObjects.Count(t => t.GetType() == typeof(Droplet));
+                tinyDropletCount = EditorBeatmap.HitObjects[0].NestedHitObjects.Count(t => t.GetType() == typeof(TinyDroplet));
+            });
+
+            SaveEditor();
+            ReloadEditorToSameBeatmap();
+
+            AddAssert("large droplet count is the same", () => EditorBeatmap.HitObjects[0].NestedHitObjects.Count(t => t.GetType() == typeof(Droplet)), () => Is.EqualTo(largeDropletCount));
+            AddAssert("tiny droplet count is the same", () => EditorBeatmap.HitObjects[0].NestedHitObjects.Count(t => t.GetType() == typeof(TinyDroplet)), () => Is.EqualTo(tinyDropletCount));
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModNoScope.cs b/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModNoScope.cs
index c48bf7adc9..c8f7da1aae 100644
--- a/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModNoScope.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModNoScope.cs
@@ -74,7 +74,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Mods
                             StartTime = 5000,
                         }
                     },
-                    Breaks = new List<BreakPeriod>
+                    Breaks =
                     {
                         new BreakPeriod(2000, 4000),
                     }
diff --git a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs
index 8c460586b0..f5c5ffb529 100644
--- a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs
@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         LegacyConvertedY = yPositionData?.Y ?? CatchHitObject.DEFAULT_LEGACY_CONVERT_Y,
                         // prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
                         // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1 : ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity,
+                        TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(obj.StartTime).SliderVelocity : 1,
                         SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1
                     }.Yield();
 
diff --git a/osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs b/osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs
index d07f25ba90..55232a9598 100644
--- a/osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs
@@ -76,7 +76,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             value *= Math.Pow(accuracy(), 5.5);
 
             if (score.Mods.Any(m => m is ModNoFail))
-                value *= 0.90;
+                value *= Math.Max(0.90, 1.0 - 0.02 * numMiss);
 
             return new CatchPerformanceAttributes
             {
diff --git a/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs b/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs
index c8c8db1ebd..7b57dac36e 100644
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs
@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints
         {
             base.LoadComplete();
 
-            inputManager = GetContainingInputManager();
+            inputManager = GetContainingInputManager()!;
 
             BeginPlacement();
         }
diff --git a/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs b/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs
index dade129038..9e7e0b6042 100644
--- a/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs
+++ b/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs
@@ -12,6 +12,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Catch.Objects
@@ -46,16 +47,10 @@ namespace osu.Game.Rulesets.Catch.Objects
         public double TickDistanceMultiplier = 1;
 
         [JsonIgnore]
-        private double velocityFactor;
+        public double Velocity { get; private set; }
 
         [JsonIgnore]
-        private double tickDistanceFactor;
-
-        [JsonIgnore]
-        public double Velocity => velocityFactor * SliderVelocityMultiplier;
-
-        [JsonIgnore]
-        public double TickDistance => tickDistanceFactor * TickDistanceMultiplier;
+        public double TickDistance { get; private set; }
 
         /// <summary>
         /// The length of one span of this <see cref="JuiceStream"/>.
@@ -68,14 +63,21 @@ namespace osu.Game.Rulesets.Catch.Objects
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
 
-            velocityFactor = base_scoring_distance * difficulty.SliderMultiplier / timingPoint.BeatLength;
-            tickDistanceFactor = base_scoring_distance * difficulty.SliderMultiplier / difficulty.SliderTickRate;
+            Velocity = base_scoring_distance * difficulty.SliderMultiplier / LegacyRulesetExtensions.GetPrecisionAdjustedBeatLength(this, timingPoint, CatchRuleset.SHORT_NAME);
+
+            // WARNING: this is intentionally not computed as `BASE_SCORING_DISTANCE * difficulty.SliderMultiplier`
+            // for backwards compatibility reasons (intentionally introducing floating point errors to match stable).
+            double scoringDistance = Velocity * timingPoint.BeatLength;
+
+            TickDistance = scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier;
         }
 
         protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
         {
             base.CreateNestedHitObjects(cancellationToken);
 
+            this.PopulateNodeSamples();
+
             var dropletSamples = Samples.Select(s => s.With(@"slidertick")).ToList();
 
             int nodeIndex = 0;
diff --git a/osu.Game.Rulesets.Catch/UI/CatcherArea.cs b/osu.Game.Rulesets.Catch/UI/CatcherArea.cs
index 567c288b47..21faec56de 100644
--- a/osu.Game.Rulesets.Catch/UI/CatcherArea.cs
+++ b/osu.Game.Rulesets.Catch/UI/CatcherArea.cs
@@ -84,7 +84,7 @@ namespace osu.Game.Rulesets.Catch.UI
         {
             base.Update();
 
-            var replayState = (GetContainingInputManager().CurrentState as RulesetInputManagerInputState<CatchAction>)?.LastReplayState as CatchFramedReplayInputHandler.CatchReplayState;
+            var replayState = (GetContainingInputManager()!.CurrentState as RulesetInputManagerInputState<CatchAction>)?.LastReplayState as CatchFramedReplayInputHandler.CatchReplayState;
 
             SetCatcherPosition(
                 replayState?.CatcherX ??
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaBeatSnapGrid.cs b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaBeatSnapGrid.cs
index fbc0ed1785..127beed83e 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaBeatSnapGrid.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaBeatSnapGrid.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
@@ -17,6 +18,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Visual;
 using osuTK;
 
@@ -84,6 +86,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
     public partial class TestHitObjectComposer : HitObjectComposer
     {
         public override Playfield Playfield { get; }
+        public override ComposeBlueprintContainer BlueprintContainer => throw new NotImplementedException();
         public override IEnumerable<DrawableHitObject> HitObjects => Enumerable.Empty<DrawableHitObject>();
         public override bool CursorInPlacementArea => false;
 
@@ -100,7 +103,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
 
         public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
         {
-            throw new System.NotImplementedException();
+            throw new NotImplementedException();
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs
new file mode 100644
index 0000000000..9765648f44
--- /dev/null
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs
@@ -0,0 +1,45 @@
+// Copyright (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.Testing;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Setup;
+using osu.Game.Tests.Visual;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Mania.Tests.Editor
+{
+    public partial class TestSceneManiaEditorSaving : EditorSavingTestScene
+    {
+        protected override Ruleset CreateRuleset() => new ManiaRuleset();
+
+        [Test]
+        public void TestKeyCountChange()
+        {
+            LabelledSliderBar<float> keyCount = null!;
+
+            AddStep("go to setup screen", () => InputManager.Key(Key.F4));
+            AddUntilStep("retrieve key count slider", () => keyCount = Editor.ChildrenOfType<SetupScreen>().Single().ChildrenOfType<LabelledSliderBar<float>>().First(), () => Is.Not.Null);
+            AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
+            AddStep("change key count to 8", () =>
+            {
+                keyCount.Current.Value = 8;
+            });
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
+            AddStep("refuse", () => InputManager.Key(Key.Number2));
+            AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
+
+            AddStep("change key count to 8 again", () =>
+            {
+                keyCount.Current.Value = 8;
+            });
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().Single().CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
+            AddStep("acquiesce", () => InputManager.Key(Key.Number1));
+            AddUntilStep("beatmap became 8K", () => Game.Beatmap.Value.BeatmapInfo.Difficulty.CircleSize, () => Is.EqualTo(8));
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaHitObjectComposer.cs b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaHitObjectComposer.cs
index 8e0b51dcf8..d88f488582 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaHitObjectComposer.cs
@@ -186,8 +186,106 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             AddAssert("head note positioned correctly", () => Precision.AlmostEquals(holdNote.ScreenSpaceDrawQuad.BottomLeft, holdNote.Head.ScreenSpaceDrawQuad.BottomLeft));
             AddAssert("tail note positioned correctly", () => Precision.AlmostEquals(holdNote.ScreenSpaceDrawQuad.TopLeft, holdNote.Tail.ScreenSpaceDrawQuad.BottomLeft));
 
-            AddAssert("head blueprint positioned correctly", () => this.ChildrenOfType<EditNotePiece>().ElementAt(0).DrawPosition == holdNote.Head.DrawPosition);
-            AddAssert("tail blueprint positioned correctly", () => this.ChildrenOfType<EditNotePiece>().ElementAt(1).DrawPosition == holdNote.Tail.DrawPosition);
+            AddAssert("head blueprint positioned correctly", () => this.ChildrenOfType<EditHoldNoteEndPiece>().ElementAt(0).DrawPosition == holdNote.Head.DrawPosition);
+            AddAssert("tail blueprint positioned correctly", () => this.ChildrenOfType<EditHoldNoteEndPiece>().ElementAt(1).DrawPosition == holdNote.Tail.DrawPosition);
+        }
+
+        [Test]
+        public void TestDragHoldNoteHead()
+        {
+            setScrollStep(ScrollingDirection.Down);
+
+            HoldNote holdNote = null;
+            AddStep("setup beatmap", () =>
+            {
+                composer.EditorBeatmap.Clear();
+                composer.EditorBeatmap.Add(holdNote = new HoldNote
+                {
+                    Column = 1,
+                    StartTime = 250,
+                    EndTime = 750,
+                });
+            });
+
+            DrawableHoldNote drawableHoldNote = null;
+            EditHoldNoteEndPiece headPiece = null;
+
+            AddStep("select blueprint", () =>
+            {
+                drawableHoldNote = this.ChildrenOfType<DrawableHoldNote>().Single();
+                InputManager.MoveMouseTo(drawableHoldNote);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("grab hold note head", () =>
+            {
+                headPiece = this.ChildrenOfType<EditHoldNoteEndPiece>().First();
+                InputManager.MoveMouseTo(headPiece);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("drag head downwards", () =>
+            {
+                InputManager.MoveMouseTo(headPiece, new Vector2(0, 100));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("start time moved back", () => holdNote!.StartTime, () => Is.LessThan(250));
+            AddAssert("end time unchanged", () => holdNote.EndTime, () => Is.EqualTo(750));
+
+            AddAssert("head note positioned correctly", () => Precision.AlmostEquals(drawableHoldNote.ScreenSpaceDrawQuad.BottomLeft, drawableHoldNote.Head.ScreenSpaceDrawQuad.BottomLeft));
+            AddAssert("tail note positioned correctly", () => Precision.AlmostEquals(drawableHoldNote.ScreenSpaceDrawQuad.TopLeft, drawableHoldNote.Tail.ScreenSpaceDrawQuad.BottomLeft));
+
+            AddAssert("head blueprint positioned correctly", () => this.ChildrenOfType<EditHoldNoteEndPiece>().ElementAt(0).DrawPosition == drawableHoldNote.Head.DrawPosition);
+            AddAssert("tail blueprint positioned correctly", () => this.ChildrenOfType<EditHoldNoteEndPiece>().ElementAt(1).DrawPosition == drawableHoldNote.Tail.DrawPosition);
+        }
+
+        [Test]
+        public void TestDragHoldNoteTail()
+        {
+            setScrollStep(ScrollingDirection.Down);
+
+            HoldNote holdNote = null;
+            AddStep("setup beatmap", () =>
+            {
+                composer.EditorBeatmap.Clear();
+                composer.EditorBeatmap.Add(holdNote = new HoldNote
+                {
+                    Column = 1,
+                    StartTime = 250,
+                    EndTime = 750,
+                });
+            });
+
+            DrawableHoldNote drawableHoldNote = null;
+            EditHoldNoteEndPiece tailPiece = null;
+
+            AddStep("select blueprint", () =>
+            {
+                drawableHoldNote = this.ChildrenOfType<DrawableHoldNote>().Single();
+                InputManager.MoveMouseTo(drawableHoldNote);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddStep("grab hold note tail", () =>
+            {
+                tailPiece = this.ChildrenOfType<EditHoldNoteEndPiece>().Last();
+                InputManager.MoveMouseTo(tailPiece);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("drag tail upwards", () =>
+            {
+                InputManager.MoveMouseTo(tailPiece, new Vector2(0, -100));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            AddAssert("start time unchanged", () => holdNote!.StartTime, () => Is.EqualTo(250));
+            AddAssert("end time moved forward", () => holdNote.EndTime, () => Is.GreaterThan(750));
+
+            AddAssert("head note positioned correctly", () => Precision.AlmostEquals(drawableHoldNote.ScreenSpaceDrawQuad.BottomLeft, drawableHoldNote.Head.ScreenSpaceDrawQuad.BottomLeft));
+            AddAssert("tail note positioned correctly", () => Precision.AlmostEquals(drawableHoldNote.ScreenSpaceDrawQuad.TopLeft, drawableHoldNote.Tail.ScreenSpaceDrawQuad.BottomLeft));
+
+            AddAssert("head blueprint positioned correctly", () => this.ChildrenOfType<EditHoldNoteEndPiece>().ElementAt(0).DrawPosition == drawableHoldNote.Head.DrawPosition);
+            AddAssert("tail blueprint positioned correctly", () => this.ChildrenOfType<EditHoldNoteEndPiece>().ElementAt(1).DrawPosition == drawableHoldNote.Tail.DrawPosition);
         }
 
         private void setScrollStep(ScrollingDirection direction)
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs
new file mode 100644
index 0000000000..b48f579ec0
--- /dev/null
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaSelectionHandler.cs
@@ -0,0 +1,96 @@
+// Copyright (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.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Tests.Visual;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Mania.Tests.Editor
+{
+    public partial class TestSceneManiaSelectionHandler : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new ManiaRuleset();
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        [Test]
+        public void TestHorizontalFlipOverSelection()
+        {
+            ManiaHitObject first = null!, second = null!, third = null!;
+
+            AddStep("create objects", () =>
+            {
+                EditorBeatmap.Add(first = new Note { StartTime = 250, Column = 2 });
+                EditorBeatmap.Add(second = new HoldNote { StartTime = 750, Duration = 1500, Column = 1 });
+                EditorBeatmap.Add(third = new Note { StartTime = 1250, Column = 3 });
+            });
+
+            AddStep("select everything", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
+            AddStep("flip horizontally over selection", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<SelectionBoxButton>().First());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("first object stayed in place", () => first.Column, () => Is.EqualTo(2));
+            AddAssert("second object flipped", () => second.Column, () => Is.EqualTo(3));
+            AddAssert("third object flipped", () => third.Column, () => Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestHorizontalFlipOverPlayfield()
+        {
+            ManiaHitObject first = null!, second = null!, third = null!;
+
+            AddStep("create objects", () =>
+            {
+                EditorBeatmap.Add(first = new Note { StartTime = 250, Column = 2 });
+                EditorBeatmap.Add(second = new HoldNote { StartTime = 750, Duration = 1500, Column = 1 });
+                EditorBeatmap.Add(third = new Note { StartTime = 1250, Column = 3 });
+            });
+
+            AddStep("select everything", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
+            AddStep("flip horizontally", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Key(Key.H);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+
+            AddAssert("first object flipped", () => first.Column, () => Is.EqualTo(1));
+            AddAssert("second object flipped", () => second.Column, () => Is.EqualTo(2));
+            AddAssert("third object flipped", () => third.Column, () => Is.EqualTo(0));
+        }
+
+        [Test]
+        public void TestVerticalFlip()
+        {
+            ManiaHitObject first = null!, second = null!, third = null!;
+
+            AddStep("create objects", () =>
+            {
+                EditorBeatmap.Add(first = new Note { StartTime = 250, Column = 2 });
+                EditorBeatmap.Add(second = new HoldNote { StartTime = 750, Duration = 1500, Column = 1 });
+                EditorBeatmap.Add(third = new Note { StartTime = 1250, Column = 3 });
+            });
+
+            AddStep("select everything", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
+            AddStep("flip vertically", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Key(Key.J);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+
+            AddAssert("first object flipped", () => first.StartTime, () => Is.EqualTo(2250));
+            AddAssert("second object flipped", () => second.StartTime, () => Is.EqualTo(250));
+            AddAssert("third object flipped", () => third.StartTime, () => Is.EqualTo(1250));
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneDrawableManiaHitObject.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneDrawableManiaHitObject.cs
index 51c2bac6d1..7a0abb9e64 100644
--- a/osu.Game.Rulesets.Mania.Tests/TestSceneDrawableManiaHitObject.cs
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneDrawableManiaHitObject.cs
@@ -66,7 +66,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             AddStep("Hold key", () =>
             {
                 clock.CurrentTime = 0;
-                note.OnPressed(new KeyBindingPressEvent<ManiaAction>(GetContainingInputManager().CurrentState, ManiaAction.Key1));
+                note.OnPressed(new KeyBindingPressEvent<ManiaAction>(GetContainingInputManager()!.CurrentState, ManiaAction.Key1));
             });
             AddStep("progress time", () => clock.CurrentTime = 500);
             AddAssert("head is visible", () => note.Head.Alpha == 1);
diff --git a/osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditHoldNoteEndPiece.cs b/osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditHoldNoteEndPiece.cs
new file mode 100644
index 0000000000..0aa72c28b8
--- /dev/null
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditHoldNoteEndPiece.cs
@@ -0,0 +1,81 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Mania.Skinning.Default;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
+{
+    public partial class EditHoldNoteEndPiece : CompositeDrawable
+    {
+        public Action? DragStarted { get; init; }
+        public Action<Vector2>? Dragging { get; init; }
+        public Action? DragEnded { get; init; }
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Height = DefaultNotePiece.NOTE_HEIGHT;
+
+            CornerRadius = 5;
+            Masking = true;
+
+            InternalChild = new DefaultNotePiece();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            updateState();
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateState();
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            updateState();
+            base.OnHoverLost(e);
+        }
+
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            DragStarted?.Invoke();
+            return true;
+        }
+
+        protected override void OnDrag(DragEvent e)
+        {
+            base.OnDrag(e);
+            Dragging?.Invoke(e.ScreenSpaceMousePosition);
+        }
+
+        protected override void OnDragEnd(DragEndEvent e)
+        {
+            base.OnDragEnd(e);
+            DragEnded?.Invoke();
+        }
+
+        private void updateState()
+        {
+            var colour = colours.Yellow;
+
+            if (IsHovered)
+                colour = colour.Lighten(1);
+
+            Colour = colour;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs b/osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs
index 8ec5213d5f..b8e6aa26a0 100644
--- a/osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs
@@ -1,16 +1,16 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Screens.Edit;
 using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
@@ -18,10 +18,19 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
     public partial class HoldNoteSelectionBlueprint : ManiaSelectionBlueprint<HoldNote>
     {
         [Resolved]
-        private OsuColour colours { get; set; }
+        private OsuColour colours { get; set; } = null!;
 
-        private EditNotePiece head;
-        private EditNotePiece tail;
+        [Resolved]
+        private IEditorChangeHandler? changeHandler { get; set; }
+
+        [Resolved]
+        private EditorBeatmap? editorBeatmap { get; set; }
+
+        [Resolved]
+        private IPositionSnapProvider? positionSnapProvider { get; set; }
+
+        private EditHoldNoteEndPiece head = null!;
+        private EditHoldNoteEndPiece tail = null!;
 
         public HoldNoteSelectionBlueprint(HoldNote hold)
             : base(hold)
@@ -33,8 +42,43 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
         {
             InternalChildren = new Drawable[]
             {
-                head = new EditNotePiece { RelativeSizeAxes = Axes.X },
-                tail = new EditNotePiece { RelativeSizeAxes = Axes.X },
+                head = new EditHoldNoteEndPiece
+                {
+                    RelativeSizeAxes = Axes.X,
+                    DragStarted = () => changeHandler?.BeginChange(),
+                    Dragging = pos =>
+                    {
+                        double endTimeBeforeDrag = HitObject.EndTime;
+                        double proposedStartTime = positionSnapProvider?.FindSnappedPositionAndTime(pos).Time ?? HitObjectContainer.TimeAtScreenSpacePosition(pos);
+                        double proposedEndTime = endTimeBeforeDrag;
+
+                        if (proposedStartTime >= proposedEndTime)
+                            return;
+
+                        HitObject.StartTime = proposedStartTime;
+                        HitObject.EndTime = proposedEndTime;
+                        editorBeatmap?.Update(HitObject);
+                    },
+                    DragEnded = () => changeHandler?.EndChange(),
+                },
+                tail = new EditHoldNoteEndPiece
+                {
+                    RelativeSizeAxes = Axes.X,
+                    DragStarted = () => changeHandler?.BeginChange(),
+                    Dragging = pos =>
+                    {
+                        double proposedStartTime = HitObject.StartTime;
+                        double proposedEndTime = positionSnapProvider?.FindSnappedPositionAndTime(pos).Time ?? HitObjectContainer.TimeAtScreenSpacePosition(pos);
+
+                        if (proposedStartTime >= proposedEndTime)
+                            return;
+
+                        HitObject.StartTime = proposedStartTime;
+                        HitObject.EndTime = proposedEndTime;
+                        editorBeatmap?.Update(HitObject);
+                    },
+                    DragEnded = () => changeHandler?.EndChange(),
+                },
                 new Container
                 {
                     RelativeSizeAxes = Axes.Both,
diff --git a/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs b/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
index 8fdbada04f..9ae2112b30 100644
--- a/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
@@ -16,6 +17,16 @@ namespace osu.Game.Rulesets.Mania.Edit
         [Resolved]
         private HitObjectComposer composer { get; set; } = null!;
 
+        protected override void OnSelectionChanged()
+        {
+            base.OnSelectionChanged();
+
+            var selectedObjects = SelectedItems.OfType<ManiaHitObject>().ToArray();
+
+            SelectionBox.CanFlipX = canFlipX(selectedObjects);
+            SelectionBox.CanFlipY = canFlipY(selectedObjects);
+        }
+
         public override bool HandleMovement(MoveSelectionEvent<HitObject> moveEvent)
         {
             var hitObjectBlueprint = (HitObjectSelectionBlueprint)moveEvent.Blueprint;
@@ -26,6 +37,58 @@ namespace osu.Game.Rulesets.Mania.Edit
             return true;
         }
 
+        public override bool HandleFlip(Direction direction, bool flipOverOrigin)
+        {
+            var selectedObjects = SelectedItems.OfType<ManiaHitObject>().ToArray();
+            var maniaPlayfield = ((ManiaHitObjectComposer)composer).Playfield;
+
+            if (selectedObjects.Length == 0)
+                return false;
+
+            switch (direction)
+            {
+                case Direction.Horizontal:
+                    if (!canFlipX(selectedObjects))
+                        return false;
+
+                    int firstColumn = flipOverOrigin ? 0 : selectedObjects.Min(ho => ho.Column);
+                    int lastColumn = flipOverOrigin ? (int)EditorBeatmap.BeatmapInfo.Difficulty.CircleSize - 1 : selectedObjects.Max(ho => ho.Column);
+
+                    EditorBeatmap.PerformOnSelection(hitObject =>
+                    {
+                        var maniaObject = (ManiaHitObject)hitObject;
+                        maniaPlayfield.Remove(maniaObject);
+                        maniaObject.Column = firstColumn + (lastColumn - maniaObject.Column);
+                        maniaPlayfield.Add(maniaObject);
+                    });
+
+                    return true;
+
+                case Direction.Vertical:
+                    if (!canFlipY(selectedObjects))
+                        return false;
+
+                    double selectionStartTime = selectedObjects.Min(ho => ho.StartTime);
+                    double selectionEndTime = selectedObjects.Max(ho => ho.GetEndTime());
+
+                    EditorBeatmap.PerformOnSelection(hitObject =>
+                    {
+                        hitObject.StartTime = selectionStartTime + (selectionEndTime - hitObject.GetEndTime());
+                    });
+
+                    return true;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(direction), direction, "Cannot flip over the supplied direction.");
+            }
+        }
+
+        private static bool canFlipX(ManiaHitObject[] selectedObjects)
+            => selectedObjects.Select(ho => ho.Column).Distinct().Count() > 1;
+
+        private static bool canFlipY(ManiaHitObject[] selectedObjects)
+            => selectedObjects.Length > 1 && selectedObjects.Min(ho => ho.StartTime) < selectedObjects.Max(ho => ho.GetEndTime());
+
         private void performColumnMovement(int lastColumn, MoveSelectionEvent<HitObject> moveEvent)
         {
             var maniaPlayfield = ((ManiaHitObjectComposer)composer).Playfield;
diff --git a/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs b/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
index 4f983debea..62b54a7215 100644
--- a/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
@@ -3,20 +3,155 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
 using osu.Game.Resources.Localisation.Web;
+using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Setup;
 
 namespace osu.Game.Rulesets.Mania.Edit.Setup
 {
-    public partial class ManiaDifficultySection : DifficultySection
+    public partial class ManiaDifficultySection : SetupSection
     {
+        public override LocalisableString Title => EditorSetupStrings.DifficultyHeader;
+
+        private LabelledSliderBar<float> keyCountSlider { get; set; } = null!;
+        private LabelledSliderBar<float> healthDrainSlider { get; set; } = null!;
+        private LabelledSliderBar<float> overallDifficultySlider { get; set; } = null!;
+        private LabelledSliderBar<double> baseVelocitySlider { get; set; } = null!;
+        private LabelledSliderBar<double> tickRateSlider { get; set; } = null!;
+
+        [Resolved]
+        private Editor? editor { get; set; }
+
+        [Resolved]
+        private IEditorChangeHandler? changeHandler { get; set; }
+
         [BackgroundDependencyLoader]
         private void load()
         {
-            CircleSizeSlider.Label = BeatmapsetsStrings.ShowStatsCsMania;
-            CircleSizeSlider.Description = "The number of columns in the beatmap";
-            if (CircleSizeSlider.Current is BindableNumber<float> circleSizeFloat)
-                circleSizeFloat.Precision = 1;
+            Children = new Drawable[]
+            {
+                keyCountSlider = new LabelledSliderBar<float>
+                {
+                    Label = BeatmapsetsStrings.ShowStatsCsMania,
+                    FixedLabelWidth = LABEL_WIDTH,
+                    Description = "The number of columns in the beatmap",
+                    Current = new BindableFloat(Beatmap.Difficulty.CircleSize)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 1,
+                    }
+                },
+                healthDrainSlider = new LabelledSliderBar<float>
+                {
+                    Label = BeatmapsetsStrings.ShowStatsDrain,
+                    FixedLabelWidth = LABEL_WIDTH,
+                    Description = EditorSetupStrings.DrainRateDescription,
+                    Current = new BindableFloat(Beatmap.Difficulty.DrainRate)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    }
+                },
+                overallDifficultySlider = new LabelledSliderBar<float>
+                {
+                    Label = BeatmapsetsStrings.ShowStatsAccuracy,
+                    FixedLabelWidth = LABEL_WIDTH,
+                    Description = EditorSetupStrings.OverallDifficultyDescription,
+                    Current = new BindableFloat(Beatmap.Difficulty.OverallDifficulty)
+                    {
+                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
+                        MinValue = 0,
+                        MaxValue = 10,
+                        Precision = 0.1f,
+                    }
+                },
+                baseVelocitySlider = new LabelledSliderBar<double>
+                {
+                    Label = EditorSetupStrings.BaseVelocity,
+                    FixedLabelWidth = LABEL_WIDTH,
+                    Description = EditorSetupStrings.BaseVelocityDescription,
+                    Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
+                    {
+                        Default = 1.4,
+                        MinValue = 0.4,
+                        MaxValue = 3.6,
+                        Precision = 0.01f,
+                    }
+                },
+                tickRateSlider = new LabelledSliderBar<double>
+                {
+                    Label = EditorSetupStrings.TickRate,
+                    FixedLabelWidth = LABEL_WIDTH,
+                    Description = EditorSetupStrings.TickRateDescription,
+                    Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
+                    {
+                        Default = 1,
+                        MinValue = 1,
+                        MaxValue = 4,
+                        Precision = 1,
+                    }
+                },
+            };
+
+            keyCountSlider.Current.BindValueChanged(updateKeyCount);
+            healthDrainSlider.Current.BindValueChanged(_ => updateValues());
+            overallDifficultySlider.Current.BindValueChanged(_ => updateValues());
+            baseVelocitySlider.Current.BindValueChanged(_ => updateValues());
+            tickRateSlider.Current.BindValueChanged(_ => updateValues());
+        }
+
+        private bool updatingKeyCount;
+
+        private void updateKeyCount(ValueChangedEvent<float> keyCount)
+        {
+            if (updatingKeyCount) return;
+
+            updateValues();
+
+            if (editor == null) return;
+
+            updatingKeyCount = true;
+
+            editor.Reload().ContinueWith(t =>
+            {
+                if (!t.GetResultSafely())
+                {
+                    Schedule(() =>
+                    {
+                        changeHandler!.RestoreState(-1);
+                        Beatmap.Difficulty.CircleSize = keyCountSlider.Current.Value = keyCount.OldValue;
+                        updatingKeyCount = false;
+                    });
+                }
+                else
+                {
+                    updatingKeyCount = false;
+                }
+            });
+        }
+
+        private void updateValues()
+        {
+            // for now, update these on commit rather than making BeatmapMetadata bindables.
+            // after switching database engines we can reconsider if switching to bindables is a good direction.
+            Beatmap.Difficulty.CircleSize = keyCountSlider.Current.Value;
+            Beatmap.Difficulty.DrainRate = healthDrainSlider.Current.Value;
+            Beatmap.Difficulty.OverallDifficulty = overallDifficultySlider.Current.Value;
+            Beatmap.Difficulty.SliderMultiplier = baseVelocitySlider.Current.Value;
+            Beatmap.Difficulty.SliderTickRate = tickRateSlider.Current.Value;
+
+            Beatmap.UpdateAllHitObjects();
+            Beatmap.SaveState();
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/ManiaRuleset.cs b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
index b5614e2b56..40eb44944c 100644
--- a/osu.Game.Rulesets.Mania/ManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
@@ -421,7 +421,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override RulesetSetupSection CreateEditorSetupSection() => new ManiaSetupSection();
 
-        public override DifficultySection CreateEditorDifficultySection() => new ManiaDifficultySection();
+        public override SetupSection CreateEditorDifficultySection() => new ManiaDifficultySection();
 
         public int GetKeyCount(IBeatmapInfo beatmapInfo, IReadOnlyList<Mod>? mods = null)
             => ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), mods);
diff --git a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBodyPiece.cs b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBodyPiece.cs
index 00054f6be2..6de0752671 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBodyPiece.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBodyPiece.cs
@@ -65,11 +65,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             if (tmp is IFramedAnimation tmpAnimation && tmpAnimation.FrameCount > 0)
                 frameLength = Math.Max(1000 / 60.0, 170.0 / tmpAnimation.FrameCount);
 
-            light = skin.GetAnimation(lightImage, true, true, frameLength: frameLength).With(d =>
+            light = skin.GetAnimation(lightImage, true, true, frameLength: frameLength)?.With(d =>
             {
-                if (d == null)
-                    return;
-
                 d.Origin = Anchor.Centre;
                 d.Blending = BlendingParameters.Additive;
                 d.Scale = new Vector2(lightScale);
@@ -91,11 +88,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             direction.BindTo(scrollingInfo.Direction);
             isHitting.BindTo(holdNote.IsHitting);
 
-            bodySprite = skin.GetAnimation(imageName, wrapMode, wrapMode, true, true, frameLength: 30).With(d =>
+            bodySprite = skin.GetAnimation(imageName, wrapMode, wrapMode, true, true, frameLength: 30)?.With(d =>
             {
-                if (d == null)
-                    return;
-
                 if (d is TextureAnimation animation)
                     animation.IsPlaying = false;
 
@@ -245,7 +239,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                         // i dunno this looks about right??
                         // the guard against zero draw height is intended for zero-length hold notes. yes, such cases have been spotted in the wild.
                         if (sprite.DrawHeight > 0)
-                            bodySprite.Scale = new Vector2(1, scaleDirection * 32800 / sprite.DrawHeight);
+                            bodySprite.Scale = new Vector2(1, scaleDirection * MathF.Max(1, 32800 / sprite.DrawHeight));
                     }
 
                     break;
diff --git a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyHitExplosion.cs b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyHitExplosion.cs
index 1ec218644c..95b00e32ea 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyHitExplosion.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyHitExplosion.cs
@@ -43,11 +43,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             if (tmp is IFramedAnimation tmpAnimation && tmpAnimation.FrameCount > 0)
                 frameLength = Math.Max(1000 / 60.0, 170.0 / tmpAnimation.FrameCount);
 
-            explosion = skin.GetAnimation(imageName, true, false, frameLength: frameLength).With(d =>
+            explosion = skin.GetAnimation(imageName, true, false, frameLength: frameLength)?.With(d =>
             {
-                if (d == null)
-                    return;
-
                 d.Origin = Anchor.Centre;
                 d.Blending = BlendingParameters.Additive;
                 d.Scale = new Vector2(explosionScale);
diff --git a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyStageForeground.cs b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyStageForeground.cs
index 1a47fe5076..680198c1a6 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyStageForeground.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyStageForeground.cs
@@ -28,13 +28,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             string bottomImage = skin.GetManiaSkinConfig<string>(LegacyManiaSkinConfigurationLookups.BottomStageImage)?.Value
                                  ?? "mania-stage-bottom";
 
-            sprite = skin.GetAnimation(bottomImage, true, true)?.With(d =>
-            {
-                if (d == null)
-                    return;
-
-                d.Scale = new Vector2(1.6f);
-            });
+            sprite = skin.GetAnimation(bottomImage, true, true)?.With(d => d.Scale = new Vector2(1.6f));
 
             if (sprite != null)
                 InternalChild = sprite;
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
index 5798869210..48aa74c5bf 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs
@@ -8,7 +8,9 @@ using osu.Framework.Utils;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
+using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Visual;
+using osu.Game.Utils;
 using osuTK;
 using osuTK.Input;
 
@@ -25,22 +27,22 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
 
             AddUntilStep("distance snap grid visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
-            rectangularGridActive(false);
+            gridActive<RectangularPositionSnapGrid>(false);
 
             AddStep("enable rectangular grid", () => InputManager.Key(Key.Y));
 
             AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
             AddUntilStep("distance snap grid still visible", () => this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
-            rectangularGridActive(true);
+            gridActive<RectangularPositionSnapGrid>(true);
 
             AddStep("disable distance snap grid", () => InputManager.Key(Key.T));
             AddUntilStep("distance snap grid hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
             AddStep("select second object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.ElementAt(1)));
-            rectangularGridActive(true);
+            gridActive<RectangularPositionSnapGrid>(true);
 
             AddStep("disable rectangular grid", () => InputManager.Key(Key.Y));
             AddUntilStep("distance snap grid still hidden", () => !this.ChildrenOfType<OsuDistanceSnapGrid>().Any());
-            rectangularGridActive(false);
+            gridActive<RectangularPositionSnapGrid>(false);
         }
 
         [Test]
@@ -117,33 +119,56 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         [Test]
         public void TestGridSnapMomentaryToggle()
         {
-            rectangularGridActive(false);
+            gridActive<RectangularPositionSnapGrid>(false);
             AddStep("hold shift", () => InputManager.PressKey(Key.ShiftLeft));
-            rectangularGridActive(true);
+            gridActive<RectangularPositionSnapGrid>(true);
             AddStep("release shift", () => InputManager.ReleaseKey(Key.ShiftLeft));
-            rectangularGridActive(false);
+            gridActive<RectangularPositionSnapGrid>(false);
         }
 
-        private void rectangularGridActive(bool active)
+        private void gridActive<T>(bool active) where T : PositionSnapGrid
         {
             AddStep("choose placement tool", () => InputManager.Key(Key.Number2));
-            AddStep("move cursor to (1, 1)", () =>
+            AddStep("move cursor to spacing + (1, 1)", () =>
             {
-                var composer = Editor.ChildrenOfType<OsuRectangularPositionSnapGrid>().Single();
-                InputManager.MoveMouseTo(composer.ToScreenSpace(new Vector2(1, 1)));
+                var composer = Editor.ChildrenOfType<T>().Single();
+                InputManager.MoveMouseTo(composer.ToScreenSpace(uniqueSnappingPosition(composer) + new Vector2(1, 1)));
             });
 
             if (active)
-                AddAssert("placement blueprint at (0, 0)", () => Precision.AlmostEquals(Editor.ChildrenOfType<HitCirclePlacementBlueprint>().Single().HitObject.Position, new Vector2(0, 0)));
+            {
+                AddAssert("placement blueprint at spacing + (0, 0)", () =>
+                {
+                    var composer = Editor.ChildrenOfType<T>().Single();
+                    return Precision.AlmostEquals(Editor.ChildrenOfType<HitCirclePlacementBlueprint>().Single().HitObject.Position,
+                        uniqueSnappingPosition(composer));
+                });
+            }
             else
-                AddAssert("placement blueprint at (1, 1)", () => Precision.AlmostEquals(Editor.ChildrenOfType<HitCirclePlacementBlueprint>().Single().HitObject.Position, new Vector2(1, 1)));
+            {
+                AddAssert("placement blueprint at spacing + (1, 1)", () =>
+                {
+                    var composer = Editor.ChildrenOfType<T>().Single();
+                    return Precision.AlmostEquals(Editor.ChildrenOfType<HitCirclePlacementBlueprint>().Single().HitObject.Position,
+                        uniqueSnappingPosition(composer) + new Vector2(1, 1));
+                });
+            }
+        }
+
+        private Vector2 uniqueSnappingPosition(PositionSnapGrid grid)
+        {
+            return grid switch
+            {
+                RectangularPositionSnapGrid rectangular => rectangular.StartPosition.Value + GeometryUtils.RotateVector(rectangular.Spacing.Value, -rectangular.GridLineRotation.Value),
+                _ => Vector2.Zero
+            };
         }
 
         [Test]
         public void TestGridSizeToggling()
         {
             AddStep("enable rectangular grid", () => InputManager.Key(Key.Y));
-            AddUntilStep("rectangular grid visible", () => this.ChildrenOfType<OsuRectangularPositionSnapGrid>().Any());
+            AddUntilStep("rectangular grid visible", () => this.ChildrenOfType<RectangularPositionSnapGrid>().Any());
             gridSizeIs(4);
 
             nextGridSizeIs(8);
@@ -159,7 +184,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
         }
 
         private void gridSizeIs(int size)
-            => AddAssert($"grid size is {size}", () => this.ChildrenOfType<OsuRectangularPositionSnapGrid>().Single().Spacing == new Vector2(size)
+            => AddAssert($"grid size is {size}", () => this.ChildrenOfType<RectangularPositionSnapGrid>().Single().Spacing.Value == new Vector2(size)
                                                        && EditorBeatmap.BeatmapInfo.GridSize == size);
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAlternate.cs b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAlternate.cs
index 88c81c7a39..7375617aa8 100644
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAlternate.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAlternate.cs
@@ -133,7 +133,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             Autoplay = false,
             Beatmap = new Beatmap
             {
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(500, 2000),
                 },
diff --git a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModNoScope.cs b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModNoScope.cs
index 9dfa76fc8e..d3996ebc3b 100644
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModNoScope.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModNoScope.cs
@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                             StartTime = 5000,
                         }
                     },
-                    Breaks = new List<BreakPeriod>
+                    Breaks =
                     {
                         new BreakPeriod(2000, 4000),
                     }
diff --git a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModSingleTap.cs b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModSingleTap.cs
index 402c680b46..bd2b205ac8 100644
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModSingleTap.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModSingleTap.cs
@@ -132,7 +132,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             Autoplay = false,
             Beatmap = new Beatmap
             {
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(500, 2000),
                 },
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneGameplayCursor.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneGameplayCursor.cs
index e6696032ae..98113a6513 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneGameplayCursor.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneGameplayCursor.cs
@@ -161,9 +161,9 @@ namespace osu.Game.Rulesets.Osu.Tests
 
                     pressed = value;
                     if (value)
-                        OnPressed(new KeyBindingPressEvent<OsuAction>(GetContainingInputManager().CurrentState, OsuAction.LeftButton));
+                        OnPressed(new KeyBindingPressEvent<OsuAction>(GetContainingInputManager()!.CurrentState, OsuAction.LeftButton));
                     else
-                        OnReleased(new KeyBindingReleaseEvent<OsuAction>(GetContainingInputManager().CurrentState, OsuAction.LeftButton));
+                        OnReleased(new KeyBindingReleaseEvent<OsuAction>(GetContainingInputManager()!.CurrentState, OsuAction.LeftButton));
                 }
             }
 
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircleArea.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircleArea.cs
index 71174e3295..5cac9843b8 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircleArea.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircleArea.cs
@@ -100,7 +100,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private void scheduleHit() => AddStep("schedule action", () =>
         {
             double delay = hitCircle.StartTime - hitCircle.HitWindows.WindowFor(HitResult.Great) - Time.Current;
-            Scheduler.AddDelayed(() => hitAreaReceptor.OnPressed(new KeyBindingPressEvent<OsuAction>(GetContainingInputManager().CurrentState, OsuAction.LeftButton)), delay);
+            Scheduler.AddDelayed(() => hitAreaReceptor.OnPressed(new KeyBindingPressEvent<OsuAction>(GetContainingInputManager()!.CurrentState, OsuAction.LeftButton)), delay);
         });
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSlider.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSlider.cs
index 4600db8174..b18c77e8ee 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSlider.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSlider.cs
@@ -156,6 +156,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 slider = (DrawableSlider)createSlider(repeats: 1);
                 Add(slider);
+                slider.HitObject.NodeSamples.Clear();
             });
 
             AddStep("change samples", () => slider.HitObject.Samples = new[]
diff --git a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs
index 9cc0a8c414..d335913586 100644
--- a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs
+++ b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
@@ -41,22 +42,22 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
         {
             base.PostProcess();
 
-            var osuBeatmap = (Beatmap<OsuHitObject>)Beatmap;
+            var hitObjects = Beatmap.HitObjects as List<OsuHitObject> ?? Beatmap.HitObjects.OfType<OsuHitObject>().ToList();
 
-            if (osuBeatmap.HitObjects.Count > 0)
+            if (hitObjects.Count > 0)
             {
                 // Reset stacking
-                foreach (var h in osuBeatmap.HitObjects)
+                foreach (var h in hitObjects)
                     h.StackHeight = 0;
 
                 if (Beatmap.BeatmapInfo.BeatmapVersion >= 6)
-                    applyStacking(osuBeatmap, 0, osuBeatmap.HitObjects.Count - 1);
+                    applyStacking(Beatmap.BeatmapInfo, hitObjects, 0, hitObjects.Count - 1);
                 else
-                    applyStackingOld(osuBeatmap);
+                    applyStackingOld(Beatmap.BeatmapInfo, hitObjects);
             }
         }
 
-        private void applyStacking(Beatmap<OsuHitObject> beatmap, int startIndex, int endIndex)
+        private void applyStacking(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObjects, int startIndex, int endIndex)
         {
             ArgumentOutOfRangeException.ThrowIfGreaterThan(startIndex, endIndex);
             ArgumentOutOfRangeException.ThrowIfNegative(startIndex);
@@ -64,24 +65,24 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 
             int extendedEndIndex = endIndex;
 
-            if (endIndex < beatmap.HitObjects.Count - 1)
+            if (endIndex < hitObjects.Count - 1)
             {
                 // Extend the end index to include objects they are stacked on
                 for (int i = endIndex; i >= startIndex; i--)
                 {
                     int stackBaseIndex = i;
 
-                    for (int n = stackBaseIndex + 1; n < beatmap.HitObjects.Count; n++)
+                    for (int n = stackBaseIndex + 1; n < hitObjects.Count; n++)
                     {
-                        OsuHitObject stackBaseObject = beatmap.HitObjects[stackBaseIndex];
+                        OsuHitObject stackBaseObject = hitObjects[stackBaseIndex];
                         if (stackBaseObject is Spinner) break;
 
-                        OsuHitObject objectN = beatmap.HitObjects[n];
+                        OsuHitObject objectN = hitObjects[n];
                         if (objectN is Spinner)
                             continue;
 
                         double endTime = stackBaseObject.GetEndTime();
-                        double stackThreshold = objectN.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
+                        double stackThreshold = objectN.TimePreempt * beatmapInfo.StackLeniency;
 
                         if (objectN.StartTime - endTime > stackThreshold)
                             // We are no longer within stacking range of the next object.
@@ -100,7 +101,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                     if (stackBaseIndex > extendedEndIndex)
                     {
                         extendedEndIndex = stackBaseIndex;
-                        if (extendedEndIndex == beatmap.HitObjects.Count - 1)
+                        if (extendedEndIndex == hitObjects.Count - 1)
                             break;
                     }
                 }
@@ -123,10 +124,10 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                  * 2 and 1 will be ignored in the i loop because they already have a stack value.
                  */
 
-                OsuHitObject objectI = beatmap.HitObjects[i];
+                OsuHitObject objectI = hitObjects[i];
                 if (objectI.StackHeight != 0 || objectI is Spinner) continue;
 
-                double stackThreshold = objectI.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
+                double stackThreshold = objectI.TimePreempt * beatmapInfo.StackLeniency;
 
                 /* If this object is a hitcircle, then we enter this "special" case.
                  * It either ends with a stack of hitcircles only, or a stack of hitcircles that are underneath a slider.
@@ -136,7 +137,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 {
                     while (--n >= 0)
                     {
-                        OsuHitObject objectN = beatmap.HitObjects[n];
+                        OsuHitObject objectN = hitObjects[n];
                         if (objectN is Spinner) continue;
 
                         double endTime = objectN.GetEndTime();
@@ -164,7 +165,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                             for (int j = n + 1; j <= i; j++)
                             {
                                 // For each object which was declared under this slider, we will offset it to appear *below* the slider end (rather than above).
-                                OsuHitObject objectJ = beatmap.HitObjects[j];
+                                OsuHitObject objectJ = hitObjects[j];
                                 if (Vector2Extensions.Distance(objectN.EndPosition, objectJ.Position) < stack_distance)
                                     objectJ.StackHeight -= offset;
                             }
@@ -191,7 +192,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                      */
                     while (--n >= startIndex)
                     {
-                        OsuHitObject objectN = beatmap.HitObjects[n];
+                        OsuHitObject objectN = hitObjects[n];
                         if (objectN is Spinner) continue;
 
                         if (objectI.StartTime - objectN.StartTime > stackThreshold)
@@ -208,11 +209,11 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
             }
         }
 
-        private void applyStackingOld(Beatmap<OsuHitObject> beatmap)
+        private void applyStackingOld(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObjects)
         {
-            for (int i = 0; i < beatmap.HitObjects.Count; i++)
+            for (int i = 0; i < hitObjects.Count; i++)
             {
-                OsuHitObject currHitObject = beatmap.HitObjects[i];
+                OsuHitObject currHitObject = hitObjects[i];
 
                 if (currHitObject.StackHeight != 0 && !(currHitObject is Slider))
                     continue;
@@ -220,11 +221,11 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 double startTime = currHitObject.GetEndTime();
                 int sliderStack = 0;
 
-                for (int j = i + 1; j < beatmap.HitObjects.Count; j++)
+                for (int j = i + 1; j < hitObjects.Count; j++)
                 {
-                    double stackThreshold = beatmap.HitObjects[i].TimePreempt * beatmap.BeatmapInfo.StackLeniency;
+                    double stackThreshold = hitObjects[i].TimePreempt * beatmapInfo.StackLeniency;
 
-                    if (beatmap.HitObjects[j].StartTime - stackThreshold > startTime)
+                    if (hitObjects[j].StartTime - stackThreshold > startTime)
                         break;
 
                     // The start position of the hitobject, or the position at the end of the path if the hitobject is a slider
@@ -239,17 +240,17 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                     // Effects of this can be seen on https://osu.ppy.sh/beatmapsets/243#osu/1146 at sliders around 86647 ms, where
                     // if we use `EndTime` here it would result in unexpected stacking.
 
-                    if (Vector2Extensions.Distance(beatmap.HitObjects[j].Position, currHitObject.Position) < stack_distance)
+                    if (Vector2Extensions.Distance(hitObjects[j].Position, currHitObject.Position) < stack_distance)
                     {
                         currHitObject.StackHeight++;
-                        startTime = beatmap.HitObjects[j].StartTime;
+                        startTime = hitObjects[j].StartTime;
                     }
-                    else if (Vector2Extensions.Distance(beatmap.HitObjects[j].Position, position2) < stack_distance)
+                    else if (Vector2Extensions.Distance(hitObjects[j].Position, position2) < stack_distance)
                     {
                         // Case for sliders - bump notes down and right, rather than up and left.
                         sliderStack++;
-                        beatmap.HitObjects[j].StackHeight -= sliderStack;
-                        startTime = beatmap.HitObjects[j].StartTime;
+                        hitObjects[j].StackHeight -= sliderStack;
+                        startTime = hitObjects[j].StartTime;
                     }
                 }
             }
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCircleOverlapMarker.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCircleOverlapMarker.cs
index fe335a048d..8ed9d0476a 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCircleOverlapMarker.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCircleOverlapMarker.cs
@@ -7,7 +7,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Objects.Types;
@@ -16,7 +15,6 @@ using osu.Game.Rulesets.Osu.Skinning.Default;
 using osu.Game.Screens.Edit;
 using osu.Game.Skinning;
 using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
 {
@@ -48,13 +46,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
                 {
-                    new Circle
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = Color4.White,
-                    },
                     ring = new RingPiece
                     {
                         BorderThickness = 4,
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCircleSelectionBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCircleSelectionBlueprint.cs
index 0608f8c929..fd2bbe9916 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCircleSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCircleSelectionBlueprint.cs
@@ -1,8 +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.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -16,6 +19,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
 
         protected readonly HitCirclePiece CirclePiece;
         private readonly HitCircleOverlapMarker marker;
+        private readonly Bindable<bool> showHitMarkers = new Bindable<bool>();
 
         public HitCircleSelectionBlueprint(HitCircle circle)
             : base(circle)
@@ -27,12 +31,32 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
             };
         }
 
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            config.BindWith(OsuSetting.EditorShowHitMarkers, showHitMarkers);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            showHitMarkers.BindValueChanged(_ =>
+            {
+                if (!showHitMarkers.Value)
+                    DrawableObject.RestoreHitAnimations();
+            });
+        }
+
         protected override void Update()
         {
             base.Update();
 
             CirclePiece.UpdateFrom(HitObject);
             marker.UpdateFrom(HitObject);
+
+            if (showHitMarkers.Value)
+                DrawableObject.SuppressHitAnimations();
         }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => DrawableObject.HitArea.ReceivePositionalInputAt(screenSpacePos);
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleOverlay.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleOverlay.cs
index d47cf6bf23..bd3b4bbc54 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleOverlay.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleOverlay.cs
@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
@@ -14,18 +13,17 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         private readonly Slider slider;
         private readonly SliderPosition position;
-        private readonly HitCircleOverlapMarker marker;
+        private readonly HitCircleOverlapMarker? marker;
 
         public SliderCircleOverlay(Slider slider, SliderPosition position)
         {
             this.slider = slider;
             this.position = position;
 
-            InternalChildren = new Drawable[]
-            {
-                marker = new HitCircleOverlapMarker(),
-                CirclePiece = new HitCirclePiece(),
-            };
+            if (position == SliderPosition.Start)
+                AddInternal(marker = new HitCircleOverlapMarker());
+
+            AddInternal(CirclePiece = new HitCirclePiece());
         }
 
         protected override void Update()
@@ -35,7 +33,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             var circle = position == SliderPosition.Start ? (HitCircle)slider.HeadCircle : slider.TailCircle;
 
             CirclePiece.UpdateFrom(circle);
-            marker.UpdateFrom(circle);
+            marker?.UpdateFrom(circle);
         }
 
         public override void Hide()
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
index 49fdf12d60..7ee6530099 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
@@ -14,6 +14,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Utils;
 using osu.Game.Audio;
+using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
@@ -59,6 +60,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         private readonly BindableList<PathControlPoint> controlPoints = new BindableList<PathControlPoint>();
         private readonly IBindable<int> pathVersion = new Bindable<int>();
         private readonly BindableList<HitObject> selectedObjects = new BindableList<HitObject>();
+        private readonly Bindable<bool> showHitMarkers = new Bindable<bool>();
 
         public SliderSelectionBlueprint(Slider slider)
             : base(slider)
@@ -66,7 +68,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OsuConfigManager config)
         {
             InternalChildren = new Drawable[]
             {
@@ -74,6 +76,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 HeadOverlay = CreateCircleOverlay(HitObject, SliderPosition.Start),
                 TailOverlay = CreateCircleOverlay(HitObject, SliderPosition.End),
             };
+
+            config.BindWith(OsuSetting.EditorShowHitMarkers, showHitMarkers);
         }
 
         protected override void LoadComplete()
@@ -90,6 +94,11 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             if (editorBeatmap != null)
                 selectedObjects.BindTo(editorBeatmap.SelectedHitObjects);
             selectedObjects.BindCollectionChanged((_, _) => updateVisualDefinition(), true);
+            showHitMarkers.BindValueChanged(_ =>
+            {
+                if (!showHitMarkers.Value)
+                    DrawableObject.RestoreHitAnimations();
+            });
         }
 
         public override bool HandleQuickDeletion()
@@ -110,6 +119,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
             if (IsSelected)
                 BodyPiece.UpdateFrom(HitObject);
+
+            if (showHitMarkers.Value)
+                DrawableObject.SuppressHitAnimations();
         }
 
         protected override bool OnHover(HoverEvent e)
diff --git a/osu.Game.Rulesets.Osu/Edit/DrawableOsuEditorRuleset.cs b/osu.Game.Rulesets.Osu/Edit/DrawableOsuEditorRuleset.cs
index 68c565af4d..4dd718597a 100644
--- a/osu.Game.Rulesets.Osu/Edit/DrawableOsuEditorRuleset.cs
+++ b/osu.Game.Rulesets.Osu/Edit/DrawableOsuEditorRuleset.cs
@@ -2,10 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit
@@ -23,12 +26,32 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private partial class OsuEditorPlayfield : OsuPlayfield
         {
+            [Resolved]
+            private EditorBeatmap editorBeatmap { get; set; } = null!;
+
             protected override GameplayCursorContainer? CreateCursor() => null;
 
             public OsuEditorPlayfield()
             {
                 HitPolicy = new AnyOrderHitPolicy();
             }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                editorBeatmap.BeatmapReprocessed += onBeatmapReprocessed;
+            }
+
+            private void onBeatmapReprocessed() => ApplyCircleSizeToPlayfieldBorder(editorBeatmap);
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                if (editorBeatmap.IsNotNull())
+                    editorBeatmap.BeatmapReprocessed -= onBeatmapReprocessed;
+            }
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
new file mode 100644
index 0000000000..21cce553b1
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
@@ -0,0 +1,171 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Input.Bindings;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Screens.Edit;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public partial class OsuGridToolboxGroup : EditorToolboxGroup, IKeyBindingHandler<GlobalAction>
+    {
+        [Resolved]
+        private EditorBeatmap editorBeatmap { get; set; } = null!;
+
+        /// <summary>
+        /// X position of the grid's origin.
+        /// </summary>
+        public BindableFloat StartPositionX { get; } = new BindableFloat(OsuPlayfield.BASE_SIZE.X / 2)
+        {
+            MinValue = 0f,
+            MaxValue = OsuPlayfield.BASE_SIZE.X,
+            Precision = 1f
+        };
+
+        /// <summary>
+        /// Y position of the grid's origin.
+        /// </summary>
+        public BindableFloat StartPositionY { get; } = new BindableFloat(OsuPlayfield.BASE_SIZE.Y / 2)
+        {
+            MinValue = 0f,
+            MaxValue = OsuPlayfield.BASE_SIZE.Y,
+            Precision = 1f
+        };
+
+        /// <summary>
+        /// The spacing between grid lines.
+        /// </summary>
+        public BindableFloat Spacing { get; } = new BindableFloat(4f)
+        {
+            MinValue = 4f,
+            MaxValue = 128f,
+            Precision = 1f
+        };
+
+        /// <summary>
+        /// Rotation of the grid lines in degrees.
+        /// </summary>
+        public BindableFloat GridLinesRotation { get; } = new BindableFloat(0f)
+        {
+            MinValue = -45f,
+            MaxValue = 45f,
+            Precision = 1f
+        };
+
+        /// <summary>
+        /// Read-only bindable representing the grid's origin.
+        /// Equivalent to <code>new Vector2(StartPositionX, StartPositionY)</code>
+        /// </summary>
+        public Bindable<Vector2> StartPosition { get; } = new Bindable<Vector2>();
+
+        /// <summary>
+        /// Read-only bindable representing the grid's spacing in both the X and Y dimension.
+        /// Equivalent to <code>new Vector2(Spacing)</code>
+        /// </summary>
+        public Bindable<Vector2> SpacingVector { get; } = new Bindable<Vector2>();
+
+        private ExpandableSlider<float> startPositionXSlider = null!;
+        private ExpandableSlider<float> startPositionYSlider = null!;
+        private ExpandableSlider<float> spacingSlider = null!;
+        private ExpandableSlider<float> gridLinesRotationSlider = null!;
+
+        public OsuGridToolboxGroup()
+            : base("grid")
+        {
+        }
+
+        private const float max_automatic_spacing = 64;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                startPositionXSlider = new ExpandableSlider<float>
+                {
+                    Current = StartPositionX,
+                    KeyboardStep = 1,
+                },
+                startPositionYSlider = new ExpandableSlider<float>
+                {
+                    Current = StartPositionY,
+                    KeyboardStep = 1,
+                },
+                spacingSlider = new ExpandableSlider<float>
+                {
+                    Current = Spacing,
+                    KeyboardStep = 1,
+                },
+                gridLinesRotationSlider = new ExpandableSlider<float>
+                {
+                    Current = GridLinesRotation,
+                    KeyboardStep = 1,
+                },
+            };
+
+            Spacing.Value = editorBeatmap.BeatmapInfo.GridSize;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            StartPositionX.BindValueChanged(x =>
+            {
+                startPositionXSlider.ContractedLabelText = $"X: {x.NewValue:N0}";
+                startPositionXSlider.ExpandedLabelText = $"X Offset: {x.NewValue:N0}";
+                StartPosition.Value = new Vector2(x.NewValue, StartPosition.Value.Y);
+            }, true);
+
+            StartPositionY.BindValueChanged(y =>
+            {
+                startPositionYSlider.ContractedLabelText = $"Y: {y.NewValue:N0}";
+                startPositionYSlider.ExpandedLabelText = $"Y Offset: {y.NewValue:N0}";
+                StartPosition.Value = new Vector2(StartPosition.Value.X, y.NewValue);
+            }, true);
+
+            Spacing.BindValueChanged(spacing =>
+            {
+                spacingSlider.ContractedLabelText = $"S: {spacing.NewValue:N0}";
+                spacingSlider.ExpandedLabelText = $"Spacing: {spacing.NewValue:N0}";
+                SpacingVector.Value = new Vector2(spacing.NewValue);
+                editorBeatmap.BeatmapInfo.GridSize = (int)spacing.NewValue;
+            }, true);
+
+            GridLinesRotation.BindValueChanged(rotation =>
+            {
+                gridLinesRotationSlider.ContractedLabelText = $"R: {rotation.NewValue:#,0.##}";
+                gridLinesRotationSlider.ExpandedLabelText = $"Rotation: {rotation.NewValue:#,0.##}";
+            }, true);
+        }
+
+        private void nextGridSize()
+        {
+            Spacing.Value = Spacing.Value * 2 >= max_automatic_spacing ? Spacing.Value / 8 : Spacing.Value * 2;
+        }
+
+        public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+        {
+            switch (e.Action)
+            {
+                case GlobalAction.EditorCycleGridDisplayMode:
+                    nextGridSize();
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+        {
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
index cc1d1fe89f..f93874481d 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
@@ -24,6 +24,7 @@ using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
@@ -50,6 +51,8 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private readonly Bindable<TernaryState> rectangularGridSnapToggle = new Bindable<TernaryState>();
 
+        protected override Drawable CreateHitObjectInspector() => new OsuHitObjectInspector();
+
         protected override IEnumerable<TernaryButton> CreateTernaryButtons()
             => base.CreateTernaryButtons()
                    .Concat(DistanceSnapProvider.CreateTernaryButtons())
@@ -65,6 +68,9 @@ namespace osu.Game.Rulesets.Osu.Edit
         [Cached(typeof(IDistanceSnapProvider))]
         protected readonly OsuDistanceSnapProvider DistanceSnapProvider = new OsuDistanceSnapProvider();
 
+        [Cached]
+        protected readonly OsuGridToolboxGroup OsuGridToolboxGroup = new OsuGridToolboxGroup();
+
         [Cached]
         protected readonly FreehandSliderToolboxGroup FreehandlSliderToolboxGroup = new FreehandSliderToolboxGroup();
 
@@ -80,10 +86,6 @@ namespace osu.Game.Rulesets.Osu.Edit
             LayerBelowRuleset.AddRange(new Drawable[]
             {
                 distanceSnapGridContainer = new Container
-                {
-                    RelativeSizeAxes = Axes.Both
-                },
-                rectangularPositionSnapGrid = new OsuRectangularPositionSnapGrid
                 {
                     RelativeSizeAxes = Axes.Both
                 }
@@ -99,8 +101,11 @@ namespace osu.Game.Rulesets.Osu.Edit
             // we may be entering the screen with a selection already active
             updateDistanceSnapGrid();
 
-            RightToolbox.AddRange(new EditorToolboxGroup[]
+            updatePositionSnapGrid();
+
+            RightToolbox.AddRange(new Drawable[]
                 {
+                    OsuGridToolboxGroup,
                     new TransformToolboxGroup
                     {
                         RotationHandler = BlueprintContainer.SelectionHandler.RotationHandler,
@@ -111,6 +116,23 @@ namespace osu.Game.Rulesets.Osu.Edit
             );
         }
 
+        private void updatePositionSnapGrid()
+        {
+            if (positionSnapGrid != null)
+                LayerBelowRuleset.Remove(positionSnapGrid, true);
+
+            var rectangularPositionSnapGrid = new RectangularPositionSnapGrid();
+
+            rectangularPositionSnapGrid.StartPosition.BindTo(OsuGridToolboxGroup.StartPosition);
+            rectangularPositionSnapGrid.Spacing.BindTo(OsuGridToolboxGroup.SpacingVector);
+            rectangularPositionSnapGrid.GridLineRotation.BindTo(OsuGridToolboxGroup.GridLinesRotation);
+
+            positionSnapGrid = rectangularPositionSnapGrid;
+
+            positionSnapGrid.RelativeSizeAxes = Axes.Both;
+            LayerBelowRuleset.Add(positionSnapGrid);
+        }
+
         protected override ComposeBlueprintContainer CreateBlueprintContainer()
             => new OsuBlueprintContainer(this);
 
@@ -151,7 +173,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         private readonly Cached distanceSnapGridCache = new Cached();
         private double? lastDistanceSnapGridTime;
 
-        private RectangularPositionSnapGrid rectangularPositionSnapGrid;
+        private PositionSnapGrid positionSnapGrid;
 
         protected override void Update()
         {
@@ -209,9 +231,13 @@ namespace osu.Game.Rulesets.Osu.Edit
             {
                 if (rectangularGridSnapToggle.Value == TernaryState.True)
                 {
-                    Vector2 pos = rectangularPositionSnapGrid.GetSnappedPosition(rectangularPositionSnapGrid.ToLocalSpace(result.ScreenSpacePosition));
+                    Vector2 pos = positionSnapGrid.GetSnappedPosition(positionSnapGrid.ToLocalSpace(result.ScreenSpacePosition));
 
-                    result.ScreenSpacePosition = rectangularPositionSnapGrid.ToScreenSpace(pos);
+                    // A grid which doesn't perfectly fit the playfield can produce a position that is outside of the playfield.
+                    // We need to clamp the position to the playfield bounds to ensure that the snapped position is always in bounds.
+                    pos = Vector2.Clamp(pos, Vector2.Zero, OsuPlayfield.BASE_SIZE);
+
+                    result.ScreenSpacePosition = positionSnapGrid.ToScreenSpace(pos);
                 }
             }
 
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectInspector.cs b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectInspector.cs
new file mode 100644
index 0000000000..27e7d5497c
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectInspector.cs
@@ -0,0 +1,42 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Diagnostics;
+using System.Linq;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Compose.Components;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public partial class OsuHitObjectInspector : HitObjectInspector
+    {
+        protected override void AddInspectorValues()
+        {
+            base.AddInspectorValues();
+
+            if (EditorBeatmap.SelectedHitObjects.Count > 0)
+            {
+                var firstInSelection = (OsuHitObject)EditorBeatmap.SelectedHitObjects.MinBy(ho => ho.StartTime)!;
+                var lastInSelection = (OsuHitObject)EditorBeatmap.SelectedHitObjects.MaxBy(ho => ho.GetEndTime())!;
+
+                Debug.Assert(firstInSelection != null && lastInSelection != null);
+
+                var precedingObject = (OsuHitObject?)EditorBeatmap.HitObjects.LastOrDefault(ho => ho.GetEndTime() < firstInSelection.StartTime);
+                var nextObject = (OsuHitObject?)EditorBeatmap.HitObjects.FirstOrDefault(ho => ho.StartTime > lastInSelection.GetEndTime());
+
+                if (precedingObject != null && precedingObject is not Spinner)
+                {
+                    AddHeader("To previous");
+                    AddValue($"{(firstInSelection.StackedPosition - precedingObject.StackedEndPosition).Length:#,0.##}px");
+                }
+
+                if (nextObject != null && nextObject is not Spinner)
+                {
+                    AddHeader("To next");
+                    AddValue($"{(nextObject.StackedPosition - lastInSelection.StackedEndPosition).Length:#,0.##}px");
+                }
+            }
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuRectangularPositionSnapGrid.cs b/osu.Game.Rulesets.Osu/Edit/OsuRectangularPositionSnapGrid.cs
deleted file mode 100644
index efc6668ebf..0000000000
--- a/osu.Game.Rulesets.Osu/Edit/OsuRectangularPositionSnapGrid.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Allocation;
-using osu.Framework.Input.Bindings;
-using osu.Framework.Input.Events;
-using osu.Game.Input.Bindings;
-using osu.Game.Rulesets.Osu.UI;
-using osu.Game.Screens.Edit;
-using osu.Game.Screens.Edit.Compose.Components;
-using osuTK;
-
-namespace osu.Game.Rulesets.Osu.Edit
-{
-    public partial class OsuRectangularPositionSnapGrid : RectangularPositionSnapGrid, IKeyBindingHandler<GlobalAction>
-    {
-        private static readonly int[] grid_sizes = { 4, 8, 16, 32 };
-
-        private int currentGridSizeIndex = grid_sizes.Length - 1;
-
-        [Resolved]
-        private EditorBeatmap editorBeatmap { get; set; } = null!;
-
-        public OsuRectangularPositionSnapGrid()
-            : base(OsuPlayfield.BASE_SIZE / 2)
-        {
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            int gridSizeIndex = Array.IndexOf(grid_sizes, editorBeatmap.BeatmapInfo.GridSize);
-            if (gridSizeIndex >= 0)
-                currentGridSizeIndex = gridSizeIndex;
-            updateSpacing();
-        }
-
-        private void nextGridSize()
-        {
-            currentGridSizeIndex = (currentGridSizeIndex + 1) % grid_sizes.Length;
-            updateSpacing();
-        }
-
-        private void updateSpacing()
-        {
-            int gridSize = grid_sizes[currentGridSizeIndex];
-
-            editorBeatmap.BeatmapInfo.GridSize = gridSize;
-            Spacing = new Vector2(gridSize);
-        }
-
-        public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
-        {
-            switch (e.Action)
-            {
-                case GlobalAction.EditorCycleGridDisplayMode:
-                    nextGridSize();
-                    return true;
-            }
-
-            return false;
-        }
-
-        public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
-        {
-        }
-    }
-}
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs
index 7624b2f27e..62a39d3702 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionRotationHandler.cs
@@ -53,9 +53,11 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         public override void Begin()
         {
-            if (objectsInRotation != null)
+            if (OperationInProgress.Value)
                 throw new InvalidOperationException($"Cannot {nameof(Begin)} a rotate operation while another is in progress!");
 
+            base.Begin();
+
             changeHandler?.BeginChange();
 
             objectsInRotation = selectedMovableObjects.ToArray();
@@ -68,10 +70,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         public override void Update(float rotation, Vector2? origin = null)
         {
-            if (objectsInRotation == null)
+            if (!OperationInProgress.Value)
                 throw new InvalidOperationException($"Cannot {nameof(Update)} a rotate operation without calling {nameof(Begin)} first!");
 
-            Debug.Assert(originalPositions != null && originalPathControlPointPositions != null && defaultOrigin != null);
+            Debug.Assert(objectsInRotation != null && originalPositions != null && originalPathControlPointPositions != null && defaultOrigin != null);
 
             Vector2 actualOrigin = origin ?? defaultOrigin.Value;
 
@@ -91,11 +93,13 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         public override void Commit()
         {
-            if (objectsInRotation == null)
+            if (!OperationInProgress.Value)
                 throw new InvalidOperationException($"Cannot {nameof(Commit)} a rotate operation without calling {nameof(Begin)} first!");
 
             changeHandler?.EndChange();
 
+            base.Commit();
+
             objectsInRotation = null;
             originalPositions = null;
             originalPathControlPointPositions = null;
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index de00aa6ad3..f4fd48f183 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -72,9 +72,11 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         public override void Begin()
         {
-            if (objectsInScale != null)
+            if (OperationInProgress.Value)
                 throw new InvalidOperationException($"Cannot {nameof(Begin)} a scale operation while another is in progress!");
 
+            base.Begin();
+
             changeHandler?.BeginChange();
 
             objectsInScale = selectedMovableObjects.ToDictionary(ho => ho, ho => new OriginalHitObjectState(ho));
@@ -86,10 +88,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
         {
-            if (objectsInScale == null)
+            if (!OperationInProgress.Value)
                 throw new InvalidOperationException($"Cannot {nameof(Update)} a scale operation without calling {nameof(Begin)} first!");
 
-            Debug.Assert(defaultOrigin != null && OriginalSurroundingQuad != null);
+            Debug.Assert(objectsInScale != null && defaultOrigin != null && OriginalSurroundingQuad != null);
 
             Vector2 actualOrigin = origin ?? defaultOrigin.Value;
 
@@ -117,11 +119,13 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         public override void Commit()
         {
-            if (objectsInScale == null)
+            if (!OperationInProgress.Value)
                 throw new InvalidOperationException($"Cannot {nameof(Commit)} a rotate operation without calling {nameof(Begin)} first!");
 
             changeHandler?.EndChange();
 
+            base.Commit();
+
             objectsInScale = null;
             OriginalSurroundingQuad = null;
             defaultOrigin = null;
diff --git a/osu.Game.Rulesets.Osu/Edit/Setup/OsuSetupSection.cs b/osu.Game.Rulesets.Osu/Edit/Setup/OsuSetupSection.cs
index ac567559b8..552b887081 100644
--- a/osu.Game.Rulesets.Osu/Edit/Setup/OsuSetupSection.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Setup/OsuSetupSection.cs
@@ -49,6 +49,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
         private void updateBeatmap()
         {
             Beatmap.BeatmapInfo.StackLeniency = stackLeniency.Current.Value;
+            Beatmap.UpdateAllHitObjects();
             Beatmap.SaveState();
         }
     }
diff --git a/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
index 28d0f8320f..a3547d45e5 100644
--- a/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
@@ -77,13 +77,15 @@ namespace osu.Game.Rulesets.Osu.Edit
             {
                 case GlobalAction.EditorToggleRotateControl:
                 {
-                    rotateButton.TriggerClick();
+                    if (!RotationHandler.OperationInProgress.Value || rotateButton.Selected.Value)
+                        rotateButton.TriggerClick();
                     return true;
                 }
 
                 case GlobalAction.EditorToggleScaleControl:
                 {
-                    scaleButton.TriggerClick();
+                    if (!ScaleHandler.OperationInProgress.Value || scaleButton.Selected.Value)
+                        scaleButton.TriggerClick();
                     return true;
                 }
             }
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs b/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
index 75ad00e169..9091837034 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
@@ -6,7 +6,9 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Skinning.Default;
 
@@ -23,6 +25,8 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles), typeof(OsuModDepth) };
 
+        protected override bool IsFirstAdjustableObject(HitObject hitObject) => !(hitObject is Spinner || hitObject is SpinnerTick);
+
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
         }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
index c3ce6acce9..101c34b725 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
@@ -9,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Framework.Utils;
 using osu.Game.Graphics.Containers;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -19,6 +20,7 @@ using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -319,5 +321,32 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             {
             }
         }
+
+        #region FOR EDITOR USE ONLY, DO NOT USE FOR ANY OTHER PURPOSE
+
+        internal void SuppressHitAnimations()
+        {
+            UpdateState(ArmedState.Idle);
+            UpdateComboColour();
+
+            // This method is called every frame in editor contexts, thus the lack of need for transforms.
+
+            if (Time.Current >= HitStateUpdateTime)
+            {
+                // More or less matches stable (see https://github.com/peppy/osu-stable-reference/blob/bb57924c1552adbed11ee3d96cdcde47cf96f2b6/osu!/GameplayElements/HitObjects/Osu/HitCircleOsu.cs#L336-L338)
+                AccentColour.Value = Color4.White;
+                Alpha = Interpolation.ValueAt(Time.Current, 1f, 0f, HitStateUpdateTime, HitStateUpdateTime + 700);
+            }
+
+            LifetimeEnd = HitStateUpdateTime + 700;
+        }
+
+        internal void RestoreHitAnimations()
+        {
+            UpdateState(ArmedState.Hit, force: true);
+            UpdateComboColour();
+        }
+
+        #endregion
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs
index 6e252a53e2..0630ecfbb5 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs
@@ -48,10 +48,20 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             if (!positionTransferred && JudgedObject is DrawableOsuHitObject osuObject && JudgedObject.IsInUse)
             {
-                Position = osuObject.ToSpaceOfOtherDrawable(osuObject.OriginPosition, Parent!);
-                Scale = new Vector2(osuObject.HitObject.Scale);
+                switch (osuObject)
+                {
+                    case DrawableSlider slider:
+                        Position = slider.TailCircle.ToSpaceOfOtherDrawable(slider.TailCircle.OriginPosition, Parent!);
+                        break;
+
+                    default:
+                        Position = osuObject.ToSpaceOfOtherDrawable(osuObject.OriginPosition, Parent!);
+                        break;
+                }
 
                 positionTransferred = true;
+
+                Scale = new Vector2(osuObject.HitObject.Scale);
             }
         }
 
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
index e519e51562..eacd2b3e75 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
@@ -370,5 +370,23 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         private partial class DefaultSliderBody : PlaySliderBody
         {
         }
+
+        #region FOR EDITOR USE ONLY, DO NOT USE FOR ANY OTHER PURPOSE
+
+        internal void SuppressHitAnimations()
+        {
+            UpdateState(ArmedState.Idle);
+            HeadCircle.SuppressHitAnimations();
+            TailCircle.SuppressHitAnimations();
+        }
+
+        internal void RestoreHitAnimations()
+        {
+            UpdateState(ArmedState.Hit);
+            HeadCircle.RestoreHitAnimations();
+            TailCircle.RestoreHitAnimations();
+        }
+
+        #endregion
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
index c4731118a1..8bb1b0aebc 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
@@ -8,10 +8,12 @@ using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Utils;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Skinning;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -125,5 +127,32 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (Slider != null)
                 Position = Slider.CurvePositionAt(HitObject.RepeatIndex % 2 == 0 ? 1 : 0);
         }
+
+        #region FOR EDITOR USE ONLY, DO NOT USE FOR ANY OTHER PURPOSE
+
+        internal void SuppressHitAnimations()
+        {
+            UpdateState(ArmedState.Idle);
+            UpdateComboColour();
+
+            // This method is called every frame in editor contexts, thus the lack of need for transforms.
+
+            if (Time.Current >= HitStateUpdateTime)
+            {
+                // More or less matches stable (see https://github.com/peppy/osu-stable-reference/blob/bb57924c1552adbed11ee3d96cdcde47cf96f2b6/osu!/GameplayElements/HitObjects/Osu/HitCircleOsu.cs#L336-L338)
+                AccentColour.Value = Color4.White;
+                Alpha = Interpolation.ValueAt(Time.Current, 1f, 0f, HitStateUpdateTime, HitStateUpdateTime + 700);
+            }
+
+            LifetimeEnd = HitStateUpdateTime + 700;
+        }
+
+        internal void RestoreHitAnimations()
+        {
+            UpdateState(ArmedState.Hit);
+            UpdateComboColour();
+        }
+
+        #endregion
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/Slider.cs b/osu.Game.Rulesets.Osu/Objects/Slider.cs
index cc3ffd376e..f542b7b5af 100644
--- a/osu.Game.Rulesets.Osu/Objects/Slider.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Slider.cs
@@ -252,6 +252,8 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         protected void UpdateNestedSamples()
         {
+            this.PopulateNodeSamples();
+
             // TODO: remove this when guaranteed sort is present for samples (https://github.com/ppy/osu/issues/1933)
             HitSampleInfo tickSample = (Samples.FirstOrDefault(s => s.Name == HitSampleInfo.HIT_NORMAL) ?? Samples.FirstOrDefault())?.With("slidertick");
 
diff --git a/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs b/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
index 93c3450904..df7f279656 100644
--- a/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
+++ b/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
@@ -8,10 +8,12 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Configuration;
 using osu.Game.Rulesets.Osu.Objects;
@@ -27,6 +29,7 @@ namespace osu.Game.Rulesets.Osu.UI
     [Cached]
     public partial class OsuPlayfield : Playfield
     {
+        private readonly Container borderContainer;
         private readonly PlayfieldBorder playfieldBorder;
         private readonly ProxyContainer approachCircles;
         private readonly ProxyContainer spinnerProxies;
@@ -45,6 +48,8 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override GameplayCursorContainer? CreateCursor() => new OsuCursorContainer();
 
+        public override Quad SkinnableComponentScreenSpaceDrawQuad => playfieldBorder.ScreenSpaceDrawQuad;
+
         private readonly Container judgementAboveHitObjectLayer;
 
         public OsuPlayfield()
@@ -54,7 +59,11 @@ namespace osu.Game.Rulesets.Osu.UI
 
             InternalChildren = new Drawable[]
             {
-                playfieldBorder = new PlayfieldBorder { RelativeSizeAxes = Axes.Both },
+                borderContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = playfieldBorder = new PlayfieldBorder { RelativeSizeAxes = Axes.Both },
+                },
                 Smoke = new SmokeContainer { RelativeSizeAxes = Axes.Both },
                 spinnerProxies = new ProxyContainer { RelativeSizeAxes = Axes.Both },
                 FollowPoints = new FollowPointRenderer { RelativeSizeAxes = Axes.Both },
@@ -151,6 +160,14 @@ namespace osu.Game.Rulesets.Osu.UI
             RegisterPool<Spinner, DrawableSpinner>(2, 20);
             RegisterPool<SpinnerTick, DrawableSpinnerTick>(10, 200);
             RegisterPool<SpinnerBonusTick, DrawableSpinnerBonusTick>(10, 200);
+
+            if (beatmap != null)
+                ApplyCircleSizeToPlayfieldBorder(beatmap);
+        }
+
+        protected void ApplyCircleSizeToPlayfieldBorder(IBeatmap beatmap)
+        {
+            borderContainer.Padding = new MarginPadding(OsuHitObject.OBJECT_RADIUS * -LegacyRulesetExtensions.CalculateScaleFromCircleSize(beatmap.Difficulty.CircleSize, true));
         }
 
         protected override HitObjectLifetimeEntry CreateLifetimeEntry(HitObject hitObject) => new OsuHitObjectLifetimeEntry(hitObject);
diff --git a/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneSwellJudgements.cs b/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneSwellJudgements.cs
index 6e42ae7eb5..04661fe2cf 100644
--- a/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneSwellJudgements.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Judgements/TestSceneSwellJudgements.cs
@@ -85,6 +85,42 @@ namespace osu.Game.Rulesets.Taiko.Tests.Judgements
             AssertResult<Swell>(0, HitResult.IgnoreMiss);
         }
 
+        [Test]
+        public void TestAlternatingIsRequired()
+        {
+            const double hit_time = 1000;
+
+            Swell swell = new Swell
+            {
+                StartTime = hit_time,
+                Duration = 1000,
+                RequiredHits = 10
+            };
+
+            List<ReplayFrame> frames = new List<ReplayFrame>
+            {
+                new TaikoReplayFrame(0),
+                new TaikoReplayFrame(2001),
+            };
+
+            for (int i = 0; i < swell.RequiredHits; i++)
+            {
+                double frameTime = 1000 + i * 50;
+                frames.Add(new TaikoReplayFrame(frameTime, TaikoAction.LeftCentre));
+                frames.Add(new TaikoReplayFrame(frameTime + 10));
+            }
+
+            PerformTest(frames, CreateBeatmap(swell));
+
+            AssertJudgementCount(11);
+
+            AssertResult<SwellTick>(0, HitResult.IgnoreHit);
+            for (int i = 1; i < swell.RequiredHits; i++)
+                AssertResult<SwellTick>(i, HitResult.IgnoreMiss);
+
+            AssertResult<Swell>(0, HitResult.IgnoreMiss);
+        }
+
         [Test]
         public void TestHitNoneSwell()
         {
diff --git a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModRelax.cs b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModRelax.cs
new file mode 100644
index 0000000000..caf8aa8e76
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModRelax.cs
@@ -0,0 +1,46 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Rulesets.Taiko.Mods;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Mods
+{
+    public partial class TestSceneTaikoModRelax : TaikoModTestScene
+    {
+        [Test]
+        public void TestRelax()
+        {
+            var beatmap = new TaikoBeatmap
+            {
+                HitObjects =
+                {
+                    new Hit { StartTime = 0, Type = HitType.Centre, },
+                    new Hit { StartTime = 250, Type = HitType.Rim, },
+                    new DrumRoll { StartTime = 500, Duration = 500, },
+                    new Swell { StartTime = 1250, Duration = 500 },
+                }
+            };
+            foreach (var ho in beatmap.HitObjects)
+                ho.ApplyDefaults(beatmap.ControlPointInfo, beatmap.Difficulty);
+
+            var replay = new TaikoAutoGenerator(beatmap).Generate();
+
+            foreach (var frame in replay.Frames.OfType<TaikoReplayFrame>().Where(r => r.Actions.Any()))
+                frame.Actions = [TaikoAction.LeftCentre];
+
+            CreateModTest(new ModTestData
+            {
+                Mod = new TaikoModRelax(),
+                Beatmap = beatmap,
+                ReplayFrames = replay.Frames,
+                Autoplay = false,
+                PassCondition = () => Player.ScoreProcessor.HasCompleted.Value && Player.ScoreProcessor.Accuracy.Value == 1,
+            });
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModSingleTap.cs b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModSingleTap.cs
index 0cd3b85f8e..3a11a91f82 100644
--- a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModSingleTap.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModSingleTap.cs
@@ -177,7 +177,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Mods
             Autoplay = false,
             Beatmap = new Beatmap
             {
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(100, 1600),
                 },
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Skills/Peaks.cs b/osu.Game.Rulesets.Taiko/Difficulty/Skills/Peaks.cs
deleted file mode 100644
index 91d8e93543..0000000000
--- a/osu.Game.Rulesets.Taiko/Difficulty/Skills/Peaks.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using osu.Game.Rulesets.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Difficulty.Skills;
-using osu.Game.Rulesets.Mods;
-
-namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
-{
-    public class Peaks : Skill
-    {
-        private const double rhythm_skill_multiplier = 0.2 * final_multiplier;
-        private const double colour_skill_multiplier = 0.375 * final_multiplier;
-        private const double stamina_skill_multiplier = 0.375 * final_multiplier;
-
-        private const double final_multiplier = 0.0625;
-
-        private readonly Rhythm rhythm;
-        private readonly Colour colour;
-        private readonly Stamina stamina;
-
-        public double ColourDifficultyValue => colour.DifficultyValue() * colour_skill_multiplier;
-        public double RhythmDifficultyValue => rhythm.DifficultyValue() * rhythm_skill_multiplier;
-        public double StaminaDifficultyValue => stamina.DifficultyValue() * stamina_skill_multiplier;
-
-        public Peaks(Mod[] mods)
-            : base(mods)
-        {
-            rhythm = new Rhythm(mods);
-            colour = new Colour(mods);
-            stamina = new Stamina(mods);
-        }
-
-        /// <summary>
-        /// Returns the <i>p</i>-norm of an <i>n</i>-dimensional vector.
-        /// </summary>
-        /// <param name="p">The value of <i>p</i> to calculate the norm for.</param>
-        /// <param name="values">The coefficients of the vector.</param>
-        private double norm(double p, params double[] values) => Math.Pow(values.Sum(x => Math.Pow(x, p)), 1 / p);
-
-        public override void Process(DifficultyHitObject current)
-        {
-            rhythm.Process(current);
-            colour.Process(current);
-            stamina.Process(current);
-        }
-
-        /// <summary>
-        /// Returns the combined star rating of the beatmap, calculated using peak strains from all sections of the map.
-        /// </summary>
-        /// <remarks>
-        /// For each section, the peak strains of all separate skills are combined into a single peak strain for the section.
-        /// The resulting partial rating of the beatmap is a weighted sum of the combined peaks (higher peaks are weighted more).
-        /// </remarks>
-        public override double DifficultyValue()
-        {
-            List<double> peaks = new List<double>();
-
-            var colourPeaks = colour.GetCurrentStrainPeaks().ToList();
-            var rhythmPeaks = rhythm.GetCurrentStrainPeaks().ToList();
-            var staminaPeaks = stamina.GetCurrentStrainPeaks().ToList();
-
-            for (int i = 0; i < colourPeaks.Count; i++)
-            {
-                double colourPeak = colourPeaks[i] * colour_skill_multiplier;
-                double rhythmPeak = rhythmPeaks[i] * rhythm_skill_multiplier;
-                double staminaPeak = staminaPeaks[i] * stamina_skill_multiplier;
-
-                double peak = norm(1.5, colourPeak, staminaPeak);
-                peak = norm(2, peak, rhythmPeak);
-
-                // Sections with 0 strain are excluded to avoid worst-case time complexity of the following sort (e.g. /b/2351871).
-                // These sections will not contribute to the difficulty.
-                if (peak > 0)
-                    peaks.Add(peak);
-            }
-
-            double difficulty = 0;
-            double weight = 1;
-
-            foreach (double strain in peaks.OrderDescending())
-            {
-                difficulty += strain * weight;
-                weight *= 0.9;
-            }
-
-            return difficulty;
-        }
-    }
-}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
index b84c2d25ee..9b746d47ea 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
@@ -23,6 +23,11 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
     {
         private const double difficulty_multiplier = 1.35;
 
+        private const double final_multiplier = 0.0625;
+        private const double rhythm_skill_multiplier = 0.2 * final_multiplier;
+        private const double colour_skill_multiplier = 0.375 * final_multiplier;
+        private const double stamina_skill_multiplier = 0.375 * final_multiplier;
+
         public override int Version => 20221107;
 
         public TaikoDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
@@ -34,7 +39,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         {
             return new Skill[]
             {
-                new Peaks(mods)
+                new Rhythm(mods),
+                new Colour(mods),
+                new Stamina(mods)
             };
         }
 
@@ -72,13 +79,15 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             if (beatmap.HitObjects.Count == 0)
                 return new TaikoDifficultyAttributes { Mods = mods };
 
-            var combined = (Peaks)skills[0];
+            Colour colour = (Colour)skills.First(x => x is Colour);
+            Rhythm rhythm = (Rhythm)skills.First(x => x is Rhythm);
+            Stamina stamina = (Stamina)skills.First(x => x is Stamina);
 
-            double colourRating = combined.ColourDifficultyValue * difficulty_multiplier;
-            double rhythmRating = combined.RhythmDifficultyValue * difficulty_multiplier;
-            double staminaRating = combined.StaminaDifficultyValue * difficulty_multiplier;
+            double colourRating = colour.DifficultyValue() * colour_skill_multiplier * difficulty_multiplier;
+            double rhythmRating = rhythm.DifficultyValue() * rhythm_skill_multiplier * difficulty_multiplier;
+            double staminaRating = stamina.DifficultyValue() * stamina_skill_multiplier * difficulty_multiplier;
 
-            double combinedRating = combined.DifficultyValue() * difficulty_multiplier;
+            double combinedRating = combinedDifficultyValue(rhythm, colour, stamina) * difficulty_multiplier;
             double starRating = rescale(combinedRating * 1.4);
 
             HitWindows hitWindows = new TaikoHitWindows();
@@ -109,5 +118,54 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
             return 10.43 * Math.Log(sr / 8 + 1);
         }
+
+        /// <summary>
+        /// Returns the combined star rating of the beatmap, calculated using peak strains from all sections of the map.
+        /// </summary>
+        /// <remarks>
+        /// For each section, the peak strains of all separate skills are combined into a single peak strain for the section.
+        /// The resulting partial rating of the beatmap is a weighted sum of the combined peaks (higher peaks are weighted more).
+        /// </remarks>
+        private double combinedDifficultyValue(Rhythm rhythm, Colour colour, Stamina stamina)
+        {
+            List<double> peaks = new List<double>();
+
+            var colourPeaks = colour.GetCurrentStrainPeaks().ToList();
+            var rhythmPeaks = rhythm.GetCurrentStrainPeaks().ToList();
+            var staminaPeaks = stamina.GetCurrentStrainPeaks().ToList();
+
+            for (int i = 0; i < colourPeaks.Count; i++)
+            {
+                double colourPeak = colourPeaks[i] * colour_skill_multiplier;
+                double rhythmPeak = rhythmPeaks[i] * rhythm_skill_multiplier;
+                double staminaPeak = staminaPeaks[i] * stamina_skill_multiplier;
+
+                double peak = norm(1.5, colourPeak, staminaPeak);
+                peak = norm(2, peak, rhythmPeak);
+
+                // Sections with 0 strain are excluded to avoid worst-case time complexity of the following sort (e.g. /b/2351871).
+                // These sections will not contribute to the difficulty.
+                if (peak > 0)
+                    peaks.Add(peak);
+            }
+
+            double difficulty = 0;
+            double weight = 1;
+
+            foreach (double strain in peaks.OrderDescending())
+            {
+                difficulty += strain * weight;
+                weight *= 0.9;
+            }
+
+            return difficulty;
+        }
+
+        /// <summary>
+        /// Returns the <i>p</i>-norm of an <i>n</i>-dimensional vector.
+        /// </summary>
+        /// <param name="p">The value of <i>p</i> to calculate the norm for.</param>
+        /// <param name="values">The coefficients of the vector.</param>
+        private double norm(double p, params double[] values) => Math.Pow(values.Sum(x => Math.Pow(x, p)), 1 / p);
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModRelax.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModRelax.cs
index e90ab589fc..ed09a85ebb 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModRelax.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModRelax.cs
@@ -5,13 +5,34 @@ using System;
 using System.Linq;
 using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Taiko.Mods
 {
-    public class TaikoModRelax : ModRelax
+    public class TaikoModRelax : ModRelax, IApplicableToDrawableHitObject
     {
-        public override LocalisableString Description => @"No ninja-like spinners, demanding drumrolls or unexpected katus.";
+        public override LocalisableString Description => @"No need to remember which key is correct anymore!";
 
         public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(TaikoModSingleTap) }).ToArray();
+
+        public void ApplyToDrawableHitObject(DrawableHitObject drawable)
+        {
+            var allActions = Enum.GetValues<TaikoAction>();
+
+            drawable.HitObjectApplied += dho =>
+            {
+                switch (dho)
+                {
+                    case DrawableHit hit:
+                        hit.HitActions = allActions;
+                        break;
+
+                    case DrawableSwell swell:
+                        swell.MustAlternate = false;
+                        break;
+                }
+            };
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs
index 4fb69056da..a5e63c373f 100644
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableHit.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         /// <summary>
         /// A list of keys which can result in hits for this HitObject.
         /// </summary>
-        public TaikoAction[] HitActions { get; private set; }
+        public TaikoAction[] HitActions { get; internal set; }
 
         /// <summary>
         /// The action that caused this <see cref="DrawableHit"/> to be hit.
diff --git a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs
index e1fc28fe16..f2fcd185dd 100644
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs
@@ -43,6 +43,11 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         public override bool DisplayResult => false;
 
+        /// <summary>
+        /// Whether the player must alternate centre and rim hits.
+        /// </summary>
+        public bool MustAlternate { get; internal set; } = true;
+
         public DrawableSwell()
             : this(null)
         {
@@ -292,7 +297,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             bool isCentre = e.Action == TaikoAction.LeftCentre || e.Action == TaikoAction.RightCentre;
 
             // Ensure alternating centre and rim hits
-            if (lastWasCentre == isCentre)
+            if (lastWasCentre == isCentre && MustAlternate)
                 return false;
 
             // If we've already successfully judged a tick this frame, do not judge more.
diff --git a/osu.Game.Tests/Editing/Checks/CheckBreaksTest.cs b/osu.Game.Tests/Editing/Checks/CheckBreaksTest.cs
index 28556566ba..f53dd9a62a 100644
--- a/osu.Game.Tests/Editing/Checks/CheckBreaksTest.cs
+++ b/osu.Game.Tests/Editing/Checks/CheckBreaksTest.cs
@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Game.Beatmaps;
@@ -29,7 +28,7 @@ namespace osu.Game.Tests.Editing.Checks
         {
             var beatmap = new Beatmap<HitObject>
             {
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(0, 649)
                 }
@@ -52,7 +51,7 @@ namespace osu.Game.Tests.Editing.Checks
                     new HitCircle { StartTime = 0 },
                     new HitCircle { StartTime = 1_200 }
                 },
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(100, 751)
                 }
@@ -75,7 +74,7 @@ namespace osu.Game.Tests.Editing.Checks
                     new HitCircle { StartTime = 0 },
                     new HitCircle { StartTime = 1_298 }
                 },
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(200, 850)
                 }
@@ -98,7 +97,7 @@ namespace osu.Game.Tests.Editing.Checks
                     new HitCircle { StartTime = 0 },
                     new HitCircle { StartTime = 1200 }
                 },
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(1398, 2300)
                 }
@@ -121,7 +120,7 @@ namespace osu.Game.Tests.Editing.Checks
                     new HitCircle { StartTime = 1100 },
                     new HitCircle { StartTime = 1500 }
                 },
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(0, 652)
                 }
@@ -145,7 +144,7 @@ namespace osu.Game.Tests.Editing.Checks
                     new HitCircle { StartTime = 1_297 },
                     new HitCircle { StartTime = 1_298 }
                 },
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(200, 850)
                 }
@@ -168,7 +167,7 @@ namespace osu.Game.Tests.Editing.Checks
                     new HitCircle { StartTime = 0 },
                     new HitCircle { StartTime = 1_300 }
                 },
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(200, 850)
                 }
diff --git a/osu.Game.Tests/Editing/Checks/CheckDrainLengthTest.cs b/osu.Game.Tests/Editing/Checks/CheckDrainLengthTest.cs
index 1b5c5c398f..be9aa711cb 100644
--- a/osu.Game.Tests/Editing/Checks/CheckDrainLengthTest.cs
+++ b/osu.Game.Tests/Editing/Checks/CheckDrainLengthTest.cs
@@ -53,7 +53,7 @@ namespace osu.Game.Tests.Editing.Checks
                     new HitCircle { StartTime = 0 },
                     new HitCircle { StartTime = 40_000 }
                 },
-                Breaks = new List<BreakPeriod>
+                Breaks =
                 {
                     new BreakPeriod(10_000, 21_000)
                 }
diff --git a/osu.Game.Tests/Editing/TestSceneEditorBeatmapProcessor.cs b/osu.Game.Tests/Editing/TestSceneEditorBeatmapProcessor.cs
new file mode 100644
index 0000000000..1a3f0aa3df
--- /dev/null
+++ b/osu.Game.Tests/Editing/TestSceneEditorBeatmapProcessor.cs
@@ -0,0 +1,476 @@
+// Copyright (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.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit;
+
+namespace osu.Game.Tests.Editing
+{
+    [TestFixture]
+    public class TestSceneEditorBeatmapProcessor
+    {
+        [Test]
+        public void TestEmptyBeatmap()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Is.Empty);
+        }
+
+        [Test]
+        public void TestSingleObjectBeatmap()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Is.Empty);
+        }
+
+        [Test]
+        public void TestTwoObjectsCloseTogether()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 2000 },
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Is.Empty);
+        }
+
+        [Test]
+        public void TestHoldNote()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HoldNote { StartTime = 1000, Duration = 10000 },
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new ManiaRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Has.Count.EqualTo(0));
+        }
+
+        [Test]
+        public void TestHoldNoteWithOverlappingNote()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HoldNote { StartTime = 1000, Duration = 10000 },
+                    new Note { StartTime = 2000 },
+                    new Note { StartTime = 12000 },
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new ManiaRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Has.Count.EqualTo(0));
+        }
+
+        [Test]
+        public void TestTwoObjectsFarApart()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 5000 },
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(beatmap.Breaks, Has.Count.EqualTo(1));
+                Assert.That(beatmap.Breaks[0].StartTime, Is.EqualTo(1200));
+                Assert.That(beatmap.Breaks[0].EndTime, Is.EqualTo(4000));
+            });
+        }
+
+        [Test]
+        public void TestBreaksAreFused()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 9000 },
+                },
+                Breaks =
+                {
+                    new BreakPeriod(1200, 4000),
+                    new BreakPeriod(5200, 8000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(beatmap.Breaks, Has.Count.EqualTo(1));
+                Assert.That(beatmap.Breaks[0].StartTime, Is.EqualTo(1200));
+                Assert.That(beatmap.Breaks[0].EndTime, Is.EqualTo(8000));
+            });
+        }
+
+        [Test]
+        public void TestBreaksAreSplit()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 5000 },
+                    new HitCircle { StartTime = 9000 },
+                },
+                Breaks =
+                {
+                    new BreakPeriod(1200, 8000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(beatmap.Breaks, Has.Count.EqualTo(2));
+                Assert.That(beatmap.Breaks[0].StartTime, Is.EqualTo(1200));
+                Assert.That(beatmap.Breaks[0].EndTime, Is.EqualTo(4000));
+                Assert.That(beatmap.Breaks[1].StartTime, Is.EqualTo(5200));
+                Assert.That(beatmap.Breaks[1].EndTime, Is.EqualTo(8000));
+            });
+        }
+
+        [Test]
+        public void TestBreaksAreNudged()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1100 },
+                    new HitCircle { StartTime = 9000 },
+                },
+                Breaks =
+                {
+                    new BreakPeriod(1200, 8000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(beatmap.Breaks, Has.Count.EqualTo(1));
+                Assert.That(beatmap.Breaks[0].StartTime, Is.EqualTo(1300));
+                Assert.That(beatmap.Breaks[0].EndTime, Is.EqualTo(8000));
+            });
+        }
+
+        [Test]
+        public void TestManualBreaksAreNotFused()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 9000 },
+                },
+                Breaks =
+                {
+                    new ManualBreakPeriod(1200, 4000),
+                    new ManualBreakPeriod(5200, 8000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(beatmap.Breaks, Has.Count.EqualTo(2));
+                Assert.That(beatmap.Breaks[0].StartTime, Is.EqualTo(1200));
+                Assert.That(beatmap.Breaks[0].EndTime, Is.EqualTo(4000));
+                Assert.That(beatmap.Breaks[1].StartTime, Is.EqualTo(5200));
+                Assert.That(beatmap.Breaks[1].EndTime, Is.EqualTo(8000));
+            });
+        }
+
+        [Test]
+        public void TestManualBreaksAreSplit()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 5000 },
+                    new HitCircle { StartTime = 9000 },
+                },
+                Breaks =
+                {
+                    new ManualBreakPeriod(1200, 8000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(beatmap.Breaks, Has.Count.EqualTo(2));
+                Assert.That(beatmap.Breaks[0].StartTime, Is.EqualTo(1200));
+                Assert.That(beatmap.Breaks[0].EndTime, Is.EqualTo(4000));
+                Assert.That(beatmap.Breaks[1].StartTime, Is.EqualTo(5200));
+                Assert.That(beatmap.Breaks[1].EndTime, Is.EqualTo(8000));
+            });
+        }
+
+        [Test]
+        public void TestManualBreaksAreNotNudged()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 9000 },
+                },
+                Breaks =
+                {
+                    new ManualBreakPeriod(1200, 8800),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(beatmap.Breaks, Has.Count.EqualTo(1));
+                Assert.That(beatmap.Breaks[0].StartTime, Is.EqualTo(1200));
+                Assert.That(beatmap.Breaks[0].EndTime, Is.EqualTo(8800));
+            });
+        }
+
+        [Test]
+        public void TestBreaksAtEndOfBeatmapAreRemoved()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 2000 },
+                },
+                Breaks =
+                {
+                    new BreakPeriod(10000, 15000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Is.Empty);
+        }
+
+        [Test]
+        public void TestManualBreaksAtEndOfBeatmapAreRemoved()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 1000 },
+                    new HitCircle { StartTime = 2000 },
+                },
+                Breaks =
+                {
+                    new ManualBreakPeriod(10000, 15000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Is.Empty);
+        }
+
+        [Test]
+        public void TestManualBreaksAtEndOfBeatmapAreRemovedCorrectlyEvenWithConcurrentObjects()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HoldNote { StartTime = 1000, EndTime = 20000 },
+                    new HoldNote { StartTime = 2000, EndTime = 3000 },
+                },
+                Breaks =
+                {
+                    new ManualBreakPeriod(10000, 15000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Is.Empty);
+        }
+
+        [Test]
+        public void TestBreaksAtStartOfBeatmapAreRemoved()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 10000 },
+                    new HitCircle { StartTime = 11000 },
+                },
+                Breaks =
+                {
+                    new BreakPeriod(0, 9000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Is.Empty);
+        }
+
+        [Test]
+        public void TestManualBreaksAtStartOfBeatmapAreRemoved()
+        {
+            var controlPoints = new ControlPointInfo();
+            controlPoints.Add(0, new TimingControlPoint { BeatLength = 500 });
+            var beatmap = new Beatmap
+            {
+                ControlPointInfo = controlPoints,
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 10000 },
+                    new HitCircle { StartTime = 11000 },
+                },
+                Breaks =
+                {
+                    new ManualBreakPeriod(0, 9000),
+                }
+            };
+
+            var beatmapProcessor = new EditorBeatmapProcessor(beatmap, new OsuRuleset());
+            beatmapProcessor.PreProcess();
+            beatmapProcessor.PostProcess();
+
+            Assert.That(beatmap.Breaks, Is.Empty);
+        }
+    }
+}
diff --git a/osu.Game.Tests/NonVisual/TestSceneTimedDifficultyCalculation.cs b/osu.Game.Tests/NonVisual/TestSceneTimedDifficultyCalculation.cs
index 1a75f735ef..f860cd097a 100644
--- a/osu.Game.Tests/NonVisual/TestSceneTimedDifficultyCalculation.cs
+++ b/osu.Game.Tests/NonVisual/TestSceneTimedDifficultyCalculation.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Tests.NonVisual
     public class TestSceneTimedDifficultyCalculation
     {
         [Test]
-        public void TestAttributesGeneratedForAllNonSkippedObjects()
+        public void TestAttributesGeneratedForEachObjectOnce()
         {
             var beatmap = new Beatmap<TestHitObject>
             {
@@ -40,15 +40,14 @@ namespace osu.Game.Tests.NonVisual
 
             List<TimedDifficultyAttributes> attribs = new TestDifficultyCalculator(new TestWorkingBeatmap(beatmap)).CalculateTimed();
 
-            Assert.That(attribs.Count, Is.EqualTo(4));
+            Assert.That(attribs.Count, Is.EqualTo(3));
             assertEquals(attribs[0], beatmap.HitObjects[0]);
             assertEquals(attribs[1], beatmap.HitObjects[0], beatmap.HitObjects[1]);
-            assertEquals(attribs[2], beatmap.HitObjects[0], beatmap.HitObjects[1]); // From the nested object.
-            assertEquals(attribs[3], beatmap.HitObjects[0], beatmap.HitObjects[1], beatmap.HitObjects[2]);
+            assertEquals(attribs[2], beatmap.HitObjects[0], beatmap.HitObjects[1], beatmap.HitObjects[2]);
         }
 
         [Test]
-        public void TestAttributesNotGeneratedForSkippedObjects()
+        public void TestAttributesGeneratedForSkippedObjects()
         {
             var beatmap = new Beatmap<TestHitObject>
             {
@@ -72,35 +71,14 @@ namespace osu.Game.Tests.NonVisual
 
             List<TimedDifficultyAttributes> attribs = new TestDifficultyCalculator(new TestWorkingBeatmap(beatmap)).CalculateTimed();
 
-            Assert.That(attribs.Count, Is.EqualTo(1));
-            assertEquals(attribs[0], beatmap.HitObjects[0], beatmap.HitObjects[1], beatmap.HitObjects[2]);
-        }
-
-        [Test]
-        public void TestNestedObjectOnlyAddsParentOnce()
-        {
-            var beatmap = new Beatmap<TestHitObject>
-            {
-                HitObjects =
-                {
-                    new TestHitObject
-                    {
-                        StartTime = 1,
-                        Skip = true,
-                        Nested = 2
-                    },
-                }
-            };
-
-            List<TimedDifficultyAttributes> attribs = new TestDifficultyCalculator(new TestWorkingBeatmap(beatmap)).CalculateTimed();
-
-            Assert.That(attribs.Count, Is.EqualTo(2));
+            Assert.That(attribs.Count, Is.EqualTo(3));
             assertEquals(attribs[0], beatmap.HitObjects[0]);
-            assertEquals(attribs[1], beatmap.HitObjects[0]);
+            assertEquals(attribs[1], beatmap.HitObjects[0], beatmap.HitObjects[1]);
+            assertEquals(attribs[2], beatmap.HitObjects[0], beatmap.HitObjects[1], beatmap.HitObjects[2]);
         }
 
         [Test]
-        public void TestSkippedLastObjectAddedInLastIteration()
+        public void TestAttributesGeneratedOnceForSkippedObjects()
         {
             var beatmap = new Beatmap<TestHitObject>
             {
@@ -110,6 +88,7 @@ namespace osu.Game.Tests.NonVisual
                     new TestHitObject
                     {
                         StartTime = 2,
+                        Nested = 5,
                         Skip = true
                     },
                     new TestHitObject
@@ -122,8 +101,10 @@ namespace osu.Game.Tests.NonVisual
 
             List<TimedDifficultyAttributes> attribs = new TestDifficultyCalculator(new TestWorkingBeatmap(beatmap)).CalculateTimed();
 
-            Assert.That(attribs.Count, Is.EqualTo(1));
-            assertEquals(attribs[0], beatmap.HitObjects[0], beatmap.HitObjects[1], beatmap.HitObjects[2]);
+            Assert.That(attribs.Count, Is.EqualTo(3));
+            assertEquals(attribs[0], beatmap.HitObjects[0]);
+            assertEquals(attribs[1], beatmap.HitObjects[0], beatmap.HitObjects[1]);
+            assertEquals(attribs[2], beatmap.HitObjects[0], beatmap.HitObjects[1], beatmap.HitObjects[2]);
         }
 
         private void assertEquals(TimedDifficultyAttributes attribs, params HitObject[] expected)
diff --git a/osu.Game.Tests/Resources/Archives/modified-classic-20230809.osk b/osu.Game.Tests/Resources/Archives/modified-classic-20230809.osk
new file mode 100644
index 0000000000..b200ab1261
Binary files /dev/null and b/osu.Game.Tests/Resources/Archives/modified-classic-20230809.osk differ
diff --git a/osu.Game.Tests/Resources/Archives/modified-default-20230809.osk b/osu.Game.Tests/Resources/Archives/modified-default-20230809.osk
new file mode 100644
index 0000000000..a46c20d2b8
Binary files /dev/null and b/osu.Game.Tests/Resources/Archives/modified-default-20230809.osk differ
diff --git a/osu.Game.Tests/Skins/SkinDeserialisationTest.cs b/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
index d979bdab93..f2547b4f5d 100644
--- a/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
+++ b/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
@@ -62,6 +62,10 @@ namespace osu.Game.Tests.Skins
             "Archives/modified-argon-20231108.osk",
             // Covers "Argon" performance points counter
             "Archives/modified-argon-20240305.osk",
+            // Covers default rank display
+            "Archives/modified-default-20230809.osk",
+            // Covers legacy rank display
+            "Archives/modified-classic-20230809.osk"
         };
 
         /// <summary>
diff --git a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs
new file mode 100644
index 0000000000..cd09a1d20f
--- /dev/null
+++ b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs
@@ -0,0 +1,40 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Online.API;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Tests.Resources;
+using osu.Game.Tests.Visual.OnlinePlay;
+
+namespace osu.Game.Tests.Visual.DailyChallenge
+{
+    public partial class TestSceneDailyChallenge : OnlinePlayTestScene
+    {
+        [Test]
+        public void TestDailyChallenge()
+        {
+            var room = new Room
+            {
+                RoomID = { Value = 1234 },
+                Name = { Value = "Daily Challenge: June 4, 2024" },
+                Playlist =
+                {
+                    new PlaylistItem(TestResources.CreateTestBeatmapSetInfo().Beatmaps.First())
+                    {
+                        RequiredMods = [new APIMod(new OsuModTraceable())],
+                        AllowedMods = [new APIMod(new OsuModDoubleTime())]
+                    }
+                },
+                EndDate = { Value = DateTimeOffset.Now.AddHours(12) },
+                Category = { Value = RoomCategory.DailyChallenge }
+            };
+
+            AddStep("add room", () => API.Perform(new CreateRoomRequest(room)));
+            AddStep("push screen", () => LoadScreen(new Screens.OnlinePlay.DailyChallenge.DailyChallenge(room)));
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeCarousel.cs b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeCarousel.cs
new file mode 100644
index 0000000000..b9143945c4
--- /dev/null
+++ b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeCarousel.cs
@@ -0,0 +1,176 @@
+// Copyright (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.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Utils;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Screens.OnlinePlay.DailyChallenge;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests.Visual.DailyChallenge
+{
+    public partial class TestSceneDailyChallengeCarousel : OsuTestScene
+    {
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
+
+        private readonly Bindable<Room> room = new Bindable<Room>(new Room());
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) => new CachedModelDependencyContainer<Room>(base.CreateChildDependencies(parent))
+        {
+            Model = { BindTarget = room }
+        };
+
+        [Test]
+        public void TestBasicAppearance()
+        {
+            DailyChallengeCarousel carousel = null!;
+
+            AddStep("create content", () => Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background4,
+                },
+                carousel = new DailyChallengeCarousel
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                }
+            });
+            AddSliderStep("adjust width", 0.1f, 1, 1, width =>
+            {
+                if (carousel.IsNotNull())
+                    carousel.Width = width;
+            });
+            AddSliderStep("adjust height", 0.1f, 1, 1, height =>
+            {
+                if (carousel.IsNotNull())
+                    carousel.Height = height;
+            });
+            AddRepeatStep("add content", () => carousel.Add(new FakeContent()), 3);
+        }
+
+        [Test]
+        public void TestIntegration()
+        {
+            GridContainer grid = null!;
+            DailyChallengeEventFeed feed = null!;
+            DailyChallengeScoreBreakdown breakdown = null!;
+
+            AddStep("create content", () => Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background4,
+                },
+                grid = new GridContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RowDimensions =
+                    [
+                        new Dimension(),
+                        new Dimension()
+                    ],
+                    Content = new[]
+                    {
+                        new Drawable[]
+                        {
+                            new DailyChallengeCarousel
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Children = new Drawable[]
+                                {
+                                    new DailyChallengeTimeRemainingRing(),
+                                    breakdown = new DailyChallengeScoreBreakdown(),
+                                }
+                            }
+                        },
+                        [
+                            feed = new DailyChallengeEventFeed
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            }
+                        ],
+                    }
+                },
+            });
+            AddSliderStep("adjust width", 0.1f, 1, 1, width =>
+            {
+                if (grid.IsNotNull())
+                    grid.Width = width;
+            });
+            AddSliderStep("adjust height", 0.1f, 1, 1, height =>
+            {
+                if (grid.IsNotNull())
+                    grid.Height = height;
+            });
+            AddSliderStep("update time remaining", 0f, 1f, 0f, progress =>
+            {
+                var startedTimeAgo = TimeSpan.FromHours(24) * progress;
+                room.Value.StartDate.Value = DateTimeOffset.Now - startedTimeAgo;
+                room.Value.EndDate.Value = room.Value.StartDate.Value.Value.AddDays(1);
+            });
+            AddStep("add normal score", () =>
+            {
+                var testScore = TestResources.CreateTestScoreInfo();
+                testScore.TotalScore = RNG.Next(1_000_000);
+
+                feed.AddNewScore(new DailyChallengeEventFeed.NewScoreEvent(testScore, null));
+                breakdown.AddNewScore(testScore);
+            });
+            AddStep("add new user best", () =>
+            {
+                var testScore = TestResources.CreateTestScoreInfo();
+                testScore.TotalScore = RNG.Next(1_000_000);
+
+                feed.AddNewScore(new DailyChallengeEventFeed.NewScoreEvent(testScore, RNG.Next(1, 1000)));
+                breakdown.AddNewScore(testScore);
+            });
+        }
+
+        private partial class FakeContent : CompositeDrawable
+        {
+            private OsuSpriteText text = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                InternalChildren = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = new Colour4(RNG.NextSingle(), RNG.NextSingle(), RNG.NextSingle(), 1),
+                    },
+                    text = new OsuSpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Text = "Fake Content " + (char)('A' + RNG.Next(26)),
+                    },
+                };
+
+                text.FadeOut(500, Easing.OutQuint)
+                    .Then().FadeIn(500, Easing.OutQuint)
+                    .Loop();
+            }
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeEventFeed.cs b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeEventFeed.cs
new file mode 100644
index 0000000000..85499f0588
--- /dev/null
+++ b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeEventFeed.cs
@@ -0,0 +1,76 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Utils;
+using osu.Game.Overlays;
+using osu.Game.Screens.OnlinePlay.DailyChallenge;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests.Visual.DailyChallenge
+{
+    public partial class TestSceneDailyChallengeEventFeed : OsuTestScene
+    {
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
+
+        [Test]
+        public void TestBasicAppearance()
+        {
+            DailyChallengeEventFeed feed = null!;
+
+            AddStep("create content", () => Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background4,
+                },
+                feed = new DailyChallengeEventFeed
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                }
+            });
+            AddSliderStep("adjust width", 0.1f, 1, 1, width =>
+            {
+                if (feed.IsNotNull())
+                    feed.Width = width;
+            });
+            AddSliderStep("adjust height", 0.1f, 1, 1, height =>
+            {
+                if (feed.IsNotNull())
+                    feed.Height = height;
+            });
+
+            AddStep("add normal score", () =>
+            {
+                var testScore = TestResources.CreateTestScoreInfo();
+                testScore.TotalScore = RNG.Next(1_000_000);
+
+                feed.AddNewScore(new DailyChallengeEventFeed.NewScoreEvent(testScore, null));
+            });
+
+            AddStep("add new user best", () =>
+            {
+                var testScore = TestResources.CreateTestScoreInfo();
+                testScore.TotalScore = RNG.Next(1_000_000);
+
+                feed.AddNewScore(new DailyChallengeEventFeed.NewScoreEvent(testScore, RNG.Next(1, 1000)));
+            });
+
+            AddStep("add top 10 score", () =>
+            {
+                var testScore = TestResources.CreateTestScoreInfo();
+                testScore.TotalScore = RNG.Next(1_000_000);
+
+                feed.AddNewScore(new DailyChallengeEventFeed.NewScoreEvent(testScore, RNG.Next(1, 10)));
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeScoreBreakdown.cs b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeScoreBreakdown.cs
new file mode 100644
index 0000000000..5523d02694
--- /dev/null
+++ b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeScoreBreakdown.cs
@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Utils;
+using osu.Game.Overlays;
+using osu.Game.Screens.OnlinePlay.DailyChallenge;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests.Visual.DailyChallenge
+{
+    public partial class TestSceneDailyChallengeScoreBreakdown : OsuTestScene
+    {
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
+
+        [Test]
+        public void TestBasicAppearance()
+        {
+            DailyChallengeScoreBreakdown breakdown = null!;
+
+            AddStep("create content", () => Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background4,
+                },
+                breakdown = new DailyChallengeScoreBreakdown
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                }
+            });
+            AddSliderStep("adjust width", 0.1f, 1, 1, width =>
+            {
+                if (breakdown.IsNotNull())
+                    breakdown.Width = width;
+            });
+            AddSliderStep("adjust height", 0.1f, 1, 1, height =>
+            {
+                if (breakdown.IsNotNull())
+                    breakdown.Height = height;
+            });
+
+            AddStep("set initial data", () => breakdown.SetInitialCounts([1, 4, 9, 16, 25, 36, 49, 36, 25, 16, 9, 4, 1]));
+            AddStep("add new score", () =>
+            {
+                var testScore = TestResources.CreateTestScoreInfo();
+                testScore.TotalScore = RNG.Next(1_000_000);
+
+                breakdown.AddNewScore(testScore);
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeTimeRemainingRing.cs b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeTimeRemainingRing.cs
new file mode 100644
index 0000000000..9e21214c11
--- /dev/null
+++ b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeTimeRemainingRing.cs
@@ -0,0 +1,86 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Screens.OnlinePlay.DailyChallenge;
+
+namespace osu.Game.Tests.Visual.DailyChallenge
+{
+    public partial class TestSceneDailyChallengeTimeRemainingRing : OsuTestScene
+    {
+        private readonly Bindable<Room> room = new Bindable<Room>(new Room());
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) => new CachedModelDependencyContainer<Room>(base.CreateChildDependencies(parent))
+        {
+            Model = { BindTarget = room }
+        };
+
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
+
+        [Test]
+        public void TestBasicAppearance()
+        {
+            DailyChallengeTimeRemainingRing ring = null!;
+
+            AddStep("create content", () => Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background4,
+                },
+                ring = new DailyChallengeTimeRemainingRing
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                }
+            });
+            AddSliderStep("adjust width", 0.1f, 1, 1, width =>
+            {
+                if (ring.IsNotNull())
+                    ring.Width = width;
+            });
+            AddSliderStep("adjust height", 0.1f, 1, 1, height =>
+            {
+                if (ring.IsNotNull())
+                    ring.Height = height;
+            });
+            AddStep("just started", () =>
+            {
+                room.Value.StartDate.Value = DateTimeOffset.Now.AddMinutes(-1);
+                room.Value.EndDate.Value = room.Value.StartDate.Value.Value.AddDays(1);
+            });
+            AddStep("midway through", () =>
+            {
+                room.Value.StartDate.Value = DateTimeOffset.Now.AddHours(-12);
+                room.Value.EndDate.Value = room.Value.StartDate.Value.Value.AddDays(1);
+            });
+            AddStep("nearing end", () =>
+            {
+                room.Value.StartDate.Value = DateTimeOffset.Now.AddDays(-1).AddMinutes(8);
+                room.Value.EndDate.Value = room.Value.StartDate.Value.Value.AddDays(1);
+            });
+            AddStep("already ended", () =>
+            {
+                room.Value.StartDate.Value = DateTimeOffset.Now.AddDays(-2);
+                room.Value.EndDate.Value = room.Value.StartDate.Value.Value.AddDays(1);
+            });
+            AddSliderStep("manual progress", 0f, 1f, 0f, progress =>
+            {
+                var startedTimeAgo = TimeSpan.FromHours(24) * progress;
+                room.Value.StartDate.Value = DateTimeOffset.Now - startedTimeAgo;
+                room.Value.EndDate.Value = room.Value.StartDate.Value.Value.AddDays(1);
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs b/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
index 79a808bbd2..28763051e3 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
@@ -84,6 +84,8 @@ namespace osu.Game.Tests.Visual.Editing
 
                 targetContainer = getTargetContainer();
                 initialRotation = targetContainer!.Rotation;
+
+                base.Begin();
             }
 
             public override void Update(float rotation, Vector2? origin = null)
@@ -102,6 +104,8 @@ namespace osu.Game.Tests.Visual.Editing
 
                 targetContainer = null;
                 initialRotation = null;
+
+                base.Commit();
             }
         }
 
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneEditorChangeStates.cs b/osu.Game.Tests/Visual/Editing/TestSceneEditorChangeStates.cs
index 278b6e9626..7827347b1f 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorChangeStates.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorChangeStates.cs
@@ -4,10 +4,12 @@
 #nullable disable
 
 using NUnit.Framework;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Tests.Visual.Editing
 {
@@ -15,6 +17,8 @@ namespace osu.Game.Tests.Visual.Editing
     {
         protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
 
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
         [Test]
         public void TestSelectedObjects()
         {
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs b/osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs
index 64c48e74cf..b487fa3cec 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs
@@ -193,5 +193,20 @@ namespace osu.Game.Tests.Visual.Editing
             AddUntilStep("Wait for song select", () => Game.ScreenStack.CurrentScreen is PlaySongSelect);
             AddAssert("Tags reverted correctly", () => Game.Beatmap.Value.BeatmapInfo.Metadata.Tags == tags_to_save);
         }
+
+        [Test]
+        public void TestBeatDivisor()
+        {
+            AddStep("Set custom beat divisor", () => Editor.Dependencies.Get<BindableBeatDivisor>().SetArbitraryDivisor(7));
+
+            SaveEditor();
+            AddAssert("Hash updated", () => !string.IsNullOrEmpty(EditorBeatmap.BeatmapInfo.BeatmapSet?.Hash));
+            AddAssert("Beatmap has correct beat divisor", () => EditorBeatmap.BeatmapInfo.BeatDivisor, () => Is.EqualTo(7));
+
+            ReloadEditorToSameBeatmap();
+
+            AddAssert("Beatmap still has correct beat divisor", () => EditorBeatmap.BeatmapInfo.BeatDivisor, () => Is.EqualTo(7));
+            AddAssert("Correct beat divisor actually active", () => Editor.BeatDivisor, () => Is.EqualTo(7));
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneEditorTestGameplay.cs b/osu.Game.Tests/Visual/Editing/TestSceneEditorTestGameplay.cs
index ca5e89c8ed..7dcb8766dd 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorTestGameplay.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorTestGameplay.cs
@@ -126,6 +126,24 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("sample playback re-enabled", () => !Editor.SamplePlaybackDisabled.Value);
         }
 
+        [TestCase(2000)] // chosen to be after last object in the map
+        [TestCase(22000)] // chosen to be in the middle of the last spinner
+        public void TestGameplayTestAtEndOfBeatmap(int offsetFromEnd)
+        {
+            AddStep($"seek to end minus {offsetFromEnd}ms", () => EditorClock.Seek(importedBeatmapSet.MaxLength - offsetFromEnd));
+            AddStep("click test gameplay button", () =>
+            {
+                var button = Editor.ChildrenOfType<TestGameplayButton>().Single();
+
+                InputManager.MoveMouseTo(button);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddUntilStep("player pushed", () => Stack.CurrentScreen is EditorPlayer);
+
+            AddUntilStep("current screen is editor", () => Stack.CurrentScreen is Editor);
+        }
+
         [Test]
         public void TestCancelGameplayTestWithUnsavedChanges()
         {
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
index 0e12ed68e4..f02d2a1bb1 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
@@ -13,9 +13,12 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osu.Game.Screens.Edit.Timing;
 using osu.Game.Tests.Beatmaps;
@@ -79,10 +82,10 @@ namespace osu.Game.Tests.Visual.Editing
         }
 
         [Test]
-        public void TestPopoverHasFocus()
+        public void TestPopoverHasNoFocus()
         {
             clickSamplePiece(0);
-            samplePopoverHasFocus();
+            samplePopoverHasNoFocus();
         }
 
         [Test]
@@ -226,6 +229,84 @@ namespace osu.Game.Tests.Visual.Editing
             samplePopoverHasSingleBank(HitSampleInfo.BANK_NORMAL);
         }
 
+        [Test]
+        public void TestPopoverAddSampleAddition()
+        {
+            clickSamplePiece(0);
+
+            setBankViaPopover(HitSampleInfo.BANK_SOFT);
+            hitObjectHasSampleBank(0, HitSampleInfo.BANK_SOFT);
+
+            toggleAdditionViaPopover(0);
+
+            hitObjectHasSampleBank(0, HitSampleInfo.BANK_SOFT);
+            hitObjectHasSamples(0, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_WHISTLE);
+
+            setAdditionBankViaPopover(HitSampleInfo.BANK_DRUM);
+
+            hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_SOFT);
+            hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_DRUM);
+
+            toggleAdditionViaPopover(0);
+
+            hitObjectHasSampleBank(0, HitSampleInfo.BANK_SOFT);
+            hitObjectHasSamples(0, HitSampleInfo.HIT_NORMAL);
+        }
+
+        [Test]
+        public void TestNodeSamplePopover()
+        {
+            AddStep("add slider", () =>
+            {
+                EditorBeatmap.Clear();
+                EditorBeatmap.Add(new Slider
+                {
+                    Position = new Vector2(256, 256),
+                    StartTime = 0,
+                    Path = new SliderPath(new[] { new PathControlPoint(Vector2.Zero), new PathControlPoint(new Vector2(250, 0)) }),
+                    Samples =
+                    {
+                        new HitSampleInfo(HitSampleInfo.HIT_NORMAL)
+                    },
+                    NodeSamples =
+                    {
+                        new List<HitSampleInfo> { new HitSampleInfo(HitSampleInfo.HIT_NORMAL) },
+                        new List<HitSampleInfo> { new HitSampleInfo(HitSampleInfo.HIT_NORMAL) },
+                    }
+                });
+            });
+
+            clickNodeSamplePiece(0, 1);
+
+            setBankViaPopover(HitSampleInfo.BANK_SOFT);
+            hitObjectNodeHasSampleBank(0, 0, HitSampleInfo.BANK_NORMAL);
+            hitObjectNodeHasSampleBank(0, 1, HitSampleInfo.BANK_SOFT);
+
+            toggleAdditionViaPopover(0);
+
+            hitObjectNodeHasSampleBank(0, 0, HitSampleInfo.BANK_NORMAL);
+            hitObjectNodeHasSampleBank(0, 1, HitSampleInfo.BANK_SOFT);
+            hitObjectNodeHasSamples(0, 0, HitSampleInfo.HIT_NORMAL);
+            hitObjectNodeHasSamples(0, 1, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_WHISTLE);
+
+            setAdditionBankViaPopover(HitSampleInfo.BANK_DRUM);
+
+            hitObjectNodeHasSampleBank(0, 0, HitSampleInfo.BANK_NORMAL);
+            hitObjectNodeHasSampleNormalBank(0, 1, HitSampleInfo.BANK_SOFT);
+            hitObjectNodeHasSampleAdditionBank(0, 1, HitSampleInfo.BANK_DRUM);
+
+            toggleAdditionViaPopover(0);
+
+            hitObjectNodeHasSampleBank(0, 1, HitSampleInfo.BANK_SOFT);
+            hitObjectNodeHasSamples(0, 0, HitSampleInfo.HIT_NORMAL);
+            hitObjectNodeHasSamples(0, 1, HitSampleInfo.HIT_NORMAL);
+
+            setVolumeViaPopover(10);
+
+            hitObjectNodeHasSampleVolume(0, 0, 100);
+            hitObjectNodeHasSampleVolume(0, 1, 10);
+        }
+
         [Test]
         public void TestHotkeysMultipleSelectionWithSameSampleBank()
         {
@@ -329,13 +410,21 @@ namespace osu.Game.Tests.Visual.Editing
             InputManager.Click(MouseButton.Left);
         });
 
-        private void samplePopoverHasFocus() => AddUntilStep("sample popover textbox focused", () =>
+        private void clickNodeSamplePiece(int objectIndex, int nodeIndex) => AddStep($"click {objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node sample piece", () =>
+        {
+            var samplePiece = this.ChildrenOfType<NodeSamplePointPiece>().Where(piece => piece.HitObject == EditorBeatmap.HitObjects.ElementAt(objectIndex)).ToArray()[nodeIndex];
+
+            InputManager.MoveMouseTo(samplePiece);
+            InputManager.Click(MouseButton.Left);
+        });
+
+        private void samplePopoverHasNoFocus() => AddUntilStep("sample popover textbox not focused", () =>
         {
             var popover = this.ChildrenOfType<SamplePointPiece.SampleEditPopover>().SingleOrDefault();
             var slider = popover?.ChildrenOfType<IndeterminateSliderWithTextBoxInput<int>>().Single();
             var textbox = slider?.ChildrenOfType<OsuTextBox>().Single();
 
-            return textbox?.HasFocus == true;
+            return textbox?.HasFocus == false;
         });
 
         private void samplePopoverHasSingleVolume(int volume) => AddUntilStep($"sample popover has volume {volume}", () =>
@@ -372,7 +461,6 @@ namespace osu.Game.Tests.Visual.Editing
 
         private void dismissPopover()
         {
-            AddStep("unfocus textbox", () => InputManager.Key(Key.Escape));
             AddStep("dismiss popover", () => InputManager.Key(Key.Escape));
             AddUntilStep("wait for dismiss", () => !this.ChildrenOfType<SamplePointPiece.SampleEditPopover>().Any(popover => popover.IsPresent));
         }
@@ -390,6 +478,12 @@ namespace osu.Game.Tests.Visual.Editing
             return h.Samples.All(o => o.Volume == volume);
         });
 
+        private void hitObjectNodeHasSampleVolume(int objectIndex, int nodeIndex, int volume) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has volume {volume}", () =>
+        {
+            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+            return h is not null && h.NodeSamples[nodeIndex].All(o => o.Volume == volume);
+        });
+
         private void setBankViaPopover(string bank) => AddStep($"set bank {bank} via popover", () =>
         {
             var popover = this.ChildrenOfType<SamplePointPiece.SampleEditPopover>().Single();
@@ -401,6 +495,26 @@ namespace osu.Game.Tests.Visual.Editing
             InputManager.Key(Key.Enter);
         });
 
+        private void setAdditionBankViaPopover(string bank) => AddStep($"set addition bank {bank} via popover", () =>
+        {
+            var popover = this.ChildrenOfType<SamplePointPiece.SampleEditPopover>().Single();
+            var textBox = popover.ChildrenOfType<LabelledTextBox>().ToArray()[1];
+            textBox.Current.Value = bank;
+            // force a commit via keyboard.
+            // this is needed when testing attempting to set empty bank - which should revert to the previous value, but only on commit.
+            ((IFocusManager)InputManager).ChangeFocus(textBox);
+            InputManager.Key(Key.Enter);
+        });
+
+        private void toggleAdditionViaPopover(int index) => AddStep($"toggle addition {index} via popover", () =>
+        {
+            var popover = this.ChildrenOfType<SamplePointPiece.SampleEditPopover>().First();
+            var ternaryButton = popover.ChildrenOfType<DrawableTernaryButton>().ToArray()[index];
+            InputManager.MoveMouseTo(ternaryButton);
+            InputManager.PressButton(MouseButton.Left);
+            InputManager.ReleaseButton(MouseButton.Left);
+        });
+
         private void hitObjectHasSamples(int objectIndex, params string[] samples) => AddAssert($"{objectIndex.ToOrdinalWords()} has samples {string.Join(',', samples)}", () =>
         {
             var h = EditorBeatmap.HitObjects.ElementAt(objectIndex);
@@ -412,5 +526,41 @@ namespace osu.Game.Tests.Visual.Editing
             var h = EditorBeatmap.HitObjects.ElementAt(objectIndex);
             return h.Samples.All(o => o.Bank == bank);
         });
+
+        private void hitObjectHasSampleNormalBank(int objectIndex, string bank) => AddAssert($"{objectIndex.ToOrdinalWords()} has normal bank {bank}", () =>
+        {
+            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex);
+            return h.Samples.Where(o => o.Name == HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
+        });
+
+        private void hitObjectHasSampleAdditionBank(int objectIndex, string bank) => AddAssert($"{objectIndex.ToOrdinalWords()} has addition bank {bank}", () =>
+        {
+            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex);
+            return h.Samples.Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
+        });
+
+        private void hitObjectNodeHasSamples(int objectIndex, int nodeIndex, params string[] samples) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has samples {string.Join(',', samples)}", () =>
+        {
+            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+            return h is not null && h.NodeSamples[nodeIndex].Select(s => s.Name).SequenceEqual(samples);
+        });
+
+        private void hitObjectNodeHasSampleBank(int objectIndex, int nodeIndex, string bank) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has bank {bank}", () =>
+        {
+            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+            return h is not null && h.NodeSamples[nodeIndex].All(o => o.Bank == bank);
+        });
+
+        private void hitObjectNodeHasSampleNormalBank(int objectIndex, int nodeIndex, string bank) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has normal bank {bank}", () =>
+        {
+            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+            return h is not null && h.NodeSamples[nodeIndex].Where(o => o.Name == HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
+        });
+
+        private void hitObjectNodeHasSampleAdditionBank(int objectIndex, int nodeIndex, string bank) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has addition bank {bank}", () =>
+        {
+            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+            return h is not null && h.NodeSamples[nodeIndex].Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
+        });
     }
 }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneRectangularPositionSnapGrid.cs b/osu.Game.Tests/Visual/Editing/TestScenePositionSnapGrid.cs
similarity index 80%
rename from osu.Game.Tests/Visual/Editing/TestSceneRectangularPositionSnapGrid.cs
rename to osu.Game.Tests/Visual/Editing/TestScenePositionSnapGrid.cs
index e73a45e154..bc2dee8534 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneRectangularPositionSnapGrid.cs
+++ b/osu.Game.Tests/Visual/Editing/TestScenePositionSnapGrid.cs
@@ -16,7 +16,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.Editing
 {
-    public partial class TestSceneRectangularPositionSnapGrid : OsuManualInputManagerTestScene
+    public partial class TestScenePositionSnapGrid : OsuManualInputManagerTestScene
     {
         private Container content;
         protected override Container<Drawable> Content => content;
@@ -33,28 +33,34 @@ namespace osu.Game.Tests.Visual.Editing
                 },
                 content = new Container
                 {
-                    RelativeSizeAxes = Axes.Both
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding(10),
                 }
             });
         }
 
         private static readonly object[][] test_cases =
         {
-            new object[] { new Vector2(0, 0), new Vector2(10, 10) },
-            new object[] { new Vector2(240, 180), new Vector2(10, 15) },
-            new object[] { new Vector2(160, 120), new Vector2(30, 20) },
-            new object[] { new Vector2(480, 360), new Vector2(100, 100) },
+            new object[] { new Vector2(0, 0), new Vector2(10, 10), 0f },
+            new object[] { new Vector2(240, 180), new Vector2(10, 15), 10f },
+            new object[] { new Vector2(160, 120), new Vector2(30, 20), -10f },
+            new object[] { new Vector2(480, 360), new Vector2(100, 100), 0f },
         };
 
         [TestCaseSource(nameof(test_cases))]
-        public void TestRectangularGrid(Vector2 position, Vector2 spacing)
+        public void TestRectangularGrid(Vector2 position, Vector2 spacing, float rotation)
         {
             RectangularPositionSnapGrid grid = null;
 
-            AddStep("create grid", () => Child = grid = new RectangularPositionSnapGrid(position)
+            AddStep("create grid", () =>
             {
-                RelativeSizeAxes = Axes.Both,
-                Spacing = spacing
+                Child = grid = new RectangularPositionSnapGrid
+                {
+                    RelativeSizeAxes = Axes.Both,
+                };
+                grid.StartPosition.Value = position;
+                grid.Spacing.Value = spacing;
+                grid.GridLineRotation.Value = rotation;
             });
 
             AddStep("add snapping cursor", () => Add(new SnappingCursorContainer
@@ -86,7 +92,7 @@ namespace osu.Game.Tests.Visual.Editing
             {
                 base.LoadComplete();
 
-                updatePosition(GetContainingInputManager().CurrentState.Mouse.Position);
+                updatePosition(GetContainingInputManager()!.CurrentState.Mouse.Position);
             }
 
             protected override bool OnMouseMove(MouseMoveEvent e)
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneTimelineSelection.cs b/osu.Game.Tests/Visual/Editing/TestSceneTimelineSelection.cs
index d8219ff36e..9e147f5ff1 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneTimelineSelection.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneTimelineSelection.cs
@@ -14,6 +14,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osu.Game.Tests.Beatmaps;
@@ -357,6 +358,51 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("all blueprints are present", () => blueprintContainer.SelectionBlueprints.Count == EditorBeatmap.SelectedHitObjects.Count);
         }
 
+        [Test]
+        public void TestDragSelectionDuringPlacement()
+        {
+            var addedObjects = new[]
+            {
+                new Slider
+                {
+                    StartTime = 300,
+                    Path = new SliderPath([
+                        new PathControlPoint(),
+                        new PathControlPoint(new Vector2(200)),
+                    ])
+                },
+            };
+            AddStep("add hitobjects", () => EditorBeatmap.AddRange(addedObjects));
+
+            AddStep("seek to 700", () => EditorClock.Seek(700));
+            AddStep("select spinner placement tool", () =>
+            {
+                InputManager.Key(Key.Number4);
+                InputManager.MoveMouseTo(this.ChildrenOfType<OsuHitObjectComposer>().Single());
+            });
+            AddStep("begin spinner placement", () => InputManager.Click(MouseButton.Left));
+            AddStep("seek to 1500", () => EditorClock.Seek(1500));
+
+            AddStep("start dragging", () =>
+            {
+                var blueprintQuad = blueprintContainer.SelectionBlueprints[1].ScreenSpaceDrawQuad;
+                var dragStartPos = (blueprintQuad.TopLeft + blueprintQuad.BottomLeft) / 2 - new Vector2(30, 0);
+                InputManager.MoveMouseTo(dragStartPos);
+                InputManager.PressButton(MouseButton.Left);
+            });
+
+            AddStep("select entire object", () =>
+            {
+                var blueprintQuad = blueprintContainer.SelectionBlueprints[1].ScreenSpaceDrawQuad;
+                var dragStartPos = (blueprintQuad.TopRight + blueprintQuad.BottomRight) / 2 + new Vector2(30, 0);
+                InputManager.MoveMouseTo(dragStartPos);
+            });
+            AddStep("end drag", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddUntilStep("hitobject selected", () => EditorBeatmap.SelectedHitObjects, () => NUnit.Framework.Contains.Item(addedObjects[0]));
+            AddAssert("placement committed", () => EditorBeatmap.HitObjects, () => Has.Count.EqualTo(2));
+        }
+
         private void assertSelectionIs(IEnumerable<HitObject> hitObjects)
             => AddAssert("correct hitobjects selected", () => EditorBeatmap.SelectedHitObjects.OrderBy(h => h.StartTime).SequenceEqual(hitObjects));
     }
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
index 83fc5c2013..3b88750013 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
@@ -19,7 +17,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 {
     public partial class TestSceneBeatmapOffsetControl : OsuTestScene
     {
-        private BeatmapOffsetControl offsetControl;
+        private BeatmapOffsetControl offsetControl = null!;
 
         [SetUpSteps]
         public void SetUpSteps()
@@ -137,5 +135,30 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("Remove reference score", () => offsetControl.ReferenceScore.Value = null);
             AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
         }
+
+        [Test]
+        public void TestCalibrationNoChange()
+        {
+            const double average_error = 0;
+
+            AddAssert("Offset is neutral", () => offsetControl.Current.Value == 0);
+            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
+            AddStep("Set reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
+                };
+            });
+
+            AddUntilStep("Has calibration button", () => offsetControl.ChildrenOfType<SettingsButton>().Any());
+            AddStep("Press button", () => offsetControl.ChildrenOfType<SettingsButton>().Single().TriggerClick());
+            AddAssert("Offset is adjusted", () => offsetControl.Current.Value == -average_error);
+
+            AddUntilStep("Button is disabled", () => !offsetControl.ChildrenOfType<SettingsButton>().Single().Enabled.Value);
+            AddStep("Remove reference score", () => offsetControl.ReferenceScore.Value = null);
+            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableRankDisplay.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableRankDisplay.cs
new file mode 100644
index 0000000000..d442e69c61
--- /dev/null
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinnableRankDisplay.cs
@@ -0,0 +1,41 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Skinning;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public partial class TestSceneSkinnableRankDisplay : SkinnableHUDComponentTestScene
+    {
+        [Cached]
+        private ScoreProcessor scoreProcessor = new ScoreProcessor(new OsuRuleset());
+
+        private Bindable<ScoreRank> rank => (Bindable<ScoreRank>)scoreProcessor.Rank;
+
+        protected override Drawable CreateDefaultImplementation() => new DefaultRankDisplay();
+
+        protected override Drawable CreateLegacyImplementation() => new LegacyRankDisplay();
+
+        [Test]
+        public void TestChangingRank()
+        {
+            AddStep("Set rank to SS Hidden", () => rank.Value = ScoreRank.XH);
+            AddStep("Set rank to SS", () => rank.Value = ScoreRank.X);
+            AddStep("Set rank to S Hidden", () => rank.Value = ScoreRank.SH);
+            AddStep("Set rank to S", () => rank.Value = ScoreRank.S);
+            AddStep("Set rank to A", () => rank.Value = ScoreRank.A);
+            AddStep("Set rank to B", () => rank.Value = ScoreRank.B);
+            AddStep("Set rank to C", () => rank.Value = ScoreRank.C);
+            AddStep("Set rank to D", () => rank.Value = ScoreRank.D);
+            AddStep("Set rank to F", () => rank.Value = ScoreRank.F);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs
index 893b9f11f4..e918a93cbc 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs
@@ -14,8 +14,11 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
 using osu.Game.Overlays;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play;
 using osu.Game.Storyboards;
 using osu.Game.Storyboards.Drawables;
+using osu.Game.Tests.Gameplay;
 using osu.Game.Tests.Resources;
 using osuTK.Graphics;
 
@@ -28,14 +31,14 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private DrawableStoryboard? storyboard;
 
+        [Cached]
+        private GameplayState testGameplayState = TestGameplayState.Create(new OsuRuleset());
+
         [Test]
         public void TestStoryboard()
         {
             AddStep("Restart", restart);
-            AddToggleStep("Passing", passing =>
-            {
-                if (storyboard != null) storyboard.Passing = passing;
-            });
+            AddToggleStep("Toggle passing state", passing => testGameplayState.HealthProcessor.Health.Value = passing ? 1 : 0);
         }
 
         [Test]
@@ -109,7 +112,6 @@ namespace osu.Game.Tests.Visual.Gameplay
             storyboardContainer.Clock = new FramedClock(Beatmap.Value.Track);
 
             storyboard = toLoad.CreateDrawable(SelectedMods.Value);
-            storyboard.Passing = false;
 
             storyboardContainer.Add(storyboard);
         }
diff --git a/osu.Game.Tests/Visual/Menus/TestSceneMainMenu.cs b/osu.Game.Tests/Visual/Menus/TestSceneMainMenu.cs
index 240421b360..57cff38ab0 100644
--- a/osu.Game.Tests/Visual/Menus/TestSceneMainMenu.cs
+++ b/osu.Game.Tests/Visual/Menus/TestSceneMainMenu.cs
@@ -20,6 +20,7 @@ namespace osu.Game.Tests.Visual.Menus
         {
             base.SetUpSteps();
             AddStep("don't fetch online content", () => onlineMenuBanner.FetchOnlineContent = false);
+            AddStep("disable return to top on idle", () => Game.ChildrenOfType<ButtonSystem>().Single().ReturnToTopOnIdle = false);
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
index 8c7576ff52..3306b6624e 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
@@ -644,7 +644,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 }
             });
 
-            AddStep("open mod overlay", () => this.ChildrenOfType<RoomSubScreen.UserModSelectButton>().Single().TriggerClick());
+            AddStep("open mod overlay", () => this.ChildrenOfType<UserModSelectButton>().Single().TriggerClick());
 
             AddStep("invoke on back button", () => multiplayerComponents.OnBackButton());
 
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
index bdfe01ba09..f9ef085838 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
@@ -197,7 +197,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for join", () => RoomJoined);
 
-            ClickButtonWhenEnabled<RoomSubScreen.UserModSelectButton>();
+            ClickButtonWhenEnabled<UserModSelectButton>();
 
             AddUntilStep("mod select contents loaded",
                 () => this.ChildrenOfType<ModColumn>().Any() && this.ChildrenOfType<ModColumn>().All(col => col.IsLoaded && col.ItemsLoaded));
@@ -311,7 +311,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for join", () => RoomJoined);
 
-            ClickButtonWhenEnabled<RoomSubScreen.UserModSelectButton>();
+            ClickButtonWhenEnabled<UserModSelectButton>();
             AddAssert("mod select shows unranked", () => screen.UserModsSelectOverlay.ChildrenOfType<RankingInformationDisplay>().Single().Ranked.Value == false);
             AddAssert("score multiplier = 1.20", () => screen.UserModsSelectOverlay.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.2).Within(0.01));
 
diff --git a/osu.Game.Tests/Visual/Settings/TestSceneFileSelector.cs b/osu.Game.Tests/Visual/Settings/TestSceneFileSelector.cs
index e8f74a2f1b..c70277987e 100644
--- a/osu.Game.Tests/Visual/Settings/TestSceneFileSelector.cs
+++ b/osu.Game.Tests/Visual/Settings/TestSceneFileSelector.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Tests.Visual.Settings
         {
             AddStep("create", () =>
             {
-                Cell(0, 0).Children = new Drawable[]
+                ContentContainer.Children = new Drawable[]
                 {
                     new Box
                     {
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneLeaderboardScoreV2.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneLeaderboardScoreV2.cs
new file mode 100644
index 0000000000..0f5eb06df7
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneLeaderboardScoreV2.cs
@@ -0,0 +1,184 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Configuration;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.SelectV2.Leaderboards;
+using osu.Game.Tests.Resources;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.SongSelect
+{
+    public partial class TestSceneLeaderboardScoreV2 : OsuTestScene
+    {
+        [Cached]
+        private OverlayColourProvider colourProvider { get; set; } = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
+        [Resolved]
+        private OsuConfigManager config { get; set; } = null!;
+
+        private FillFlowContainer? fillFlow;
+        private OsuSpriteText? drawWidthText;
+        private float relativeWidth;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            // TODO: invalidation seems to be one-off when clicking slider to a certain value, so drag for now
+            // doesn't seem to happen in-game (when toggling window mode)
+            AddSliderStep("change relative width", 0, 1f, 0.6f, v =>
+            {
+                relativeWidth = v;
+                if (fillFlow != null) fillFlow.Width = v;
+            });
+        }
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Children = new Drawable[]
+            {
+                fillFlow = new FillFlowContainer
+                {
+                    Width = relativeWidth,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Spacing = new Vector2(0f, 2f),
+                    Shear = new Vector2(OsuGame.SHEAR, 0)
+                },
+                drawWidthText = new OsuSpriteText(),
+            };
+
+            foreach (var scoreInfo in getTestScores())
+            {
+                fillFlow.Add(new LeaderboardScoreV2(scoreInfo, scoreInfo.Position, scoreInfo.User.Id == 2)
+                {
+                    Shear = Vector2.Zero,
+                });
+            }
+
+            foreach (var score in fillFlow.Children)
+                score.Show();
+        });
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddToggleStep("toggle scoring mode", v => config.SetValue(OsuSetting.ScoreDisplayMode, v ? ScoringMode.Classic : ScoringMode.Standardised));
+        }
+
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+
+            if (drawWidthText != null) drawWidthText.Text = $"DrawWidth: {fillFlow?.DrawWidth}";
+        }
+
+        private static ScoreInfo[] getTestScores()
+        {
+            var scores = new[]
+            {
+                new ScoreInfo
+                {
+                    Position = 999,
+                    Rank = ScoreRank.X,
+                    Accuracy = 1,
+                    MaxCombo = 244,
+                    TotalScore = RNG.Next(1_800_000, 2_000_000),
+                    MaximumStatistics = { { HitResult.Great, 3000 } },
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                    User = new APIUser
+                    {
+                        Id = 6602580,
+                        Username = @"waaiiru",
+                        CountryCode = CountryCode.ES,
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c1.jpg",
+                    },
+                    Date = DateTimeOffset.Now.AddYears(-2),
+                },
+                new ScoreInfo
+                {
+                    Position = 22333,
+                    Rank = ScoreRank.S,
+                    Accuracy = 0.1f,
+                    MaxCombo = 32040,
+                    TotalScore = RNG.Next(1_200_000, 1_500_000),
+                    MaximumStatistics = { { HitResult.Great, 3000 } },
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                    User = new APIUser
+                    {
+                        Id = 1541390,
+                        Username = @"Toukai",
+                        CountryCode = CountryCode.CA,
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c2.jpg",
+                    },
+                    Date = DateTimeOffset.Now.AddMonths(-6),
+                },
+                TestResources.CreateTestScoreInfo(),
+                new ScoreInfo
+                {
+                    Position = 110000,
+                    Rank = ScoreRank.B,
+                    Accuracy = 1,
+                    MaxCombo = 244,
+                    TotalScore = RNG.Next(1_000_000, 1_200_000),
+                    MaximumStatistics = { { HitResult.Great, 3000 } },
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                    User = new APIUser
+                    {
+                        Username = @"No cover",
+                        CountryCode = CountryCode.BR,
+                    },
+                    Date = DateTimeOffset.Now,
+                },
+                new ScoreInfo
+                {
+                    Position = 110000,
+                    Rank = ScoreRank.D,
+                    Accuracy = 1,
+                    MaxCombo = 244,
+                    TotalScore = RNG.Next(500_000, 1_000_000),
+                    MaximumStatistics = { { HitResult.Great, 3000 } },
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                    User = new APIUser
+                    {
+                        Id = 226597,
+                        Username = @"WWWWWWWWWWWWWWWWWWWW",
+                        CountryCode = CountryCode.US,
+                    },
+                    Date = DateTimeOffset.Now,
+                },
+            };
+
+            scores[2].Rank = ScoreRank.A;
+            scores[2].TotalScore = RNG.Next(120_000, 400_000);
+            scores[2].MaximumStatistics[HitResult.Great] = 3000;
+
+            scores[1].Mods = new Mod[] { new OsuModHidden(), new OsuModDoubleTime(), new OsuModHardRock(), new OsuModFlashlight() };
+            scores[2].Mods = new Mod[] { new OsuModHidden(), new OsuModDoubleTime(), new OsuModHardRock(), new OsuModFlashlight(), new OsuModClassic() };
+            scores[3].Mods = new Mod[] { new OsuModHidden(), new OsuModDoubleTime(), new OsuModHardRock(), new OsuModFlashlight(), new OsuModClassic(), new OsuModDifficultyAdjust() };
+            scores[4].Mods = new ManiaRuleset().CreateAllMods().ToArray();
+
+            return scores;
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectV2.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectV2.cs
new file mode 100644
index 0000000000..674eaa2ff8
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectV2.cs
@@ -0,0 +1,204 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Overlays.Mods;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Screens;
+using osu.Game.Screens.Footer;
+using osu.Game.Screens.Menu;
+using osu.Game.Screens.SelectV2;
+using osu.Game.Screens.SelectV2.Footer;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.SongSelect
+{
+    public partial class TestSceneSongSelectV2 : ScreenTestScene
+    {
+        [Cached]
+        private readonly ScreenFooter screenScreenFooter;
+
+        [Cached]
+        private readonly OsuLogo logo;
+
+        public TestSceneSongSelectV2()
+        {
+            Children = new Drawable[]
+            {
+                new PopoverContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = screenScreenFooter = new ScreenFooter
+                    {
+                        OnBack = () => Stack.CurrentScreen.Exit(),
+                    },
+                },
+                logo = new OsuLogo
+                {
+                    Alpha = 0f,
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Stack.ScreenPushed += updateFooter;
+            Stack.ScreenExited += updateFooter;
+        }
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("load screen", () => Stack.Push(new SongSelectV2()));
+            AddUntilStep("wait for load", () => Stack.CurrentScreen is SongSelectV2 songSelect && songSelect.IsLoaded);
+        }
+
+        #region Footer
+
+        [Test]
+        public void TestMods()
+        {
+            AddStep("one mod", () => SelectedMods.Value = new List<Mod> { new OsuModHidden() });
+            AddStep("two mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock() });
+            AddStep("three mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime() });
+            AddStep("four mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime(), new OsuModClassic() });
+            AddStep("five mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime(), new OsuModClassic(), new OsuModDifficultyAdjust() });
+
+            AddStep("modified", () => SelectedMods.Value = new List<Mod> { new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
+            AddStep("modified + one", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
+            AddStep("modified + two", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
+            AddStep("modified + three", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModClassic(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
+            AddStep("modified + four", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModClassic(), new OsuModDifficultyAdjust(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
+
+            AddStep("clear mods", () => SelectedMods.Value = Array.Empty<Mod>());
+            AddWaitStep("wait", 3);
+            AddStep("one mod", () => SelectedMods.Value = new List<Mod> { new OsuModHidden() });
+
+            AddStep("clear mods", () => SelectedMods.Value = Array.Empty<Mod>());
+            AddWaitStep("wait", 3);
+            AddStep("five mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime(), new OsuModClassic(), new OsuModDifficultyAdjust() });
+        }
+
+        [Test]
+        public void TestShowOptions()
+        {
+            AddStep("enable options", () =>
+            {
+                var optionsButton = this.ChildrenOfType<ScreenFooterButton>().Last();
+
+                optionsButton.Enabled.Value = true;
+                optionsButton.TriggerClick();
+            });
+        }
+
+        [Test]
+        public void TestState()
+        {
+            AddToggleStep("set options enabled state", state => this.ChildrenOfType<ScreenFooterButton>().Last().Enabled.Value = state);
+        }
+
+        // add these test cases when functionality is implemented.
+        // [Test]
+        // public void TestFooterRandom()
+        // {
+        //     AddStep("press F2", () => InputManager.Key(Key.F2));
+        //     AddAssert("next random invoked", () => nextRandomCalled && !previousRandomCalled);
+        // }
+        //
+        // [Test]
+        // public void TestFooterRandomViaMouse()
+        // {
+        //     AddStep("click button", () =>
+        //     {
+        //         InputManager.MoveMouseTo(randomButton);
+        //         InputManager.Click(MouseButton.Left);
+        //     });
+        //     AddAssert("next random invoked", () => nextRandomCalled && !previousRandomCalled);
+        // }
+        //
+        // [Test]
+        // public void TestFooterRewind()
+        // {
+        //     AddStep("press Shift+F2", () =>
+        //     {
+        //         InputManager.PressKey(Key.LShift);
+        //         InputManager.PressKey(Key.F2);
+        //         InputManager.ReleaseKey(Key.F2);
+        //         InputManager.ReleaseKey(Key.LShift);
+        //     });
+        //     AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
+        // }
+        //
+        // [Test]
+        // public void TestFooterRewindViaShiftMouseLeft()
+        // {
+        //     AddStep("shift + click button", () =>
+        //     {
+        //         InputManager.PressKey(Key.LShift);
+        //         InputManager.MoveMouseTo(randomButton);
+        //         InputManager.Click(MouseButton.Left);
+        //         InputManager.ReleaseKey(Key.LShift);
+        //     });
+        //     AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
+        // }
+        //
+        // [Test]
+        // public void TestFooterRewindViaMouseRight()
+        // {
+        //     AddStep("right click button", () =>
+        //     {
+        //         InputManager.MoveMouseTo(randomButton);
+        //         InputManager.Click(MouseButton.Right);
+        //     });
+        //     AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
+        // }
+
+        [Test]
+        public void TestOverlayPresent()
+        {
+            AddStep("Press F1", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<ScreenFooterButtonMods>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+            AddAssert("Overlay visible", () => this.ChildrenOfType<ModSelectOverlay>().Single().State.Value == Visibility.Visible);
+            AddStep("Hide", () => this.ChildrenOfType<ModSelectOverlay>().Single().Hide());
+        }
+
+        #endregion
+
+        protected override void Update()
+        {
+            base.Update();
+            Stack.Padding = new MarginPadding { Bottom = screenScreenFooter.DrawHeight - screenScreenFooter.Y };
+        }
+
+        private void updateFooter(IScreen? _, IScreen? newScreen)
+        {
+            if (newScreen is IOsuScreen osuScreen && osuScreen.ShowFooter)
+            {
+                screenScreenFooter.Show();
+                screenScreenFooter.SetButtons(osuScreen.CreateFooterButtons());
+            }
+            else
+            {
+                screenScreenFooter.Hide();
+                screenScreenFooter.SetButtons(Array.Empty<ScreenFooterButton>());
+            }
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectV2Navigation.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectV2Navigation.cs
new file mode 100644
index 0000000000..ededb80228
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectV2Navigation.cs
@@ -0,0 +1,33 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Screens.Menu;
+using osu.Game.Screens.SelectV2;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.SongSelect
+{
+    public partial class TestSceneSongSelectV2Navigation : OsuGameTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
+            AddWaitStep("wait", 5);
+            PushAndConfirm(() => new SongSelectV2());
+        }
+
+        [Test]
+        public void TestClickLogo()
+        {
+            AddStep("click", () =>
+            {
+                InputManager.MoveMouseTo(Game.ChildrenOfType<OsuLogo>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneBackButton.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneBackButton.cs
index 494268b158..7aaf616767 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneBackButton.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneBackButton.cs
@@ -5,6 +5,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Screens.Footer;
 using osuTK;
 using osuTK.Graphics;
 
@@ -15,7 +16,7 @@ namespace osu.Game.Tests.Visual.UserInterface
         public TestSceneBackButton()
         {
             BackButton button;
-            BackButton.Receptor receptor = new BackButton.Receptor();
+            ScreenFooter.BackReceptor receptor = new ScreenFooter.BackReceptor();
 
             Child = new Container
             {
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneOsuDropdown.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneOsuDropdown.cs
index 63f7a2f2cc..2f855c8744 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneOsuDropdown.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneOsuDropdown.cs
@@ -6,23 +6,51 @@ using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Input.Events;
-using osu.Framework.Input.States;
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Input.Bindings;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
     public partial class TestSceneOsuDropdown : ThemeComparisonTestScene
     {
-        protected override Drawable CreateContent() =>
-            new OsuEnumDropdown<TestEnum>
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.TopCentre,
-                Width = 150
-            };
+        protected override Drawable CreateContent() => new OsuEnumDropdown<TestEnum>
+        {
+            Anchor = Anchor.Centre,
+            Origin = Anchor.TopCentre,
+            Width = 150
+        };
+
+        [Test]
+        public void TestBackAction()
+        {
+            AddStep("open", () => dropdownMenu.Open());
+            AddStep("press back", () => InputManager.Key(Key.Escape));
+            AddAssert("closed", () => dropdownMenu.State == MenuState.Closed);
+
+            AddStep("open", () => dropdownMenu.Open());
+            AddStep("type something", () => dropdownSearchBar.SearchTerm.Value = "something");
+            AddAssert("search bar visible", () => dropdownSearchBar.State.Value == Visibility.Visible);
+            AddStep("press back", () => InputManager.Key(Key.Escape));
+            AddAssert("text clear", () => dropdownSearchBar.SearchTerm.Value == string.Empty);
+            AddAssert("search bar hidden", () => dropdownSearchBar.State.Value == Visibility.Hidden);
+            AddAssert("still open", () => dropdownMenu.State == MenuState.Open);
+            AddStep("press back", () => InputManager.Key(Key.Escape));
+            AddAssert("closed", () => dropdownMenu.State == MenuState.Closed);
+        }
+
+        [Test]
+        public void TestSelectAction()
+        {
+            AddStep("open", () => dropdownMenu.Open());
+            AddStep("press down", () => InputManager.Key(Key.Down));
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
+            AddAssert("second selected", () => dropdown.Current.Value == TestEnum.ReallyLongOption);
+        }
+
+        private OsuEnumDropdown<TestEnum> dropdown => this.ChildrenOfType<OsuEnumDropdown<TestEnum>>().Last();
+        private Menu dropdownMenu => dropdown.ChildrenOfType<Menu>().Single();
+        private DropdownSearchBar dropdownSearchBar => dropdown.ChildrenOfType<DropdownSearchBar>().Single();
 
         private enum TestEnum
         {
@@ -32,26 +60,5 @@ namespace osu.Game.Tests.Visual.UserInterface
             [System.ComponentModel.Description("Really lonnnnnnng option")]
             ReallyLongOption,
         }
-
-        [Test]
-        // todo: this can be written much better if ThemeComparisonTestScene has a manual input manager
-        public void TestBackAction()
-        {
-            AddStep("open", () => dropdown().ChildrenOfType<Menu>().Single().Open());
-            AddStep("press back", () => dropdown().OnPressed(new KeyBindingPressEvent<GlobalAction>(new InputState(), GlobalAction.Back)));
-            AddAssert("closed", () => dropdown().ChildrenOfType<Menu>().Single().State == MenuState.Closed);
-
-            AddStep("open", () => dropdown().ChildrenOfType<Menu>().Single().Open());
-            AddStep("type something", () => dropdown().ChildrenOfType<DropdownSearchBar>().Single().SearchTerm.Value = "something");
-            AddAssert("search bar visible", () => dropdown().ChildrenOfType<DropdownSearchBar>().Single().State.Value == Visibility.Visible);
-            AddStep("press back", () => dropdown().OnPressed(new KeyBindingPressEvent<GlobalAction>(new InputState(), GlobalAction.Back)));
-            AddAssert("text clear", () => dropdown().ChildrenOfType<DropdownSearchBar>().Single().SearchTerm.Value == string.Empty);
-            AddAssert("search bar hidden", () => dropdown().ChildrenOfType<DropdownSearchBar>().Single().State.Value == Visibility.Hidden);
-            AddAssert("still open", () => dropdown().ChildrenOfType<Menu>().Single().State == MenuState.Open);
-            AddStep("press back", () => dropdown().OnPressed(new KeyBindingPressEvent<GlobalAction>(new InputState(), GlobalAction.Back)));
-            AddAssert("closed", () => dropdown().ChildrenOfType<Menu>().Single().State == MenuState.Closed);
-
-            OsuEnumDropdown<TestEnum> dropdown() => this.ChildrenOfType<OsuEnumDropdown<TestEnum>>().First();
-        }
     }
 }
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneRoundedButton.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneRoundedButton.cs
index 8c2651f71d..2d5c2c6d57 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneRoundedButton.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneRoundedButton.cs
@@ -53,8 +53,8 @@ namespace osu.Game.Tests.Visual.UserInterface
         public void TestBackgroundColour()
         {
             AddStep("set red scheme", () => CreateThemedContent(OverlayColourScheme.Red));
-            AddAssert("rounded button has correct colour", () => Cell(0, 1).ChildrenOfType<RoundedButton>().First().BackgroundColour == new OverlayColourProvider(OverlayColourScheme.Red).Colour3);
-            AddAssert("settings button has correct colour", () => Cell(0, 1).ChildrenOfType<SettingsButton>().First().BackgroundColour == new OverlayColourProvider(OverlayColourScheme.Red).Colour3);
+            AddAssert("rounded button has correct colour", () => ContentContainer.ChildrenOfType<RoundedButton>().First().BackgroundColour == new OverlayColourProvider(OverlayColourScheme.Red).Colour3);
+            AddAssert("settings button has correct colour", () => ContentContainer.ChildrenOfType<SettingsButton>().First().BackgroundColour == new OverlayColourProvider(OverlayColourScheme.Red).Colour3);
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs
index 162609df70..dabb2e7f50 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs
@@ -2,194 +2,93 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Testing;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Footer;
 using osu.Game.Screens.SelectV2.Footer;
-using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
     public partial class TestSceneScreenFooter : OsuManualInputManagerTestScene
     {
-        private ScreenFooterButtonRandom randomButton = null!;
-        private ScreenFooterButtonMods modsButton = null!;
-
-        private bool nextRandomCalled;
-        private bool previousRandomCalled;
-
-        private DummyOverlay overlay = null!;
-
-        [Cached]
-        private OverlayColourProvider colourProvider { get; set; } = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+        private ScreenFooter screenFooter = null!;
+        private TestModSelectOverlay overlay = null!;
 
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
-            nextRandomCalled = false;
-            previousRandomCalled = false;
-
-            ScreenFooter footer;
-
             Children = new Drawable[]
             {
+                overlay = new TestModSelectOverlay
+                {
+                    Padding = new MarginPadding
+                    {
+                        Bottom = ScreenFooter.HEIGHT
+                    }
+                },
                 new PopoverContainer
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Child = footer = new ScreenFooter(),
+                    Child = screenFooter = new ScreenFooter(),
                 },
-                overlay = new DummyOverlay()
             };
 
-            footer.AddButton(modsButton = new ScreenFooterButtonMods { Current = SelectedMods }, overlay);
-            footer.AddButton(randomButton = new ScreenFooterButtonRandom
+            screenFooter.SetButtons(new ScreenFooterButton[]
             {
-                NextRandom = () => nextRandomCalled = true,
-                PreviousRandom = () => previousRandomCalled = true
+                new ScreenFooterButtonMods(overlay) { Current = SelectedMods },
+                new ScreenFooterButtonRandom(),
+                new ScreenFooterButtonOptions(),
             });
-            footer.AddButton(new ScreenFooterButtonOptions());
-
-            overlay.Hide();
         });
 
         [SetUpSteps]
         public void SetUpSteps()
         {
-            AddStep("clear mods", () => SelectedMods.Value = Array.Empty<Mod>());
-            AddStep("set beatmap", () => Beatmap.Value = CreateWorkingBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo)));
+            AddStep("show footer", () => screenFooter.Show());
         }
 
+        /// <summary>
+        /// Transition when moving from a screen with no buttons to a screen with buttons.
+        /// </summary>
         [Test]
-        public void TestMods()
+        public void TestButtonsIn()
         {
-            AddStep("one mod", () => SelectedMods.Value = new List<Mod> { new OsuModHidden() });
-            AddStep("two mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock() });
-            AddStep("three mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime() });
-            AddStep("four mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime(), new OsuModClassic() });
-            AddStep("five mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime(), new OsuModClassic(), new OsuModDifficultyAdjust() });
-
-            AddStep("modified", () => SelectedMods.Value = new List<Mod> { new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
-            AddStep("modified + one", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
-            AddStep("modified + two", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
-            AddStep("modified + three", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModClassic(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
-            AddStep("modified + four", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModClassic(), new OsuModDifficultyAdjust(), new OsuModDoubleTime { SpeedChange = { Value = 1.2 } } });
-
-            AddStep("clear mods", () => SelectedMods.Value = Array.Empty<Mod>());
-            AddWaitStep("wait", 3);
-            AddStep("one mod", () => SelectedMods.Value = new List<Mod> { new OsuModHidden() });
-
-            AddStep("clear mods", () => SelectedMods.Value = Array.Empty<Mod>());
-            AddWaitStep("wait", 3);
-            AddStep("five mods", () => SelectedMods.Value = new List<Mod> { new OsuModHidden(), new OsuModHardRock(), new OsuModDoubleTime(), new OsuModClassic(), new OsuModDifficultyAdjust() });
         }
 
+        /// <summary>
+        /// Transition when moving from a screen with buttons to a screen with no buttons.
+        /// </summary>
         [Test]
-        public void TestShowOptions()
+        public void TestButtonsOut()
         {
-            AddStep("enable options", () =>
+            AddStep("clear buttons", () => screenFooter.SetButtons(Array.Empty<ScreenFooterButton>()));
+        }
+
+        /// <summary>
+        /// Transition when moving from a screen with buttons to a screen with buttons.
+        /// </summary>
+        [Test]
+        public void TestReplaceButtons()
+        {
+            AddStep("replace buttons", () => screenFooter.SetButtons(new[]
             {
-                var optionsButton = this.ChildrenOfType<ScreenFooterButton>().Last();
-
-                optionsButton.Enabled.Value = true;
-                optionsButton.TriggerClick();
-            });
+                new ScreenFooterButton { Text = "One", Action = () => { } },
+                new ScreenFooterButton { Text = "Two", Action = () => { } },
+                new ScreenFooterButton { Text = "Three", Action = () => { } },
+            }));
         }
 
-        [Test]
-        public void TestState()
+        private partial class TestModSelectOverlay : UserModSelectOverlay
         {
-            AddToggleStep("set options enabled state", state => this.ChildrenOfType<ScreenFooterButton>().Last().Enabled.Value = state);
-        }
+            protected override bool ShowPresets => true;
 
-        [Test]
-        public void TestFooterRandom()
-        {
-            AddStep("press F2", () => InputManager.Key(Key.F2));
-            AddAssert("next random invoked", () => nextRandomCalled && !previousRandomCalled);
-        }
-
-        [Test]
-        public void TestFooterRandomViaMouse()
-        {
-            AddStep("click button", () =>
+            public TestModSelectOverlay()
+                : base(OverlayColourScheme.Aquamarine)
             {
-                InputManager.MoveMouseTo(randomButton);
-                InputManager.Click(MouseButton.Left);
-            });
-            AddAssert("next random invoked", () => nextRandomCalled && !previousRandomCalled);
-        }
-
-        [Test]
-        public void TestFooterRewind()
-        {
-            AddStep("press Shift+F2", () =>
-            {
-                InputManager.PressKey(Key.LShift);
-                InputManager.PressKey(Key.F2);
-                InputManager.ReleaseKey(Key.F2);
-                InputManager.ReleaseKey(Key.LShift);
-            });
-            AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
-        }
-
-        [Test]
-        public void TestFooterRewindViaShiftMouseLeft()
-        {
-            AddStep("shift + click button", () =>
-            {
-                InputManager.PressKey(Key.LShift);
-                InputManager.MoveMouseTo(randomButton);
-                InputManager.Click(MouseButton.Left);
-                InputManager.ReleaseKey(Key.LShift);
-            });
-            AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
-        }
-
-        [Test]
-        public void TestFooterRewindViaMouseRight()
-        {
-            AddStep("right click button", () =>
-            {
-                InputManager.MoveMouseTo(randomButton);
-                InputManager.Click(MouseButton.Right);
-            });
-            AddAssert("previous random invoked", () => previousRandomCalled && !nextRandomCalled);
-        }
-
-        [Test]
-        public void TestOverlayPresent()
-        {
-            AddStep("Press F1", () =>
-            {
-                InputManager.MoveMouseTo(modsButton);
-                InputManager.Click(MouseButton.Left);
-            });
-            AddAssert("Overlay visible", () => overlay.State.Value == Visibility.Visible);
-            AddStep("Hide", () => overlay.Hide());
-        }
-
-        private partial class DummyOverlay : ShearedOverlayContainer
-        {
-            public DummyOverlay()
-                : base(OverlayColourScheme.Green)
-            {
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                Header.Title = "An overlay";
             }
         }
     }
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs
index df2109ace8..ba53eb83c4 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs
@@ -10,6 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.SelectV2.Footer;
@@ -26,12 +27,12 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         public TestSceneScreenFooterButtonMods()
         {
-            Add(footerButtonMods = new TestScreenFooterButtonMods
+            Add(footerButtonMods = new TestScreenFooterButtonMods(new TestModSelectOverlay())
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.CentreLeft,
-                X = -100,
                 Action = () => { },
+                X = -100,
             });
         }
 
@@ -112,9 +113,24 @@ namespace osu.Game.Tests.Visual.UserInterface
             return expectedValue == footerButtonMods.MultiplierText.Current.Value;
         }
 
+        private partial class TestModSelectOverlay : UserModSelectOverlay
+        {
+            protected override bool ShowPresets => true;
+
+            public TestModSelectOverlay()
+                : base(OverlayColourScheme.Aquamarine)
+            {
+            }
+        }
+
         private partial class TestScreenFooterButtonMods : ScreenFooterButtonMods
         {
             public new OsuSpriteText MultiplierText => base.MultiplierText;
+
+            public TestScreenFooterButtonMods(ModSelectOverlay overlay)
+                : base(overlay)
+            {
+            }
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/UserInterface/ThemeComparisonTestScene.cs b/osu.Game.Tests/Visual/UserInterface/ThemeComparisonTestScene.cs
index 3177695f44..4700ef72d9 100644
--- a/osu.Game.Tests/Visual/UserInterface/ThemeComparisonTestScene.cs
+++ b/osu.Game.Tests/Visual/UserInterface/ThemeComparisonTestScene.cs
@@ -6,18 +6,21 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Overlays;
+using osuTK;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
-    public abstract partial class ThemeComparisonTestScene : OsuGridTestScene
+    public abstract partial class ThemeComparisonTestScene : OsuManualInputManagerTestScene
     {
         private readonly bool showWithoutColourProvider;
 
+        public Container ContentContainer { get; private set; } = null!;
+
         protected ThemeComparisonTestScene(bool showWithoutColourProvider = true)
-            : base(1, showWithoutColourProvider ? 2 : 1)
         {
             this.showWithoutColourProvider = showWithoutColourProvider;
         }
@@ -25,16 +28,32 @@ namespace osu.Game.Tests.Visual.UserInterface
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
+            Child = ContentContainer = new Container
+            {
+                Anchor = Anchor.TopRight,
+                Origin = Anchor.TopRight,
+                RelativeSizeAxes = Axes.Both,
+            };
+
             if (showWithoutColourProvider)
             {
-                Cell(0, 0).AddRange(new[]
+                ContentContainer.Size = new Vector2(0.5f, 1f);
+
+                Add(new Container
                 {
-                    new Box
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.TopLeft,
+                    RelativeSizeAxes = Axes.Both,
+                    Size = new Vector2(0.5f, 1f),
+                    Children = new[]
                     {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = colours.GreySeaFoam
-                    },
-                    CreateContent()
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = colours.GreySeaFoam
+                        },
+                        CreateContent()
+                    }
                 });
             }
         }
@@ -43,10 +62,8 @@ namespace osu.Game.Tests.Visual.UserInterface
         {
             var colourProvider = new OverlayColourProvider(colourScheme);
 
-            int col = showWithoutColourProvider ? 1 : 0;
-
-            Cell(0, col).Clear();
-            Cell(0, col).Add(new DependencyProvidingContainer
+            ContentContainer.Clear();
+            ContentContainer.Add(new DependencyProvidingContainer
             {
                 RelativeSizeAxes = Axes.Both,
                 CachedDependencies = new (Type, object)[]
diff --git a/osu.Game.Tournament/Screens/Editors/LadderEditorScreen.cs b/osu.Game.Tournament/Screens/Editors/LadderEditorScreen.cs
index 4074e681f9..a7f0a52003 100644
--- a/osu.Game.Tournament/Screens/Editors/LadderEditorScreen.cs
+++ b/osu.Game.Tournament/Screens/Editors/LadderEditorScreen.cs
@@ -51,15 +51,16 @@ namespace osu.Game.Tournament.Screens.Editors
 
             AddInternal(rightClickMessage = new WarningBox("Right click to place and link matches"));
 
-            ScrollContent.Add(grid = new RectangularPositionSnapGrid(Vector2.Zero)
+            ScrollContent.Add(grid = new RectangularPositionSnapGrid
             {
-                Spacing = new Vector2(GRID_SPACING),
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 BypassAutoSizeAxes = Axes.Both,
                 Depth = float.MaxValue
             });
 
+            grid.Spacing.Value = new Vector2(GRID_SPACING);
+
             LadderInfo.Matches.CollectionChanged += (_, _) => updateMessage();
             updateMessage();
         }
diff --git a/osu.Game.Tournament/Screens/Ladder/Components/LadderEditorSettings.cs b/osu.Game.Tournament/Screens/Ladder/Components/LadderEditorSettings.cs
index 08ed815253..775fd4fdf2 100644
--- a/osu.Game.Tournament/Screens/Ladder/Components/LadderEditorSettings.cs
+++ b/osu.Game.Tournament/Screens/Ladder/Components/LadderEditorSettings.cs
@@ -58,7 +58,7 @@ namespace osu.Game.Tournament.Screens.Ladder.Components
             editorInfo.Selected.ValueChanged += selection =>
             {
                 // ensure any ongoing edits are committed out to the *current* selection before changing to a new one.
-                GetContainingFocusManager().TriggerFocusContention(null);
+                GetContainingFocusManager()?.TriggerFocusContention(null);
 
                 // Required to avoid cyclic failure in BindableWithCurrent (TriggerChange called during the Current_Set process).
                 // Arguable a framework issue but since we haven't hit it anywhere else a local workaround seems best.
diff --git a/osu.Game.Tournament/Screens/MapPool/MapPoolScreen.cs b/osu.Game.Tournament/Screens/MapPool/MapPoolScreen.cs
index 665d3c131a..e8b6bdad9f 100644
--- a/osu.Game.Tournament/Screens/MapPool/MapPoolScreen.cs
+++ b/osu.Game.Tournament/Screens/MapPool/MapPoolScreen.cs
@@ -123,7 +123,12 @@ namespace osu.Game.Tournament.Screens.MapPool
 
         private void beatmapChanged(ValueChangedEvent<TournamentBeatmap?> beatmap)
         {
-            if (CurrentMatch.Value == null || CurrentMatch.Value.PicksBans.Count(p => p.Type == ChoiceType.Ban) < 2)
+            if (CurrentMatch.Value?.Round.Value == null)
+                return;
+
+            int totalBansRequired = CurrentMatch.Value.Round.Value.BanCount.Value * 2;
+
+            if (CurrentMatch.Value.PicksBans.Count(p => p.Type == ChoiceType.Ban) < totalBansRequired)
                 return;
 
             // if bans have already been placed, beatmap changes result in a selection being made automatically
diff --git a/osu.Game/Audio/Effects/AudioFilter.cs b/osu.Game/Audio/Effects/AudioFilter.cs
index bfa9b31242..8db457ae67 100644
--- a/osu.Game/Audio/Effects/AudioFilter.cs
+++ b/osu.Game/Audio/Effects/AudioFilter.cs
@@ -1,10 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Diagnostics;
 using ManagedBass.Fx;
 using osu.Framework.Audio.Mixing;
-using osu.Framework.Caching;
 using osu.Framework.Graphics;
 
 namespace osu.Game.Audio.Effects
@@ -26,8 +24,6 @@ namespace osu.Game.Audio.Effects
         private readonly BQFParameters filter;
         private readonly BQFType type;
 
-        private readonly Cached filterApplication = new Cached();
-
         private int cutoff;
 
         /// <summary>
@@ -42,7 +38,7 @@ namespace osu.Game.Audio.Effects
                     return;
 
                 cutoff = value;
-                filterApplication.Invalidate();
+                updateFilter();
             }
         }
 
@@ -64,18 +60,9 @@ namespace osu.Game.Audio.Effects
                 fQ = 0.7f
             };
 
-            Cutoff = getInitialCutoff(type);
-        }
+            cutoff = getInitialCutoff(type);
 
-        protected override void Update()
-        {
-            base.Update();
-
-            if (!filterApplication.IsValid)
-            {
-                updateFilter(cutoff);
-                filterApplication.Validate();
-            }
+            updateFilter();
         }
 
         private int getInitialCutoff(BQFType type)
@@ -93,13 +80,13 @@ namespace osu.Game.Audio.Effects
             }
         }
 
-        private void updateFilter(int newValue)
+        private void updateFilter()
         {
             switch (type)
             {
                 case BQFType.LowPass:
                     // Workaround for weird behaviour when rapidly setting fCenter of a low-pass filter to nyquist - 1hz.
-                    if (newValue >= MAX_LOWPASS_CUTOFF)
+                    if (Cutoff >= MAX_LOWPASS_CUTOFF)
                     {
                         ensureDetached();
                         return;
@@ -109,7 +96,7 @@ namespace osu.Game.Audio.Effects
 
                 // Workaround for weird behaviour when rapidly setting fCenter of a high-pass filter to 1hz.
                 case BQFType.HighPass:
-                    if (newValue <= 1)
+                    if (Cutoff <= 1)
                     {
                         ensureDetached();
                         return;
@@ -120,17 +107,8 @@ namespace osu.Game.Audio.Effects
 
             ensureAttached();
 
-            int filterIndex = mixer.Effects.IndexOf(filter);
-
-            if (filterIndex < 0) return;
-
-            if (mixer.Effects[filterIndex] is BQFParameters existingFilter)
-            {
-                existingFilter.fCenter = newValue;
-
-                // required to update effect with new parameters.
-                mixer.Effects[filterIndex] = existingFilter;
-            }
+            filter.fCenter = Cutoff;
+            mixer.UpdateEffect(filter);
         }
 
         private void ensureAttached()
@@ -138,8 +116,7 @@ namespace osu.Game.Audio.Effects
             if (IsAttached)
                 return;
 
-            Debug.Assert(!mixer.Effects.Contains(filter));
-            mixer.Effects.Add(filter);
+            mixer.AddEffect(filter);
             IsAttached = true;
         }
 
@@ -148,8 +125,7 @@ namespace osu.Game.Audio.Effects
             if (!IsAttached)
                 return;
 
-            Debug.Assert(mixer.Effects.Contains(filter));
-            mixer.Effects.Remove(filter);
+            mixer.RemoveEffect(filter);
             IsAttached = false;
         }
 
diff --git a/osu.Game/Beatmaps/Beatmap.cs b/osu.Game/Beatmaps/Beatmap.cs
index ae77e4adcf..510410bc09 100644
--- a/osu.Game/Beatmaps/Beatmap.cs
+++ b/osu.Game/Beatmaps/Beatmap.cs
@@ -8,6 +8,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps.ControlPoints;
 using Newtonsoft.Json;
+using osu.Framework.Bindables;
 using osu.Game.IO.Serialization.Converters;
 
 namespace osu.Game.Beatmaps
@@ -61,7 +62,7 @@ namespace osu.Game.Beatmaps
 
         public ControlPointInfo ControlPointInfo { get; set; } = new ControlPointInfo();
 
-        public List<BreakPeriod> Breaks { get; set; } = new List<BreakPeriod>();
+        public BindableList<BreakPeriod> Breaks { get; set; } = new BindableList<BreakPeriod>();
 
         public List<string> UnhandledEventLines { get; set; } = new List<string>();
 
diff --git a/osu.Game/Beatmaps/ControlPoints/ControlPoint.cs b/osu.Game/Beatmaps/ControlPoints/ControlPoint.cs
index f46e4af332..416ad0a590 100644
--- a/osu.Game/Beatmaps/ControlPoints/ControlPoint.cs
+++ b/osu.Game/Beatmaps/ControlPoints/ControlPoint.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json;
 using osu.Game.Graphics;
 using osu.Game.Utils;
@@ -9,10 +10,31 @@ using osuTK.Graphics;
 
 namespace osu.Game.Beatmaps.ControlPoints
 {
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
     public abstract class ControlPoint : IComparable<ControlPoint>, IDeepCloneable<ControlPoint>, IEquatable<ControlPoint>, IControlPoint
     {
+        /// <summary>
+        /// Invoked when any of this <see cref="ControlPoint"/>'s properties have changed.
+        /// </summary>
+        public event Action<ControlPoint>? Changed;
+
+        protected void RaiseChanged() => Changed?.Invoke(this);
+
+        private double time;
+
         [JsonIgnore]
-        public double Time { get; set; }
+        public double Time
+        {
+            get => time;
+            set
+            {
+                if (time == value)
+                    return;
+
+                time = value;
+                RaiseChanged();
+            }
+        }
 
         public void AttachGroup(ControlPointGroup pointGroup) => Time = pointGroup.Time;
 
diff --git a/osu.Game/Beatmaps/ControlPoints/ControlPointGroup.cs b/osu.Game/Beatmaps/ControlPoints/ControlPointGroup.cs
index 1f34f3777d..c9c87dc85d 100644
--- a/osu.Game/Beatmaps/ControlPoints/ControlPointGroup.cs
+++ b/osu.Game/Beatmaps/ControlPoints/ControlPointGroup.cs
@@ -10,8 +10,11 @@ namespace osu.Game.Beatmaps.ControlPoints
     public class ControlPointGroup : IComparable<ControlPointGroup>, IEquatable<ControlPointGroup>
     {
         public event Action<ControlPoint>? ItemAdded;
+        public event Action<ControlPoint>? ItemChanged;
         public event Action<ControlPoint>? ItemRemoved;
 
+        private void raiseItemChanged(ControlPoint controlPoint) => ItemChanged?.Invoke(controlPoint);
+
         /// <summary>
         /// The time at which the control point takes effect.
         /// </summary>
@@ -39,12 +42,14 @@ namespace osu.Game.Beatmaps.ControlPoints
 
             controlPoints.Add(point);
             ItemAdded?.Invoke(point);
+            point.Changed += raiseItemChanged;
         }
 
         public void Remove(ControlPoint point)
         {
             controlPoints.Remove(point);
             ItemRemoved?.Invoke(point);
+            point.Changed -= raiseItemChanged;
         }
 
         public sealed override bool Equals(object? obj)
diff --git a/osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs b/osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs
index 1a15db98e4..f8e72a1e34 100644
--- a/osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs
+++ b/osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs
@@ -17,8 +17,17 @@ using osu.Game.Utils;
 namespace osu.Game.Beatmaps.ControlPoints
 {
     [Serializable]
+    [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
     public class ControlPointInfo : IDeepCloneable<ControlPointInfo>
     {
+        /// <summary>
+        /// Invoked on any change to the set of control points.
+        /// </summary>
+        [CanBeNull]
+        public event Action ControlPointsChanged;
+
+        private void raiseControlPointsChanged([CanBeNull] ControlPoint _ = null) => ControlPointsChanged?.Invoke();
+
         /// <summary>
         /// All control points grouped by time.
         /// </summary>
@@ -116,6 +125,7 @@ namespace osu.Game.Beatmaps.ControlPoints
             if (addIfNotExisting)
             {
                 newGroup.ItemAdded += GroupItemAdded;
+                newGroup.ItemChanged += raiseControlPointsChanged;
                 newGroup.ItemRemoved += GroupItemRemoved;
 
                 groups.Insert(~i, newGroup);
@@ -131,6 +141,7 @@ namespace osu.Game.Beatmaps.ControlPoints
                 group.Remove(item);
 
             group.ItemAdded -= GroupItemAdded;
+            group.ItemChanged -= raiseControlPointsChanged;
             group.ItemRemoved -= GroupItemRemoved;
 
             groups.Remove(group);
@@ -287,6 +298,8 @@ namespace osu.Game.Beatmaps.ControlPoints
                 default:
                     throw new ArgumentException($"A control point of unexpected type {controlPoint.GetType()} was added to this {nameof(ControlPointInfo)}");
             }
+
+            raiseControlPointsChanged();
         }
 
         protected virtual void GroupItemRemoved(ControlPoint controlPoint)
@@ -301,6 +314,8 @@ namespace osu.Game.Beatmaps.ControlPoints
                     effectPoints.Remove(typed);
                     break;
             }
+
+            raiseControlPointsChanged();
         }
 
         public ControlPointInfo DeepClone()
diff --git a/osu.Game/Beatmaps/ControlPoints/DifficultyControlPoint.cs b/osu.Game/Beatmaps/ControlPoints/DifficultyControlPoint.cs
index 05230c85f4..9f8ed1b396 100644
--- a/osu.Game/Beatmaps/ControlPoints/DifficultyControlPoint.cs
+++ b/osu.Game/Beatmaps/ControlPoints/DifficultyControlPoint.cs
@@ -44,6 +44,11 @@ namespace osu.Game.Beatmaps.ControlPoints
             set => SliderVelocityBindable.Value = value;
         }
 
+        public DifficultyControlPoint()
+        {
+            SliderVelocityBindable.BindValueChanged(_ => RaiseChanged());
+        }
+
         public override bool IsRedundant(ControlPoint? existing)
             => existing is DifficultyControlPoint existingDifficulty
                && GenerateTicks == existingDifficulty.GenerateTicks
diff --git a/osu.Game/Beatmaps/ControlPoints/EffectControlPoint.cs b/osu.Game/Beatmaps/ControlPoints/EffectControlPoint.cs
index 0138ac7569..d48ed957ee 100644
--- a/osu.Game/Beatmaps/ControlPoints/EffectControlPoint.cs
+++ b/osu.Game/Beatmaps/ControlPoints/EffectControlPoint.cs
@@ -50,6 +50,12 @@ namespace osu.Game.Beatmaps.ControlPoints
             set => KiaiModeBindable.Value = value;
         }
 
+        public EffectControlPoint()
+        {
+            KiaiModeBindable.BindValueChanged(_ => RaiseChanged());
+            ScrollSpeedBindable.BindValueChanged(_ => RaiseChanged());
+        }
+
         public override bool IsRedundant(ControlPoint? existing)
             => existing is EffectControlPoint existingEffect
                && KiaiMode == existingEffect.KiaiMode
diff --git a/osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs b/osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs
index ae4bdafd6f..800d9f9abc 100644
--- a/osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs
+++ b/osu.Game/Beatmaps/ControlPoints/SampleControlPoint.cs
@@ -56,6 +56,12 @@ namespace osu.Game.Beatmaps.ControlPoints
             set => SampleVolumeBindable.Value = value;
         }
 
+        public SampleControlPoint()
+        {
+            SampleBankBindable.BindValueChanged(_ => RaiseChanged());
+            SampleVolumeBindable.BindValueChanged(_ => RaiseChanged());
+        }
+
         /// <summary>
         /// Create a SampleInfo based on the sample settings in this control point.
         /// </summary>
diff --git a/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs b/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
index 4e69486e2d..9ac361cffe 100644
--- a/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
+++ b/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
@@ -82,6 +82,13 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         public double BPM => 60000 / BeatLength;
 
+        public TimingControlPoint()
+        {
+            TimeSignatureBindable.BindValueChanged(_ => RaiseChanged());
+            OmitFirstBarLineBindable.BindValueChanged(_ => RaiseChanged());
+            BeatLengthBindable.BindValueChanged(_ => RaiseChanged());
+        }
+
         // Timing points are never redundant as they can change the time signature.
         public override bool IsRedundant(ControlPoint? existing) => false;
 
diff --git a/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs b/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs
index 1f3dcfee8c..36ddb6030e 100644
--- a/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs
+++ b/osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs
@@ -13,6 +13,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Utils;
 using osuTK;
 
 namespace osu.Game.Beatmaps.Drawables
@@ -124,12 +125,8 @@ namespace osu.Game.Beatmaps.Drawables
             miscFillFlowContainer.Show();
 
             double rate = 1;
-
             if (displayedContent.Mods != null)
-            {
-                foreach (var mod in displayedContent.Mods.OfType<IApplicableToRate>())
-                    rate = mod.ApplyToRate(0, rate);
-            }
+                rate = ModUtils.CalculateRateWithMods(displayedContent.Mods);
 
             double bpmAdjusted = displayedContent.BeatmapInfo.BPM * rate;
 
diff --git a/osu.Game/Beatmaps/IBeatmap.cs b/osu.Game/Beatmaps/IBeatmap.cs
index 5cc38e5b84..072e246a36 100644
--- a/osu.Game/Beatmaps/IBeatmap.cs
+++ b/osu.Game/Beatmaps/IBeatmap.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Bindables;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Objects;
@@ -40,7 +41,7 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// The breaks in this beatmap.
         /// </summary>
-        List<BreakPeriod> Breaks { get; }
+        BindableList<BreakPeriod> Breaks { get; }
 
         /// <summary>
         /// All lines from the [Events] section which aren't handled in the encoding process yet.
diff --git a/osu.Game/Beatmaps/Timing/BreakPeriod.cs b/osu.Game/Beatmaps/Timing/BreakPeriod.cs
index 4c90b16745..d8b500227a 100644
--- a/osu.Game/Beatmaps/Timing/BreakPeriod.cs
+++ b/osu.Game/Beatmaps/Timing/BreakPeriod.cs
@@ -1,26 +1,44 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Game.Screens.Play;
 
 namespace osu.Game.Beatmaps.Timing
 {
-    public class BreakPeriod
+    public class BreakPeriod : IEquatable<BreakPeriod>
     {
+        /// <summary>
+        /// The minimum gap between the start of the break and the previous object.
+        /// </summary>
+        public const double GAP_BEFORE_BREAK = 200;
+
+        /// <summary>
+        /// The minimum gap between the end of the break and the next object.
+        /// Based on osu! preempt time at AR=10.
+        /// See also: https://github.com/ppy/osu/issues/14330#issuecomment-1002158551
+        /// </summary>
+        public const double GAP_AFTER_BREAK = 450;
+
         /// <summary>
         /// The minimum duration required for a break to have any effect.
         /// </summary>
         public const double MIN_BREAK_DURATION = 650;
 
+        /// <summary>
+        /// The minimum required duration of a gap between two objects such that a break can be placed between them.
+        /// </summary>
+        public const double MIN_GAP_DURATION = GAP_BEFORE_BREAK + MIN_BREAK_DURATION + GAP_AFTER_BREAK;
+
         /// <summary>
         /// The break start time.
         /// </summary>
-        public double StartTime;
+        public double StartTime { get; }
 
         /// <summary>
         /// The break end time.
         /// </summary>
-        public double EndTime;
+        public double EndTime { get; }
 
         /// <summary>
         /// The break duration.
@@ -49,5 +67,14 @@ namespace osu.Game.Beatmaps.Timing
         /// <param name="time">The time to check in milliseconds.</param>
         /// <returns>Whether the time falls within this <see cref="BreakPeriod"/>.</returns>
         public bool Contains(double time) => time >= StartTime && time <= EndTime - BreakOverlay.BREAK_FADE_DURATION;
+
+        public bool Intersects(BreakPeriod other) => StartTime <= other.EndTime && EndTime >= other.StartTime;
+
+        public virtual bool Equals(BreakPeriod? other) =>
+            other != null
+            && StartTime == other.StartTime
+            && EndTime == other.EndTime;
+
+        public override int GetHashCode() => HashCode.Combine(StartTime, EndTime);
     }
 }
diff --git a/osu.Game/Configuration/OsuConfigManager.cs b/osu.Game/Configuration/OsuConfigManager.cs
index affcaffe02..bef1cf2899 100644
--- a/osu.Game/Configuration/OsuConfigManager.cs
+++ b/osu.Game/Configuration/OsuConfigManager.cs
@@ -208,6 +208,9 @@ namespace osu.Game.Configuration
 
             SetDefault(OsuSetting.ComboColourNormalisationAmount, 0.2f, 0f, 1f, 0.01f);
             SetDefault<UserStatus?>(OsuSetting.UserOnlineStatus, null);
+
+            SetDefault(OsuSetting.EditorTimelineShowTimingChanges, true);
+            SetDefault(OsuSetting.EditorTimelineShowTicks, true);
         }
 
         protected override bool CheckLookupContainsPrivateInformation(OsuSetting lookup)
@@ -439,5 +442,7 @@ namespace osu.Game.Configuration
         UserOnlineStatus,
         MultiplayerRoomFilter,
         HideCountryFlags,
+        EditorTimelineShowTimingChanges,
+        EditorTimelineShowTicks,
     }
 }
diff --git a/osu.Game/Database/LegacyBeatmapExporter.cs b/osu.Game/Database/LegacyBeatmapExporter.cs
index 69120ea885..17c2c8c88d 100644
--- a/osu.Game/Database/LegacyBeatmapExporter.cs
+++ b/osu.Game/Database/LegacyBeatmapExporter.cs
@@ -8,6 +8,7 @@ using System.Text;
 using osu.Framework.Platform;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
+using osu.Game.Beatmaps.Timing;
 using osu.Game.IO;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -59,9 +60,13 @@ namespace osu.Game.Database
 
             // Convert beatmap elements to be compatible with legacy format
             // So we truncate time and position values to integers, and convert paths with multiple segments to bezier curves
+
             foreach (var controlPoint in playableBeatmap.ControlPointInfo.AllControlPoints)
                 controlPoint.Time = Math.Floor(controlPoint.Time);
 
+            for (int i = 0; i < playableBeatmap.Breaks.Count; i++)
+                playableBeatmap.Breaks[i] = new BreakPeriod(Math.Floor(playableBeatmap.Breaks[i].StartTime), Math.Floor(playableBeatmap.Breaks[i].EndTime));
+
             foreach (var hitObject in playableBeatmap.HitObjects)
             {
                 // Truncate end time before truncating start time because end time is dependent on start time
diff --git a/osu.Game/Graphics/Cursor/GlobalCursorDisplay.cs b/osu.Game/Graphics/Cursor/GlobalCursorDisplay.cs
index 85a2d68e55..d32544fc42 100644
--- a/osu.Game/Graphics/Cursor/GlobalCursorDisplay.cs
+++ b/osu.Game/Graphics/Cursor/GlobalCursorDisplay.cs
@@ -53,7 +53,7 @@ namespace osu.Game.Graphics.Cursor
         {
             base.LoadComplete();
 
-            inputManager = GetContainingInputManager();
+            inputManager = GetContainingInputManager()!;
             showDuringTouch = config.GetBindable<bool>(OsuSetting.GameplayCursorDuringTouch);
         }
 
diff --git a/osu.Game/Graphics/UserInterface/BackButton.cs b/osu.Game/Graphics/UserInterface/BackButton.cs
index cd9a357ea4..29bac8fbae 100644
--- a/osu.Game/Graphics/UserInterface/BackButton.cs
+++ b/osu.Game/Graphics/UserInterface/BackButton.cs
@@ -7,19 +7,18 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.Bindings;
-using osu.Framework.Input.Events;
-using osu.Game.Input.Bindings;
+using osu.Game.Screens.Footer;
 
 namespace osu.Game.Graphics.UserInterface
 {
+    // todo: remove this once all screens migrate to display the new game footer and back button.
     public partial class BackButton : VisibilityContainer
     {
         public Action Action;
 
         private readonly TwoLayerButton button;
 
-        public BackButton(Receptor receptor = null)
+        public BackButton(ScreenFooter.BackReceptor receptor = null)
         {
             Size = TwoLayerButton.SIZE_EXTENDED;
 
@@ -35,7 +34,7 @@ namespace osu.Game.Graphics.UserInterface
             if (receptor == null)
             {
                 // if a receptor wasn't provided, create our own locally.
-                Add(receptor = new Receptor());
+                Add(receptor = new ScreenFooter.BackReceptor());
             }
 
             receptor.OnBackPressed = () => button.TriggerClick();
@@ -59,29 +58,5 @@ namespace osu.Game.Graphics.UserInterface
             button.MoveToX(-TwoLayerButton.SIZE_EXTENDED.X / 2, 400, Easing.OutQuint);
             button.FadeOut(400, Easing.OutQuint);
         }
-
-        public partial class Receptor : Drawable, IKeyBindingHandler<GlobalAction>
-        {
-            public Action OnBackPressed;
-
-            public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
-            {
-                if (e.Repeat)
-                    return false;
-
-                switch (e.Action)
-                {
-                    case GlobalAction.Back:
-                        OnBackPressed?.Invoke();
-                        return true;
-                }
-
-                return false;
-            }
-
-            public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
-            {
-            }
-        }
     }
 }
diff --git a/osu.Game/Graphics/UserInterface/FocusedTextBox.cs b/osu.Game/Graphics/UserInterface/FocusedTextBox.cs
index 4ec93995a4..f4ca00b7d0 100644
--- a/osu.Game/Graphics/UserInterface/FocusedTextBox.cs
+++ b/osu.Game/Graphics/UserInterface/FocusedTextBox.cs
@@ -31,7 +31,7 @@ namespace osu.Game.Graphics.UserInterface
             if (!allowImmediateFocus)
                 return;
 
-            Scheduler.Add(() => GetContainingFocusManager().ChangeFocus(this));
+            Scheduler.Add(() => GetContainingFocusManager()!.ChangeFocus(this));
         }
 
         public new void KillFocus() => base.KillFocus();
diff --git a/osu.Game/Graphics/UserInterface/OsuDropdown.cs b/osu.Game/Graphics/UserInterface/OsuDropdown.cs
index 38e90bf4ea..c8bb45b59d 100644
--- a/osu.Game/Graphics/UserInterface/OsuDropdown.cs
+++ b/osu.Game/Graphics/UserInterface/OsuDropdown.cs
@@ -418,16 +418,19 @@ namespace osu.Game.Graphics.UserInterface
                     FontSize = OsuFont.Default.Size,
                 };
 
-                private partial class DropdownSearchTextBox : SearchTextBox
+                private partial class DropdownSearchTextBox : OsuTextBox
                 {
-                    public override bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+                    [BackgroundDependencyLoader]
+                    private void load(OverlayColourProvider? colourProvider)
                     {
-                        if (e.Action == GlobalAction.Back)
-                            // this method is blocking Dropdown from receiving the back action, despite this text box residing in a separate input manager.
-                            // to fix this properly, a local global action container needs to be added as well, but for simplicity, just don't handle the back action here.
-                            return false;
+                        BackgroundUnfocused = colourProvider?.Background5 ?? new Color4(10, 10, 10, 255);
+                        BackgroundFocused = colourProvider?.Background5 ?? new Color4(10, 10, 10, 255);
+                    }
 
-                        return base.OnPressed(e);
+                    protected override void OnFocus(FocusEvent e)
+                    {
+                        base.OnFocus(e);
+                        BorderThickness = 0;
                     }
                 }
             }
diff --git a/osu.Game/Graphics/UserInterface/SectionHeader.cs b/osu.Game/Graphics/UserInterface/SectionHeader.cs
new file mode 100644
index 0000000000..0ee430c501
--- /dev/null
+++ b/osu.Game/Graphics/UserInterface/SectionHeader.cs
@@ -0,0 +1,55 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Localisation;
+using osu.Game.Graphics.Containers;
+using osu.Game.Overlays;
+using osuTK;
+
+namespace osu.Game.Graphics.UserInterface
+{
+    public partial class SectionHeader : CompositeDrawable
+    {
+        private readonly LocalisableString text;
+
+        public SectionHeader(LocalisableString text)
+        {
+            this.text = text;
+
+            Margin = new MarginPadding { Vertical = 10, Horizontal = 5 };
+
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
+        {
+            InternalChild = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(2),
+                Children = new Drawable[]
+                {
+                    new OsuTextFlowContainer(cp => cp.Font = OsuFont.Default.With(size: 16, weight: FontWeight.SemiBold))
+                    {
+                        Text = text,
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                    },
+                    new Circle
+                    {
+                        Colour = colourProvider.Highlight1,
+                        Size = new Vector2(28, 2),
+                    }
+                }
+            };
+        }
+    }
+}
diff --git a/osu.Game/Graphics/UserInterfaceV2/LabelledTextBox.cs b/osu.Game/Graphics/UserInterfaceV2/LabelledTextBox.cs
index 8dfe729ce7..fabfde4333 100644
--- a/osu.Game/Graphics/UserInterfaceV2/LabelledTextBox.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/LabelledTextBox.cs
@@ -59,7 +59,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
         protected override void OnFocus(FocusEvent e)
         {
             base.OnFocus(e);
-            GetContainingFocusManager().ChangeFocus(Component);
+            GetContainingFocusManager()!.ChangeFocus(Component);
         }
 
         protected override OsuTextBox CreateComponent() => CreateTextBox().With(t =>
diff --git a/osu.Game/Graphics/UserInterfaceV2/SliderWithTextBoxInput.cs b/osu.Game/Graphics/UserInterfaceV2/SliderWithTextBoxInput.cs
index f1f4fe3b46..50d8d763e1 100644
--- a/osu.Game/Graphics/UserInterfaceV2/SliderWithTextBoxInput.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/SliderWithTextBoxInput.cs
@@ -85,7 +85,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
             Current.BindValueChanged(updateTextBoxFromSlider, true);
         }
 
-        public bool TakeFocus() => GetContainingFocusManager().ChangeFocus(textBox);
+        public bool TakeFocus() => GetContainingFocusManager()?.ChangeFocus(textBox) == true;
 
         public bool SelectAll() => textBox.SelectAll();
 
diff --git a/osu.Game/Input/Bindings/GlobalActionContainer.cs b/osu.Game/Input/Bindings/GlobalActionContainer.cs
index 2af564d8ba..2452852f6f 100644
--- a/osu.Game/Input/Bindings/GlobalActionContainer.cs
+++ b/osu.Game/Input/Bindings/GlobalActionContainer.cs
@@ -412,9 +412,6 @@ namespace osu.Game.Input.Bindings
         [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorToggleRotateControl))]
         EditorToggleRotateControl,
 
-        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorToggleScaleControl))]
-        EditorToggleScaleControl,
-
         [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.IncreaseOffset))]
         IncreaseOffset,
 
@@ -432,6 +429,9 @@ namespace osu.Game.Input.Bindings
 
         [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.DecreaseModSpeed))]
         DecreaseModSpeed,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorToggleScaleControl))]
+        EditorToggleScaleControl,
     }
 
     public enum GlobalActionCategory
diff --git a/osu.Game/Localisation/EditorDialogsStrings.cs b/osu.Game/Localisation/EditorDialogsStrings.cs
index fc4c2b7f2a..94f28c617c 100644
--- a/osu.Game/Localisation/EditorDialogsStrings.cs
+++ b/osu.Game/Localisation/EditorDialogsStrings.cs
@@ -49,6 +49,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString ContinueEditing => new TranslatableString(getKey(@"continue_editing"), @"Oops, continue editing");
 
+        /// <summary>
+        /// "The editor must be reloaded to apply this change. The beatmap will be saved."
+        /// </summary>
+        public static LocalisableString EditorReloadDialogHeader => new TranslatableString(getKey(@"editor_reload_dialog_header"), @"The editor must be reloaded to apply this change. The beatmap will be saved.");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/EditorStrings.cs b/osu.Game/Localisation/EditorStrings.cs
index 6ad12f54df..bcffc18d4d 100644
--- a/osu.Game/Localisation/EditorStrings.cs
+++ b/osu.Game/Localisation/EditorStrings.cs
@@ -99,16 +99,6 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString TestBeatmap => new TranslatableString(getKey(@"test_beatmap"), @"Test!");
 
-        /// <summary>
-        /// "Waveform"
-        /// </summary>
-        public static LocalisableString TimelineWaveform => new TranslatableString(getKey(@"timeline_waveform"), @"Waveform");
-
-        /// <summary>
-        /// "Ticks"
-        /// </summary>
-        public static LocalisableString TimelineTicks => new TranslatableString(getKey(@"timeline_ticks"), @"Ticks");
-
         /// <summary>
         /// "{0:0}&#176;"
         /// </summary>
@@ -134,6 +124,21 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString FailedToParseEditorLink => new TranslatableString(getKey(@"failed_to_parse_edtior_link"), @"Failed to parse editor link");
 
+        /// <summary>
+        /// "Timeline"
+        /// </summary>
+        public static LocalisableString Timeline => new TranslatableString(getKey(@"timeline"), @"Timeline");
+
+        /// <summary>
+        /// "Show timing changes"
+        /// </summary>
+        public static LocalisableString TimelineShowTimingChanges => new TranslatableString(getKey(@"timeline_show_timing_changes"), @"Show timing changes");
+
+        /// <summary>
+        /// "Show ticks"
+        /// </summary>
+        public static LocalisableString TimelineShowTicks => new TranslatableString(getKey(@"timeline_show_ticks"), @"Show ticks");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Online/Leaderboards/DrawableRank.cs b/osu.Game/Online/Leaderboards/DrawableRank.cs
index 0b0ab11410..3bc80c8b37 100644
--- a/osu.Game/Online/Leaderboards/DrawableRank.cs
+++ b/osu.Game/Online/Leaderboards/DrawableRank.cs
@@ -18,12 +18,8 @@ namespace osu.Game.Online.Leaderboards
 {
     public partial class DrawableRank : CompositeDrawable
     {
-        private readonly ScoreRank rank;
-
         public DrawableRank(ScoreRank rank)
         {
-            this.rank = rank;
-
             RelativeSizeAxes = Axes.Both;
             FillMode = FillMode.Fit;
             FillAspectRatio = 2;
@@ -57,7 +53,7 @@ namespace osu.Game.Online.Leaderboards
                             Origin = Anchor.Centre,
                             Spacing = new Vector2(-3, 0),
                             Padding = new MarginPadding { Top = 5 },
-                            Colour = getRankNameColour(),
+                            Colour = GetRankNameColour(rank),
                             Font = OsuFont.Numeric.With(size: 25),
                             Text = GetRankName(rank),
                             ShadowColour = Color4.Black.Opacity(0.3f),
@@ -74,7 +70,7 @@ namespace osu.Game.Online.Leaderboards
         /// <summary>
         ///  Retrieves the grade text colour.
         /// </summary>
-        private ColourInfo getRankNameColour()
+        public static ColourInfo GetRankNameColour(ScoreRank rank)
         {
             switch (rank)
             {
diff --git a/osu.Game/Online/Leaderboards/UpdateableRank.cs b/osu.Game/Online/Leaderboards/UpdateableRank.cs
index 46cfe8ec65..b64fab6861 100644
--- a/osu.Game/Online/Leaderboards/UpdateableRank.cs
+++ b/osu.Game/Online/Leaderboards/UpdateableRank.cs
@@ -1,16 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
+using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Transforms;
 using osu.Game.Scoring;
 
 namespace osu.Game.Online.Leaderboards
 {
     public partial class UpdateableRank : ModelBackedDrawable<ScoreRank?>
     {
+        protected override double TransformDuration => 600;
+        protected override bool TransformImmediately => true;
+
         public ScoreRank? Rank
         {
             get => Model;
@@ -22,7 +25,17 @@ namespace osu.Game.Online.Leaderboards
             Rank = rank;
         }
 
-        protected override Drawable CreateDrawable(ScoreRank? rank)
+        protected override DelayedLoadWrapper CreateDelayedLoadWrapper(Func<Drawable> createContentFunc, double timeBeforeLoad)
+        {
+            return base.CreateDelayedLoadWrapper(createContentFunc, timeBeforeLoad)
+                       .With(w =>
+                       {
+                           w.Anchor = Anchor.Centre;
+                           w.Origin = Anchor.Centre;
+                       });
+        }
+
+        protected override Drawable? CreateDrawable(ScoreRank? rank)
         {
             if (rank.HasValue)
             {
@@ -35,5 +48,18 @@ namespace osu.Game.Online.Leaderboards
 
             return null;
         }
+
+        protected override TransformSequence<Drawable> ApplyShowTransforms(Drawable drawable)
+        {
+            drawable.ScaleTo(1);
+            return base.ApplyShowTransforms(drawable);
+        }
+
+        protected override TransformSequence<Drawable> ApplyHideTransforms(Drawable drawable)
+        {
+            drawable.ScaleTo(1.8f, TransformDuration, Easing.Out);
+
+            return base.ApplyHideTransforms(drawable);
+        }
     }
 }
diff --git a/osu.Game/Online/Metadata/IMetadataClient.cs b/osu.Game/Online/Metadata/IMetadataClient.cs
index ee7a726bfc..97c1bbde5f 100644
--- a/osu.Game/Online/Metadata/IMetadataClient.cs
+++ b/osu.Game/Online/Metadata/IMetadataClient.cs
@@ -26,5 +26,11 @@ namespace osu.Game.Online.Metadata
         /// Null value means there is no "daily challenge" currently active.
         /// </summary>
         Task DailyChallengeUpdated(DailyChallengeInfo? info);
+
+        /// <summary>
+        /// Delivers information that a multiplayer score was set in a watched room.
+        /// To receive these, the client must call <see cref="IMetadataServer.BeginWatchingMultiplayerRoom"/> for a given room first.
+        /// </summary>
+        Task MultiplayerRoomScoreSet(MultiplayerRoomScoreSetEvent roomScoreSetEvent);
     }
 }
diff --git a/osu.Game/Online/Metadata/IMetadataServer.cs b/osu.Game/Online/Metadata/IMetadataServer.cs
index 8bf3f8f56b..79ed8b5634 100644
--- a/osu.Game/Online/Metadata/IMetadataServer.cs
+++ b/osu.Game/Online/Metadata/IMetadataServer.cs
@@ -43,5 +43,15 @@ namespace osu.Game.Online.Metadata
         /// Signals to the server that the current user would like to stop receiving updates on other users' online presence.
         /// </summary>
         Task EndWatchingUserPresence();
+
+        /// <summary>
+        /// Signals to the server that the current user would like to begin receiving updates about the state of the multiplayer room with the given <paramref name="id"/>.
+        /// </summary>
+        Task<MultiplayerPlaylistItemStats[]> BeginWatchingMultiplayerRoom(long id);
+
+        /// <summary>
+        /// Signals to the server that the current user would like to stop receiving updates about the state of the multiplayer room with the given <paramref name="id"/>.
+        /// </summary>
+        Task EndWatchingMultiplayerRoom(long id);
     }
 }
diff --git a/osu.Game/Online/Metadata/MetadataClient.cs b/osu.Game/Online/Metadata/MetadataClient.cs
index b619970494..8a5fe1733e 100644
--- a/osu.Game/Online/Metadata/MetadataClient.cs
+++ b/osu.Game/Online/Metadata/MetadataClient.cs
@@ -68,6 +68,24 @@ namespace osu.Game.Online.Metadata
 
         #endregion
 
+        #region Multiplayer room watching
+
+        public abstract Task<MultiplayerPlaylistItemStats[]> BeginWatchingMultiplayerRoom(long id);
+
+        public abstract Task EndWatchingMultiplayerRoom(long id);
+
+        public event Action<MultiplayerRoomScoreSetEvent>? MultiplayerRoomScoreSet;
+
+        Task IMetadataClient.MultiplayerRoomScoreSet(MultiplayerRoomScoreSetEvent roomScoreSetEvent)
+        {
+            if (MultiplayerRoomScoreSet != null)
+                Schedule(MultiplayerRoomScoreSet, roomScoreSetEvent);
+
+            return Task.CompletedTask;
+        }
+
+        #endregion
+
         #region Disconnection handling
 
         public event Action? Disconnecting;
diff --git a/osu.Game/Online/Metadata/MultiplayerPlaylistItemStats.cs b/osu.Game/Online/Metadata/MultiplayerPlaylistItemStats.cs
new file mode 100644
index 0000000000..d13705bf5b
--- /dev/null
+++ b/osu.Game/Online/Metadata/MultiplayerPlaylistItemStats.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 System;
+using MessagePack;
+
+namespace osu.Game.Online.Metadata
+{
+    [MessagePackObject]
+    [Serializable]
+    public class MultiplayerPlaylistItemStats
+    {
+        public const int TOTAL_SCORE_DISTRIBUTION_BINS = 13;
+
+        /// <summary>
+        /// The ID of the playlist item which these stats pertain to.
+        /// </summary>
+        [Key(0)]
+        public long PlaylistItemID { get; set; }
+
+        /// <summary>
+        /// The count of scores with given total ranges in the room.
+        /// The ranges are bracketed into <see cref="TOTAL_SCORE_DISTRIBUTION_BINS"/> bins, each of 100,000 score width.
+        /// The last bin will contain count of all scores with total of 1,200,000 or larger.
+        /// </summary>
+        [Key(1)]
+        public long[] TotalScoreDistribution { get; set; } = new long[TOTAL_SCORE_DISTRIBUTION_BINS];
+    }
+}
diff --git a/osu.Game/Online/Metadata/MultiplayerRoomScoreSetEvent.cs b/osu.Game/Online/Metadata/MultiplayerRoomScoreSetEvent.cs
new file mode 100644
index 0000000000..00bc5dc840
--- /dev/null
+++ b/osu.Game/Online/Metadata/MultiplayerRoomScoreSetEvent.cs
@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using MessagePack;
+
+namespace osu.Game.Online.Metadata
+{
+    [Serializable]
+    [MessagePackObject]
+    public class MultiplayerRoomScoreSetEvent
+    {
+        /// <summary>
+        /// The ID of the room in which the score was set.
+        /// </summary>
+        [Key(0)]
+        public long RoomID { get; set; }
+
+        /// <summary>
+        /// The ID of the playlist item on which the score was set.
+        /// </summary>
+        [Key(1)]
+        public long PlaylistItemID { get; set; }
+
+        /// <summary>
+        /// The ID of the score set.
+        /// </summary>
+        [Key(2)]
+        public long ScoreID { get; set; }
+
+        /// <summary>
+        /// The ID of the user who set the score.
+        /// </summary>
+        [Key(3)]
+        public int UserID { get; set; }
+
+        /// <summary>
+        /// The total score set by the player.
+        /// </summary>
+        [Key(4)]
+        public long TotalScore { get; set; }
+
+        /// <summary>
+        /// If the set score is the user's new best on a playlist item, this member will contain the user's new rank in the room overall.
+        /// Otherwise, it will contain <see langword="null"/>.
+        /// </summary>
+        [Key(5)]
+        public int? NewRank { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Metadata/OnlineMetadataClient.cs b/osu.Game/Online/Metadata/OnlineMetadataClient.cs
index b94f26a71d..80fcf7571d 100644
--- a/osu.Game/Online/Metadata/OnlineMetadataClient.cs
+++ b/osu.Game/Online/Metadata/OnlineMetadataClient.cs
@@ -62,6 +62,7 @@ namespace osu.Game.Online.Metadata
                     connection.On<BeatmapUpdates>(nameof(IMetadataClient.BeatmapSetsUpdated), ((IMetadataClient)this).BeatmapSetsUpdated);
                     connection.On<int, UserPresence?>(nameof(IMetadataClient.UserPresenceUpdated), ((IMetadataClient)this).UserPresenceUpdated);
                     connection.On<DailyChallengeInfo?>(nameof(IMetadataClient.DailyChallengeUpdated), ((IMetadataClient)this).DailyChallengeUpdated);
+                    connection.On<MultiplayerRoomScoreSetEvent>(nameof(IMetadataClient.MultiplayerRoomScoreSet), ((IMetadataClient)this).MultiplayerRoomScoreSet);
                     connection.On(nameof(IStatefulUserHubClient.DisconnectRequested), ((IMetadataClient)this).DisconnectRequested);
                 };
 
@@ -240,6 +241,24 @@ namespace osu.Game.Online.Metadata
             return Task.CompletedTask;
         }
 
+        public override async Task<MultiplayerPlaylistItemStats[]> BeginWatchingMultiplayerRoom(long id)
+        {
+            if (connector?.IsConnected.Value != true)
+                throw new OperationCanceledException();
+
+            Debug.Assert(connection != null);
+            return await connection.InvokeAsync<MultiplayerPlaylistItemStats[]>(nameof(IMetadataServer.BeginWatchingMultiplayerRoom), id).ConfigureAwait(false);
+        }
+
+        public override async Task EndWatchingMultiplayerRoom(long id)
+        {
+            if (connector?.IsConnected.Value != true)
+                throw new OperationCanceledException();
+
+            Debug.Assert(connection != null);
+            await connection.InvokeAsync(nameof(IMetadataServer.EndWatchingMultiplayerRoom)).ConfigureAwait(false);
+        }
+
         public override async Task DisconnectRequested()
         {
             await base.DisconnectRequested().ConfigureAwait(false);
diff --git a/osu.Game/Online/Rooms/OnlinePlayBeatmapAvailabilityTracker.cs b/osu.Game/Online/Rooms/OnlinePlayBeatmapAvailabilityTracker.cs
index ceb8e53778..45f52f3cd8 100644
--- a/osu.Game/Online/Rooms/OnlinePlayBeatmapAvailabilityTracker.cs
+++ b/osu.Game/Online/Rooms/OnlinePlayBeatmapAvailabilityTracker.cs
@@ -29,7 +29,7 @@ namespace osu.Game.Online.Rooms
     /// </summary>
     public partial class OnlinePlayBeatmapAvailabilityTracker : CompositeComponent
     {
-        public readonly IBindable<PlaylistItem> SelectedItem = new Bindable<PlaylistItem>();
+        public readonly Bindable<PlaylistItem> SelectedItem = new Bindable<PlaylistItem>();
 
         [Resolved]
         private RealmAccess realm { get; set; } = null!;
diff --git a/osu.Game/Online/Rooms/PlaylistExtensions.cs b/osu.Game/Online/Rooms/PlaylistExtensions.cs
index cd52a3c6e6..8591b5bb47 100644
--- a/osu.Game/Online/Rooms/PlaylistExtensions.cs
+++ b/osu.Game/Online/Rooms/PlaylistExtensions.cs
@@ -6,6 +6,8 @@ using System.Linq;
 using Humanizer;
 using Humanizer.Localisation;
 using osu.Framework.Bindables;
+using osu.Game.Rulesets;
+using osu.Game.Utils;
 
 namespace osu.Game.Online.Rooms
 {
@@ -38,7 +40,21 @@ namespace osu.Game.Online.Rooms
                 : GetUpcomingItems(playlist).First();
         }
 
-        public static string GetTotalDuration(this BindableList<PlaylistItem> playlist) =>
-            playlist.Select(p => p.Beatmap.Length).Sum().Milliseconds().Humanize(minUnit: TimeUnit.Second, maxUnit: TimeUnit.Hour, precision: 2);
+        /// <summary>
+        /// Returns the total duration from the <see cref="PlaylistItem"/> in playlist order from the supplied <paramref name="playlist"/>,
+        /// </summary>
+        public static string GetTotalDuration(this BindableList<PlaylistItem> playlist, RulesetStore rulesetStore) =>
+            playlist.Select(p =>
+            {
+                double rate = 1;
+
+                if (p.RequiredMods.Length > 0)
+                {
+                    var ruleset = rulesetStore.GetRuleset(p.RulesetID)!.CreateInstance();
+                    rate = ModUtils.CalculateRateWithMods(p.RequiredMods.Select(mod => mod.ToMod(ruleset)));
+                }
+
+                return p.Beatmap.Length / rate;
+            }).Sum().Milliseconds().Humanize(minUnit: TimeUnit.Second, maxUnit: TimeUnit.Hour, precision: 2);
     }
 }
diff --git a/osu.Game/Online/Rooms/Room.cs b/osu.Game/Online/Rooms/Room.cs
index 5abf5034d9..c39932c3bf 100644
--- a/osu.Game/Online/Rooms/Room.cs
+++ b/osu.Game/Online/Rooms/Room.cs
@@ -146,6 +146,11 @@ namespace osu.Game.Online.Rooms
 
         #endregion
 
+        // Only supports retrieval for now
+        [Cached]
+        [JsonProperty("starts_at")]
+        public readonly Bindable<DateTimeOffset?> StartDate = new Bindable<DateTimeOffset?>();
+
         // Only supports retrieval for now
         [Cached]
         [JsonProperty("ends_at")]
diff --git a/osu.Game/OsuGame.cs b/osu.Game/OsuGame.cs
index 0833f52b1e..cf32daab00 100644
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@@ -8,6 +8,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using Humanizer;
@@ -22,6 +23,7 @@ using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
@@ -58,6 +60,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
 using osu.Game.Screens;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.Play;
@@ -153,6 +156,8 @@ namespace osu.Game
 
         private float toolbarOffset => (Toolbar?.Position.Y ?? 0) + (Toolbar?.DrawHeight ?? 0);
 
+        private float screenFooterOffset => (ScreenFooter?.DrawHeight ?? 0) - (ScreenFooter?.Position.Y ?? 0);
+
         private IdleTracker idleTracker;
 
         /// <summary>
@@ -177,6 +182,7 @@ namespace osu.Game
         protected OsuScreenStack ScreenStack;
 
         protected BackButton BackButton;
+        protected ScreenFooter ScreenFooter;
 
         protected SettingsOverlay Settings;
 
@@ -866,6 +872,9 @@ namespace osu.Game
         {
             base.LoadComplete();
 
+            if (RuntimeInfo.EntryAssembly.GetCustomAttribute<OfficialBuildAttribute>() == null)
+                Logger.Log(NotificationsStrings.NotOfficialBuild.ToString());
+
             var languages = Enum.GetValues<Language>();
 
             var mappings = languages.Select(language =>
@@ -926,7 +935,7 @@ namespace osu.Game
             };
 
             Container logoContainer;
-            BackButton.Receptor receptor;
+            ScreenFooter.BackReceptor backReceptor;
 
             dependencies.CacheAs(idleTracker = new GameIdleTracker(6000));
 
@@ -959,20 +968,28 @@ namespace osu.Game
                             Origin = Anchor.Centre,
                             Children = new Drawable[]
                             {
-                                receptor = new BackButton.Receptor(),
+                                backReceptor = new ScreenFooter.BackReceptor(),
                                 ScreenStack = new OsuScreenStack { RelativeSizeAxes = Axes.Both },
-                                BackButton = new BackButton(receptor)
+                                BackButton = new BackButton(backReceptor)
                                 {
                                     Anchor = Anchor.BottomLeft,
                                     Origin = Anchor.BottomLeft,
-                                    Action = () =>
+                                    Action = () => ScreenFooter.OnBack?.Invoke(),
+                                },
+                                new PopoverContainer
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Child = ScreenFooter = new ScreenFooter(backReceptor)
                                     {
-                                        if (!(ScreenStack.CurrentScreen is IOsuScreen currentScreen))
-                                            return;
+                                        OnBack = () =>
+                                        {
+                                            if (!(ScreenStack.CurrentScreen is IOsuScreen currentScreen))
+                                                return;
 
-                                        if (!((Drawable)currentScreen).IsLoaded || (currentScreen.AllowBackButton && !currentScreen.OnBackButton()))
-                                            ScreenStack.Exit();
-                                    }
+                                            if (!((Drawable)currentScreen).IsLoaded || (currentScreen.AllowBackButton && !currentScreen.OnBackButton()))
+                                                ScreenStack.Exit();
+                                        }
+                                    },
                                 },
                                 logoContainer = new Container { RelativeSizeAxes = Axes.Both },
                             }
@@ -994,6 +1011,8 @@ namespace osu.Game
                 new ConfineMouseTracker()
             });
 
+            dependencies.Cache(ScreenFooter);
+
             ScreenStack.ScreenPushed += screenPushed;
             ScreenStack.ScreenExited += screenExited;
 
@@ -1466,6 +1485,7 @@ namespace osu.Game
 
             ScreenOffsetContainer.Padding = new MarginPadding { Top = toolbarOffset };
             overlayOffsetContainer.Padding = new MarginPadding { Top = toolbarOffset };
+            ScreenStack.Padding = new MarginPadding { Bottom = screenFooterOffset };
 
             float horizontalOffset = 0f;
 
@@ -1538,6 +1558,18 @@ namespace osu.Game
                     BackButton.Show();
                 else
                     BackButton.Hide();
+
+                if (newOsuScreen.ShowFooter)
+                {
+                    BackButton.Hide();
+                    ScreenFooter.SetButtons(newOsuScreen.CreateFooterButtons());
+                    ScreenFooter.Show();
+                }
+                else
+                {
+                    ScreenFooter.SetButtons(Array.Empty<ScreenFooterButton>());
+                    ScreenFooter.Hide();
+                }
             }
 
             skinEditor.SetTarget((OsuScreen)newScreen);
diff --git a/osu.Game/Overlays/AccountCreation/ScreenEntry.cs b/osu.Game/Overlays/AccountCreation/ScreenEntry.cs
index 53e51e0611..fb6a5796a1 100644
--- a/osu.Game/Overlays/AccountCreation/ScreenEntry.cs
+++ b/osu.Game/Overlays/AccountCreation/ScreenEntry.cs
@@ -243,7 +243,7 @@ namespace osu.Game.Overlays.AccountCreation
 
             if (nextTextBox != null)
             {
-                Schedule(() => GetContainingFocusManager().ChangeFocus(nextTextBox));
+                Schedule(() => GetContainingFocusManager()!.ChangeFocus(nextTextBox));
                 return true;
             }
 
diff --git a/osu.Game/Overlays/BeatmapListing/BeatmapSearchGeneralFilterRow.cs b/osu.Game/Overlays/BeatmapListing/BeatmapSearchGeneralFilterRow.cs
index a4a914db55..2d56c60de6 100644
--- a/osu.Game/Overlays/BeatmapListing/BeatmapSearchGeneralFilterRow.cs
+++ b/osu.Game/Overlays/BeatmapListing/BeatmapSearchGeneralFilterRow.cs
@@ -56,8 +56,6 @@ namespace osu.Game.Overlays.BeatmapListing
             [Resolved(canBeNull: true)]
             private IDialogOverlay dialogOverlay { get; set; }
 
-            protected override Color4 GetStateColour() => colours.Orange1;
-
             protected override void LoadComplete()
             {
                 base.LoadComplete();
@@ -65,6 +63,9 @@ namespace osu.Game.Overlays.BeatmapListing
                 disclaimerShown = sessionStatics.GetBindable<bool>(Static.FeaturedArtistDisclaimerShownOnce);
             }
 
+            protected override Color4 ColourNormal => colours.Orange1;
+            protected override Color4 ColourActive => colours.Orange2;
+
             protected override bool OnClick(ClickEvent e)
             {
                 if (!disclaimerShown.Value && dialogOverlay != null)
diff --git a/osu.Game/Overlays/BeatmapListing/BeatmapSearchMultipleSelectionFilterRow.cs b/osu.Game/Overlays/BeatmapListing/BeatmapSearchMultipleSelectionFilterRow.cs
index 4bd25f6561..958297b559 100644
--- a/osu.Game/Overlays/BeatmapListing/BeatmapSearchMultipleSelectionFilterRow.cs
+++ b/osu.Game/Overlays/BeatmapListing/BeatmapSearchMultipleSelectionFilterRow.cs
@@ -1,21 +1,23 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Linq;
-using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osuTK;
+using osuTK.Graphics;
+using FontWeight = osu.Game.Graphics.FontWeight;
 
 namespace osu.Game.Overlays.BeatmapListing
 {
@@ -24,7 +26,7 @@ namespace osu.Game.Overlays.BeatmapListing
     {
         public new readonly BindableList<T> Current = new BindableList<T>();
 
-        private MultipleSelectionFilter filter;
+        private MultipleSelectionFilter filter = null!;
 
         public BeatmapSearchMultipleSelectionFilterRow(LocalisableString header)
             : base(header)
@@ -42,7 +44,6 @@ namespace osu.Game.Overlays.BeatmapListing
         /// <summary>
         /// Creates a filter control that can be used to simultaneously select multiple values of type <typeparamref name="T"/>.
         /// </summary>
-        [NotNull]
         protected virtual MultipleSelectionFilter CreateMultipleSelectionFilter() => new MultipleSelectionFilter();
 
         protected partial class MultipleSelectionFilter : FillFlowContainer<MultipleSelectionFilterTabItem>
@@ -54,7 +55,7 @@ namespace osu.Game.Overlays.BeatmapListing
             {
                 RelativeSizeAxes = Axes.X;
                 AutoSizeAxes = Axes.Y;
-                Spacing = new Vector2(10, 0);
+                Spacing = new Vector2(10, 5);
 
                 AddRange(GetValues().Select(CreateTabItem));
             }
@@ -69,7 +70,7 @@ namespace osu.Game.Overlays.BeatmapListing
                 Current.BindCollectionChanged(currentChanged, true);
             }
 
-            private void currentChanged(object sender, NotifyCollectionChangedEventArgs e)
+            private void currentChanged(object? sender, NotifyCollectionChangedEventArgs e)
             {
                 foreach (var c in Children)
                     c.Active.Value = Current.Contains(c.Value);
@@ -99,30 +100,91 @@ namespace osu.Game.Overlays.BeatmapListing
 
         protected partial class MultipleSelectionFilterTabItem : FilterTabItem<T>
         {
-            private readonly Box selectedUnderline;
-
-            protected override bool HighlightOnHoverWhenActive => true;
+            private Drawable activeContent = null!;
+            private Circle background = null!;
 
             public MultipleSelectionFilterTabItem(T value)
                 : base(value)
             {
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AutoSizeDuration = 100;
+                AutoSizeEasing = Easing.OutQuint;
+
                 // This doesn't match any actual design, but should make it easier for the user to understand
                 // that filters are applied until we settle on a final design.
-                AddInternal(selectedUnderline = new Box
+                AddInternal(activeContent = new Container
                 {
                     Depth = float.MaxValue,
-                    RelativeSizeAxes = Axes.X,
-                    Height = 1.5f,
-                    Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.CentreLeft,
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0,
+                    Padding = new MarginPadding
+                    {
+                        Left = -16,
+                        Right = -4,
+                        Vertical = -2
+                    },
+                    Children = new Drawable[]
+                    {
+                        background = new Circle
+                        {
+                            Colour = Color4.White,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new SpriteIcon
+                        {
+                            Icon = FontAwesome.Solid.TimesCircle,
+                            Size = new Vector2(10),
+                            Colour = ColourProvider.Background4,
+                            Position = new Vector2(3, 0.5f),
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                        }
+                    }
                 });
             }
 
+            protected override Color4 ColourActive => ColourProvider.Light1;
+
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
+            {
+                return Active.Value
+                    ? background.ReceivePositionalInputAt(screenSpacePos)
+                    : base.ReceivePositionalInputAt(screenSpacePos);
+            }
+
             protected override void UpdateState()
             {
-                base.UpdateState();
-                selectedUnderline.FadeTo(Active.Value ? 1 : 0, 200, Easing.OutQuint);
-                selectedUnderline.FadeColour(IsHovered ? ColourProvider.Content2 : GetStateColour(), 200, Easing.OutQuint);
+                Color4 colour = Active.Value ? ColourActive : ColourNormal;
+
+                if (IsHovered)
+                    colour = Active.Value ? colour.Darken(0.2f) : colour.Lighten(0.2f);
+
+                if (Active.Value)
+                {
+                    // This just allows enough spacing for adjacent tab items to show the "x".
+                    Padding = new MarginPadding { Left = 12 };
+
+                    activeContent.FadeIn(200, Easing.OutQuint);
+                    background.FadeColour(colour, 200, Easing.OutQuint);
+
+                    // flipping colours
+                    Text.FadeColour(ColourProvider.Background4, 200, Easing.OutQuint);
+                    Text.Font = Text.Font.With(weight: FontWeight.SemiBold);
+                }
+                else
+                {
+                    Padding = new MarginPadding();
+
+                    activeContent.FadeOut();
+
+                    background.FadeColour(colour, 200, Easing.OutQuint);
+                    Text.FadeColour(colour, 200, Easing.OutQuint);
+                    Text.Font = Text.Font.With(weight: FontWeight.Regular);
+                }
             }
 
             protected override bool OnClick(ClickEvent e)
diff --git a/osu.Game/Overlays/BeatmapListing/FilterTabItem.cs b/osu.Game/Overlays/BeatmapListing/FilterTabItem.cs
index ee188d34ce..8f4ecaa0f5 100644
--- a/osu.Game/Overlays/BeatmapListing/FilterTabItem.cs
+++ b/osu.Game/Overlays/BeatmapListing/FilterTabItem.cs
@@ -8,6 +8,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
@@ -24,7 +25,7 @@ namespace osu.Game.Overlays.BeatmapListing
         [Resolved]
         protected OverlayColourProvider ColourProvider { get; private set; }
 
-        private OsuSpriteText text;
+        protected OsuSpriteText Text;
 
         protected Sample SelectSample { get; private set; } = null!;
 
@@ -39,7 +40,7 @@ namespace osu.Game.Overlays.BeatmapListing
             AutoSizeAxes = Axes.Both;
             AddRangeInternal(new Drawable[]
             {
-                text = new OsuSpriteText
+                Text = new OsuSpriteText
                 {
                     Font = OsuFont.GetFont(size: 13, weight: FontWeight.Regular),
                     Text = LabelFor(Value)
@@ -84,16 +85,18 @@ namespace osu.Game.Overlays.BeatmapListing
         /// </summary>
         protected virtual LocalisableString LabelFor(T value) => (value as Enum)?.GetLocalisableDescription() ?? value.ToString();
 
-        protected virtual bool HighlightOnHoverWhenActive => false;
+        protected virtual Color4 ColourActive => ColourProvider.Content1;
+        protected virtual Color4 ColourNormal => ColourProvider.Light2;
 
         protected virtual void UpdateState()
         {
-            bool highlightHover = IsHovered && (!Active.Value || HighlightOnHoverWhenActive);
+            Color4 colour = Active.Value ? ColourActive : ColourNormal;
 
-            text.FadeColour(highlightHover ? ColourProvider.Content2 : GetStateColour(), 200, Easing.OutQuint);
-            text.Font = text.Font.With(weight: Active.Value ? FontWeight.Bold : FontWeight.Regular);
+            if (IsHovered)
+                colour = colour.Lighten(0.2f);
+
+            Text.FadeColour(colour, 200, Easing.OutQuint);
+            Text.Font = Text.Font.With(weight: Active.Value ? FontWeight.Bold : FontWeight.Regular);
         }
-
-        protected virtual Color4 GetStateColour() => Active.Value ? ColourProvider.Content1 : ColourProvider.Light2;
     }
 }
diff --git a/osu.Game/Overlays/Comments/ReplyCommentEditor.cs b/osu.Game/Overlays/Comments/ReplyCommentEditor.cs
index caf19829ee..d5ae4f92ab 100644
--- a/osu.Game/Overlays/Comments/ReplyCommentEditor.cs
+++ b/osu.Game/Overlays/Comments/ReplyCommentEditor.cs
@@ -39,7 +39,7 @@ namespace osu.Game.Overlays.Comments
             base.LoadComplete();
 
             if (!TextBox.ReadOnly)
-                GetContainingFocusManager().ChangeFocus(TextBox);
+                GetContainingFocusManager()!.ChangeFocus(TextBox);
         }
 
         protected override void OnCommit(string text)
diff --git a/osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs b/osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs
index 19d7ea7a87..d16f49eab7 100644
--- a/osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs
+++ b/osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs
@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -71,7 +72,7 @@ namespace osu.Game.Overlays.Dialog
             protected override void LoadComplete()
             {
                 base.LoadComplete();
-                Progress.BindValueChanged(progressChanged);
+                Progress.BindValueChanged(progressChanged, true);
             }
 
             protected override void AbortConfirm()
@@ -122,11 +123,13 @@ namespace osu.Game.Overlays.Dialog
 
             private void progressChanged(ValueChangedEvent<double> progress)
             {
-                if (progress.NewValue < progress.OldValue) return;
+                lowPassFilter.Cutoff = Math.Max(1, (int)(progress.NewValue * AudioFilter.MAX_LOWPASS_CUTOFF * 0.5));
 
-                if (Clock.CurrentTime - lastTickPlaybackTime < 30) return;
+                if (progress.NewValue < progress.OldValue)
+                    return;
 
-                lowPassFilter.CutoffTo((int)(progress.NewValue * AudioFilter.MAX_LOWPASS_CUTOFF * 0.5));
+                if (Clock.CurrentTime - lastTickPlaybackTime < 30)
+                    return;
 
                 var channel = tickSample.GetChannel();
 
diff --git a/osu.Game/Overlays/Login/LoginForm.cs b/osu.Game/Overlays/Login/LoginForm.cs
index 418721f371..13e528ff8f 100644
--- a/osu.Game/Overlays/Login/LoginForm.cs
+++ b/osu.Game/Overlays/Login/LoginForm.cs
@@ -150,7 +150,7 @@ namespace osu.Game.Overlays.Login
 
         protected override void OnFocus(FocusEvent e)
         {
-            Schedule(() => { GetContainingFocusManager().ChangeFocus(string.IsNullOrEmpty(username.Text) ? username : password); });
+            Schedule(() => { GetContainingFocusManager()!.ChangeFocus(string.IsNullOrEmpty(username.Text) ? username : password); });
         }
     }
 }
diff --git a/osu.Game/Overlays/Login/LoginPanel.cs b/osu.Game/Overlays/Login/LoginPanel.cs
index 845d20ccaf..cb642f9b72 100644
--- a/osu.Game/Overlays/Login/LoginPanel.cs
+++ b/osu.Game/Overlays/Login/LoginPanel.cs
@@ -216,7 +216,7 @@ namespace osu.Game.Overlays.Login
 
         protected override void OnFocus(FocusEvent e)
         {
-            if (form != null) GetContainingFocusManager().ChangeFocus(form);
+            if (form != null) GetContainingFocusManager()!.ChangeFocus(form);
             base.OnFocus(e);
         }
     }
diff --git a/osu.Game/Overlays/Login/SecondFactorAuthForm.cs b/osu.Game/Overlays/Login/SecondFactorAuthForm.cs
index 82e328c036..77835b1f09 100644
--- a/osu.Game/Overlays/Login/SecondFactorAuthForm.cs
+++ b/osu.Game/Overlays/Login/SecondFactorAuthForm.cs
@@ -141,7 +141,7 @@ namespace osu.Game.Overlays.Login
 
         protected override void OnFocus(FocusEvent e)
         {
-            Schedule(() => { GetContainingFocusManager().ChangeFocus(codeTextBox); });
+            Schedule(() => { GetContainingFocusManager()!.ChangeFocus(codeTextBox); });
         }
     }
 }
diff --git a/osu.Game/Overlays/LoginOverlay.cs b/osu.Game/Overlays/LoginOverlay.cs
index 8dc454c0a0..d570983f98 100644
--- a/osu.Game/Overlays/LoginOverlay.cs
+++ b/osu.Game/Overlays/LoginOverlay.cs
@@ -78,7 +78,7 @@ namespace osu.Game.Overlays
             this.FadeIn(transition_time, Easing.OutQuint);
             FadeEdgeEffectTo(WaveContainer.SHADOW_OPACITY, WaveContainer.APPEAR_DURATION, Easing.Out);
 
-            ScheduleAfterChildren(() => GetContainingFocusManager().ChangeFocus(panel));
+            ScheduleAfterChildren(() => GetContainingFocusManager()!.ChangeFocus(panel));
         }
 
         protected override void PopOut()
diff --git a/osu.Game/Overlays/Mods/AddPresetPopover.cs b/osu.Game/Overlays/Mods/AddPresetPopover.cs
index 50aa5a2eb4..7df7d6339c 100644
--- a/osu.Game/Overlays/Mods/AddPresetPopover.cs
+++ b/osu.Game/Overlays/Mods/AddPresetPopover.cs
@@ -89,7 +89,7 @@ namespace osu.Game.Overlays.Mods
         {
             base.LoadComplete();
 
-            ScheduleAfterChildren(() => GetContainingFocusManager().ChangeFocus(nameTextBox));
+            ScheduleAfterChildren(() => GetContainingFocusManager()!.ChangeFocus(nameTextBox));
 
             nameTextBox.Current.BindValueChanged(s =>
             {
diff --git a/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs b/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
index 5b10a2844e..1f4e007f47 100644
--- a/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
+++ b/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
@@ -165,9 +165,7 @@ namespace osu.Game.Overlays.Mods
                     starRatingDisplay.FinishTransforms(true);
             });
 
-            double rate = 1;
-            foreach (var mod in Mods.Value.OfType<IApplicableToRate>())
-                rate = mod.ApplyToRate(0, rate);
+            double rate = ModUtils.CalculateRateWithMods(Mods.Value);
 
             bpmDisplay.Current.Value = FormatUtils.RoundBPM(BeatmapInfo.Value.BPM, rate);
 
diff --git a/osu.Game/Overlays/Mods/EditPresetPopover.cs b/osu.Game/Overlays/Mods/EditPresetPopover.cs
index 8fa6b35162..526ab6fc63 100644
--- a/osu.Game/Overlays/Mods/EditPresetPopover.cs
+++ b/osu.Game/Overlays/Mods/EditPresetPopover.cs
@@ -136,7 +136,7 @@ namespace osu.Game.Overlays.Mods
         {
             base.LoadComplete();
 
-            ScheduleAfterChildren(() => GetContainingFocusManager().ChangeFocus(nameTextBox));
+            ScheduleAfterChildren(() => GetContainingFocusManager()!.ChangeFocus(nameTextBox));
         }
 
         public override bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
diff --git a/osu.Game/Overlays/Mods/IncompatibilityDisplayingModPanel.cs b/osu.Game/Overlays/Mods/IncompatibilityDisplayingModPanel.cs
index 26c5b2ac49..84336319b7 100644
--- a/osu.Game/Overlays/Mods/IncompatibilityDisplayingModPanel.cs
+++ b/osu.Game/Overlays/Mods/IncompatibilityDisplayingModPanel.cs
@@ -16,6 +16,9 @@ namespace osu.Game.Overlays.Mods
     {
         private readonly BindableBool incompatible = new BindableBool();
 
+        [Resolved]
+        private OverlayColourProvider overlayColourProvider { get; set; } = null!;
+
         [Resolved]
         private Bindable<IReadOnlyList<Mod>> selectedMods { get; set; } = null!;
 
@@ -55,7 +58,7 @@ namespace osu.Game.Overlays.Mods
 
         #region IHasCustomTooltip
 
-        public ITooltip<Mod> GetCustomTooltip() => new IncompatibilityDisplayingTooltip();
+        public ITooltip<Mod> GetCustomTooltip() => new IncompatibilityDisplayingTooltip(overlayColourProvider);
 
         public Mod TooltipContent => Mod;
 
diff --git a/osu.Game/Overlays/Mods/IncompatibilityDisplayingTooltip.cs b/osu.Game/Overlays/Mods/IncompatibilityDisplayingTooltip.cs
index 2f82711162..3ac541eaa3 100644
--- a/osu.Game/Overlays/Mods/IncompatibilityDisplayingTooltip.cs
+++ b/osu.Game/Overlays/Mods/IncompatibilityDisplayingTooltip.cs
@@ -24,13 +24,15 @@ namespace osu.Game.Overlays.Mods
         [Resolved]
         private Bindable<RulesetInfo> ruleset { get; set; } = null!;
 
-        public IncompatibilityDisplayingTooltip()
+        public IncompatibilityDisplayingTooltip(OverlayColourProvider colourProvider)
+            : base(colourProvider)
         {
             AddRange(new Drawable[]
             {
                 incompatibleText = new OsuSpriteText
                 {
                     Margin = new MarginPadding { Top = 5 },
+                    Colour = colourProvider.Content2,
                     Font = OsuFont.GetFont(weight: FontWeight.Regular),
                     Text = "Incompatible with:"
                 },
@@ -43,12 +45,6 @@ namespace osu.Game.Overlays.Mods
             });
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            incompatibleText.Colour = colours.BlueLight;
-        }
-
         protected override void UpdateDisplay(Mod mod)
         {
             base.UpdateDisplay(mod);
diff --git a/osu.Game/Overlays/Mods/ModButtonTooltip.cs b/osu.Game/Overlays/Mods/ModButtonTooltip.cs
index 52b27f1e00..061c3e3e3a 100644
--- a/osu.Game/Overlays/Mods/ModButtonTooltip.cs
+++ b/osu.Game/Overlays/Mods/ModButtonTooltip.cs
@@ -1,9 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
@@ -18,11 +15,10 @@ namespace osu.Game.Overlays.Mods
     public partial class ModButtonTooltip : VisibilityContainer, ITooltip<Mod>
     {
         private readonly OsuSpriteText descriptionText;
-        private readonly Box background;
 
         protected override Container<Drawable> Content { get; }
 
-        public ModButtonTooltip()
+        public ModButtonTooltip(OverlayColourProvider colourProvider)
         {
             AutoSizeAxes = Axes.Both;
             Masking = true;
@@ -30,9 +26,10 @@ namespace osu.Game.Overlays.Mods
 
             InternalChildren = new Drawable[]
             {
-                background = new Box
+                new Box
                 {
-                    RelativeSizeAxes = Axes.Both
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background6,
                 },
                 Content = new FillFlowContainer
                 {
@@ -43,6 +40,7 @@ namespace osu.Game.Overlays.Mods
                     {
                         descriptionText = new OsuSpriteText
                         {
+                            Colour = colourProvider.Content1,
                             Font = OsuFont.GetFont(weight: FontWeight.Regular),
                         },
                     }
@@ -50,17 +48,10 @@ namespace osu.Game.Overlays.Mods
             };
         }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            background.Colour = colours.Gray3;
-            descriptionText.Colour = colours.BlueLighter;
-        }
-
         protected override void PopIn() => this.FadeIn(200, Easing.OutQuint);
         protected override void PopOut() => this.FadeOut(200, Easing.OutQuint);
 
-        private Mod lastMod;
+        private Mod? lastMod;
 
         public void SetContent(Mod mod)
         {
diff --git a/osu.Game/Overlays/Mods/ModPresetTooltip.cs b/osu.Game/Overlays/Mods/ModPresetTooltip.cs
index 077bd14751..ec81aa7ceb 100644
--- a/osu.Game/Overlays/Mods/ModPresetTooltip.cs
+++ b/osu.Game/Overlays/Mods/ModPresetTooltip.cs
@@ -6,6 +6,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using osuTK;
 
@@ -17,6 +19,8 @@ namespace osu.Game.Overlays.Mods
 
         private const double transition_duration = 200;
 
+        private readonly OsuSpriteText descriptionText;
+
         public ModPresetTooltip(OverlayColourProvider colourProvider)
         {
             Width = 250;
@@ -36,8 +40,16 @@ namespace osu.Game.Overlays.Mods
                 {
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
-                    Padding = new MarginPadding(7),
-                    Spacing = new Vector2(7)
+                    Padding = new MarginPadding { Left = 10, Right = 10, Top = 5, Bottom = 5 },
+                    Spacing = new Vector2(7),
+                    Children = new[]
+                    {
+                        descriptionText = new OsuSpriteText
+                        {
+                            Font = OsuFont.GetFont(weight: FontWeight.Regular),
+                            Colour = colourProvider.Content1,
+                        },
+                    }
                 }
             };
         }
@@ -49,8 +61,12 @@ namespace osu.Game.Overlays.Mods
             if (ReferenceEquals(preset, lastPreset))
                 return;
 
+            descriptionText.Text = preset.Description;
+
             lastPreset = preset;
-            Content.ChildrenEnumerable = preset.Mods.AsOrdered().Select(mod => new ModPresetRow(mod));
+
+            Content.RemoveAll(d => d is ModPresetRow, true);
+            Content.AddRange(preset.Mods.AsOrdered().Select(mod => new ModPresetRow(mod)));
         }
 
         protected override void PopIn() => this.FadeIn(transition_duration, Easing.OutQuint);
diff --git a/osu.Game/Overlays/Mods/ModSelectOverlay.cs b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
index 0dccc88ea0..145f58fb55 100644
--- a/osu.Game/Overlays/Mods/ModSelectOverlay.cs
+++ b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
@@ -949,7 +949,7 @@ namespace osu.Game.Overlays.Mods
                     RequestScroll?.Invoke(this);
 
                 // Killing focus is done here because it's the only feasible place on ModSelectOverlay you can click on without triggering any action.
-                Scheduler.Add(() => GetContainingFocusManager().ChangeFocus(null));
+                Scheduler.Add(() => GetContainingFocusManager()!.ChangeFocus(null));
 
                 return true;
             }
diff --git a/osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.cs b/osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.cs
index 3f6eeca10e..ddf831c23e 100644
--- a/osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.cs
+++ b/osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.cs
@@ -465,7 +465,7 @@ namespace osu.Game.Overlays.Settings.Sections.Input
             }
 
             if (HasFocus)
-                GetContainingFocusManager().ChangeFocus(null);
+                GetContainingFocusManager()!.ChangeFocus(null);
 
             cancelAndClearButtons.FadeOut(300, Easing.OutQuint);
             cancelAndClearButtons.BypassAutoSizeAxes |= Axes.Y;
diff --git a/osu.Game/Overlays/Settings/Sections/Input/KeyBindingsSubsection.cs b/osu.Game/Overlays/Settings/Sections/Input/KeyBindingsSubsection.cs
index db3b56b9f0..cde9f10549 100644
--- a/osu.Game/Overlays/Settings/Sections/Input/KeyBindingsSubsection.cs
+++ b/osu.Game/Overlays/Settings/Sections/Input/KeyBindingsSubsection.cs
@@ -106,7 +106,7 @@ namespace osu.Game.Overlays.Settings.Sections.Input
             {
                 var next = Children.SkipWhile(c => c != sender).Skip(1).FirstOrDefault();
                 if (next != null)
-                    GetContainingFocusManager().ChangeFocus(next);
+                    GetContainingFocusManager()?.ChangeFocus(next);
             }
         }
     }
diff --git a/osu.Game/Overlays/SettingsPanel.cs b/osu.Game/Overlays/SettingsPanel.cs
index d5c642d24f..df50e0f339 100644
--- a/osu.Game/Overlays/SettingsPanel.cs
+++ b/osu.Game/Overlays/SettingsPanel.cs
@@ -201,7 +201,7 @@ namespace osu.Game.Overlays
 
             searchTextBox.HoldFocus = false;
             if (searchTextBox.HasFocus)
-                GetContainingFocusManager().ChangeFocus(null);
+                GetContainingFocusManager()!.ChangeFocus(null);
         }
 
         public override bool AcceptsFocus => true;
diff --git a/osu.Game/Overlays/SkinEditor/SkinEditor.cs b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
index 67fd6a9550..484af34603 100644
--- a/osu.Game/Overlays/SkinEditor/SkinEditor.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
@@ -540,6 +540,8 @@ namespace osu.Game.Overlays.SkinEditor
 
         protected void Redo() => changeHandler?.RestoreState(1);
 
+        void IEditorChangeHandler.RestoreState(int direction) => changeHandler?.RestoreState(direction);
+
         public void Save(bool userTriggered = true) => save(currentSkin.Value, userTriggered);
 
         private void save(Skin skin, bool userTriggered = true)
@@ -667,7 +669,7 @@ namespace osu.Game.Overlays.SkinEditor
                 {
                     SpriteName = { Value = file.Name },
                     Origin = Anchor.Centre,
-                    Position = skinnableTarget.ToLocalSpace(GetContainingInputManager().CurrentState.Mouse.Position),
+                    Position = skinnableTarget.ToLocalSpace(GetContainingInputManager()!.CurrentState.Mouse.Position),
                 };
 
                 SelectedComponents.Clear();
diff --git a/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs b/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
index 6a118a73a8..36b38543d1 100644
--- a/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinSelectionRotationHandler.cs
@@ -61,6 +61,8 @@ namespace osu.Game.Overlays.SkinEditor
             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;
+
+            base.Begin();
         }
 
         public override void Update(float rotation, Vector2? origin = null)
@@ -99,6 +101,8 @@ namespace osu.Game.Overlays.SkinEditor
             originalPositions = null;
             originalRotations = null;
             defaultOrigin = null;
+
+            base.Commit();
         }
     }
 }
diff --git a/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs b/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
index d37cfc28b9..4c6a4cc9c2 100644
--- a/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
+++ b/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
@@ -9,6 +9,7 @@ using System.Linq;
 using System.Threading;
 using JetBrains.Annotations;
 using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -109,26 +110,24 @@ namespace osu.Game.Rulesets.Difficulty
             var progressiveBeatmap = new ProgressiveCalculationBeatmap(Beatmap);
             var difficultyObjects = getDifficultyHitObjects().ToArray();
 
-            foreach (var obj in difficultyObjects)
+            int currentIndex = 0;
+
+            foreach (var obj in Beatmap.HitObjects)
             {
-                // Implementations expect the progressive beatmap to only contain top-level objects from the original beatmap.
-                // At the same time, we also need to consider the possibility DHOs may not be generated for any given object,
-                // so we'll add all remaining objects up to the current point in time to the progressive beatmap.
-                for (int i = progressiveBeatmap.HitObjects.Count; i < Beatmap.HitObjects.Count; i++)
-                {
-                    if (obj != difficultyObjects[^1] && Beatmap.HitObjects[i].StartTime > obj.BaseObject.StartTime)
-                        break;
+                progressiveBeatmap.HitObjects.Add(obj);
 
-                    progressiveBeatmap.HitObjects.Add(Beatmap.HitObjects[i]);
+                while (currentIndex < difficultyObjects.Length && difficultyObjects[currentIndex].BaseObject.GetEndTime() <= obj.GetEndTime())
+                {
+                    foreach (var skill in skills)
+                    {
+                        cancellationToken.ThrowIfCancellationRequested();
+                        skill.Process(difficultyObjects[currentIndex]);
+                    }
+
+                    currentIndex++;
                 }
 
-                foreach (var skill in skills)
-                {
-                    cancellationToken.ThrowIfCancellationRequested();
-                    skill.Process(obj);
-                }
-
-                attribs.Add(new TimedDifficultyAttributes(obj.EndTime * clockRate, CreateDifficultyAttributes(progressiveBeatmap, playableMods, skills, clockRate)));
+                attribs.Add(new TimedDifficultyAttributes(obj.GetEndTime(), CreateDifficultyAttributes(progressiveBeatmap, playableMods, skills, clockRate)));
             }
 
             return attribs;
@@ -329,7 +328,7 @@ namespace osu.Game.Rulesets.Difficulty
                 set => baseBeatmap.Difficulty = value;
             }
 
-            public List<BreakPeriod> Breaks => baseBeatmap.Breaks;
+            public BindableList<BreakPeriod> Breaks => baseBeatmap.Breaks;
             public List<string> UnhandledEventLines => baseBeatmap.UnhandledEventLines;
 
             public double TotalBreakTime => baseBeatmap.TotalBreakTime;
diff --git a/osu.Game/Rulesets/Edit/Checks/CheckBreaks.cs b/osu.Game/Rulesets/Edit/Checks/CheckBreaks.cs
index 0842ff5453..f7be36beab 100644
--- a/osu.Game/Rulesets/Edit/Checks/CheckBreaks.cs
+++ b/osu.Game/Rulesets/Edit/Checks/CheckBreaks.cs
@@ -13,13 +13,7 @@ namespace osu.Game.Rulesets.Edit.Checks
     {
         // Breaks may be off by 1 ms.
         private const int leniency_threshold = 1;
-        private const double minimum_gap_before_break = 200;
 
-        // Break end time depends on the upcoming object's pre-empt time.
-        // As things stand, "pre-empt time" is only defined for osu! standard
-        // This is a generic value representing AR=10
-        // Relevant: https://github.com/ppy/osu/issues/14330#issuecomment-1002158551
-        private const double min_end_threshold = 450;
         public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Events, "Breaks not achievable using the editor");
 
         public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
@@ -45,8 +39,8 @@ namespace osu.Game.Rulesets.Edit.Checks
                 if (previousObjectEndTimeIndex >= 0)
                 {
                     double gapBeforeBreak = breakPeriod.StartTime - endTimes[previousObjectEndTimeIndex];
-                    if (gapBeforeBreak < minimum_gap_before_break - leniency_threshold)
-                        yield return new IssueTemplateEarlyStart(this).Create(breakPeriod.StartTime, minimum_gap_before_break - gapBeforeBreak);
+                    if (gapBeforeBreak < BreakPeriod.GAP_BEFORE_BREAK - leniency_threshold)
+                        yield return new IssueTemplateEarlyStart(this).Create(breakPeriod.StartTime, BreakPeriod.GAP_BEFORE_BREAK - gapBeforeBreak);
                 }
 
                 int nextObjectStartTimeIndex = startTimes.BinarySearch(breakPeriod.EndTime);
@@ -55,8 +49,8 @@ namespace osu.Game.Rulesets.Edit.Checks
                 if (nextObjectStartTimeIndex < startTimes.Count)
                 {
                     double gapAfterBreak = startTimes[nextObjectStartTimeIndex] - breakPeriod.EndTime;
-                    if (gapAfterBreak < min_end_threshold - leniency_threshold)
-                        yield return new IssueTemplateLateEnd(this).Create(breakPeriod.StartTime, min_end_threshold - gapAfterBreak);
+                    if (gapAfterBreak < BreakPeriod.GAP_AFTER_BREAK - leniency_threshold)
+                        yield return new IssueTemplateLateEnd(this).Create(breakPeriod.StartTime, BreakPeriod.GAP_AFTER_BREAK - gapAfterBreak);
                 }
             }
         }
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index 4d92a08bed..540e0440c6 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -7,6 +7,7 @@ using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Linq;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.EnumExtensions;
@@ -66,7 +67,8 @@ namespace osu.Game.Rulesets.Edit
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; }
 
-        protected ComposeBlueprintContainer BlueprintContainer { get; private set; }
+        public override ComposeBlueprintContainer BlueprintContainer => blueprintContainer;
+        private ComposeBlueprintContainer blueprintContainer;
 
         protected ExpandingToolboxContainer LeftToolbox { get; private set; }
 
@@ -78,14 +80,16 @@ namespace osu.Game.Rulesets.Edit
 
         protected InputManager InputManager { get; private set; }
 
+        private Box leftToolboxBackground;
+        private Box rightToolboxBackground;
+
         private EditorRadioButtonCollection toolboxCollection;
-
         private FillFlowContainer togglesCollection;
-
         private FillFlowContainer sampleBankTogglesCollection;
 
         private IBindable<bool> hasTiming;
         private Bindable<bool> autoSeekOnPlacement;
+        private readonly Bindable<bool> composerFocusMode = new Bindable<bool>();
 
         protected DrawableRuleset<TObject> DrawableRuleset { get; private set; }
 
@@ -97,11 +101,14 @@ namespace osu.Game.Rulesets.Edit
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
             dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        [BackgroundDependencyLoader(true)]
+        private void load(OsuConfigManager config, [CanBeNull] Editor editor)
         {
             autoSeekOnPlacement = config.GetBindable<bool>(OsuSetting.EditorAutoSeekOnPlacement);
 
+            if (editor != null)
+                composerFocusMode.BindTo(editor.ComposerFocusMode);
+
             Config = Dependencies.Get<IRulesetConfigCache>().GetConfigFor(Ruleset);
 
             try
@@ -126,7 +133,7 @@ namespace osu.Game.Rulesets.Edit
 
             InternalChildren = new[]
             {
-                PlayfieldContentContainer = new Container
+                PlayfieldContentContainer = new ContentContainer
                 {
                     Name = "Playfield content",
                     RelativeSizeAxes = Axes.Y,
@@ -137,7 +144,7 @@ namespace osu.Game.Rulesets.Edit
                         drawableRulesetWrapper,
                         // layers above playfield
                         drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer()
-                                              .WithChild(BlueprintContainer = CreateBlueprintContainer())
+                                              .WithChild(blueprintContainer = CreateBlueprintContainer())
                     }
                 },
                 new Container
@@ -146,7 +153,7 @@ namespace osu.Game.Rulesets.Edit
                     AutoSizeAxes = Axes.X,
                     Children = new Drawable[]
                     {
-                        new Box
+                        leftToolboxBackground = new Box
                         {
                             Colour = colourProvider.Background5,
                             RelativeSizeAxes = Axes.Both,
@@ -191,7 +198,7 @@ namespace osu.Game.Rulesets.Edit
                     AutoSizeAxes = Axes.X,
                     Children = new Drawable[]
                     {
-                        new Box
+                        rightToolboxBackground = new Box
                         {
                             Colour = colourProvider.Background5,
                             RelativeSizeAxes = Axes.Both,
@@ -200,7 +207,7 @@ namespace osu.Game.Rulesets.Edit
                         {
                             Child = new EditorToolboxGroup("inspector")
                             {
-                                Child = new HitObjectInspector()
+                                Child = CreateHitObjectInspector()
                             },
                         }
                     }
@@ -260,6 +267,13 @@ namespace osu.Game.Rulesets.Edit
                     item.Selected.Disabled = !hasTiming.NewValue;
                 }
             }, true);
+
+            composerFocusMode.BindValueChanged(_ =>
+            {
+                float targetAlpha = composerFocusMode.Value ? 0.5f : 1;
+                leftToolboxBackground.FadeTo(targetAlpha, 400, Easing.OutQuint);
+                rightToolboxBackground.FadeTo(targetAlpha, 400, Easing.OutQuint);
+            }, true);
         }
 
         protected override void Update()
@@ -315,6 +329,8 @@ namespace osu.Game.Rulesets.Edit
         /// </summary>
         protected virtual ComposeBlueprintContainer CreateBlueprintContainer() => new ComposeBlueprintContainer(this);
 
+        protected virtual Drawable CreateHitObjectInspector() => new HitObjectInspector();
+
         /// <summary>
         /// Construct a drawable ruleset for the provided ruleset.
         /// </summary>
@@ -507,6 +523,31 @@ namespace osu.Game.Rulesets.Edit
         }
 
         #endregion
+
+        private partial class ContentContainer : Container
+        {
+            public override bool HandlePositionalInput => true;
+
+            private readonly Bindable<bool> composerFocusMode = new Bindable<bool>();
+
+            [BackgroundDependencyLoader(true)]
+            private void load([CanBeNull] Editor editor)
+            {
+                if (editor != null)
+                    composerFocusMode.BindTo(editor.ComposerFocusMode);
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                composerFocusMode.Value = true;
+                return false;
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                composerFocusMode.Value = false;
+            }
+        }
     }
 
     /// <summary>
@@ -532,6 +573,8 @@ namespace osu.Game.Rulesets.Edit
         /// </summary>
         public abstract Playfield Playfield { get; }
 
+        public abstract ComposeBlueprintContainer BlueprintContainer { get; }
+
         /// <summary>
         /// All <see cref="DrawableHitObject"/>s in currently loaded beatmap.
         /// </summary>
diff --git a/osu.Game/Rulesets/Edit/ScrollingHitObjectComposer.cs b/osu.Game/Rulesets/Edit/ScrollingHitObjectComposer.cs
index eb73cef01a..223b770b48 100644
--- a/osu.Game/Rulesets/Edit/ScrollingHitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/ScrollingHitObjectComposer.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -12,6 +13,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
@@ -21,6 +23,9 @@ namespace osu.Game.Rulesets.Edit
     public abstract partial class ScrollingHitObjectComposer<TObject> : HitObjectComposer<TObject>
         where TObject : HitObject
     {
+        [Resolved]
+        private Editor? editor { get; set; }
+
         private readonly Bindable<TernaryState> showSpeedChanges = new Bindable<TernaryState>();
         private Bindable<bool> configShowSpeedChanges = null!;
 
@@ -72,6 +77,8 @@ namespace osu.Game.Rulesets.Edit
 
             if (beatSnapGrid != null)
                 AddInternal(beatSnapGrid);
+
+            EditorBeatmap.ControlPointInfo.ControlPointsChanged += expireComposeScreenOnControlPointChange;
         }
 
         protected override void UpdateAfterChildren()
@@ -104,5 +111,15 @@ namespace osu.Game.Rulesets.Edit
                     beatSnapGrid.SelectionTimeRange = null;
             }
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (EditorBeatmap.IsNotNull())
+                EditorBeatmap.ControlPointInfo.ControlPointsChanged -= expireComposeScreenOnControlPointChange;
+        }
+
+        private void expireComposeScreenOnControlPointChange() => editor?.ReloadComposeScreen();
     }
 }
diff --git a/osu.Game/Rulesets/Mods/Mod.cs b/osu.Game/Rulesets/Mods/Mod.cs
index 50c867f41b..b9a937b1a2 100644
--- a/osu.Game/Rulesets/Mods/Mod.cs
+++ b/osu.Game/Rulesets/Mods/Mod.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
@@ -21,6 +22,7 @@ namespace osu.Game.Rulesets.Mods
     /// <summary>
     /// The base class for gameplay modifiers.
     /// </summary>
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
     public abstract class Mod : IMod, IEquatable<Mod>, IDeepCloneable<Mod>
     {
         [JsonIgnore]
diff --git a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
index 3ce6cc3cef..1f735576bc 100644
--- a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
@@ -314,11 +314,11 @@ namespace osu.Game.Rulesets.Objects.Drawables
         private void updateStateFromResult()
         {
             if (Result.IsHit)
-                updateState(ArmedState.Hit, true);
+                UpdateState(ArmedState.Hit, true);
             else if (Result.HasResult)
-                updateState(ArmedState.Miss, true);
+                UpdateState(ArmedState.Miss, true);
             else
-                updateState(ArmedState.Idle, true);
+                UpdateState(ArmedState.Idle, true);
         }
 
         protected sealed override void OnFree(HitObjectLifetimeEntry entry)
@@ -402,7 +402,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         private void onRevertResult()
         {
-            updateState(ArmedState.Idle);
+            UpdateState(ArmedState.Idle);
             OnRevertResult?.Invoke(this, Result);
         }
 
@@ -421,7 +421,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
             if (Result is not null)
             {
                 Result.TimeOffset = 0;
-                updateState(State.Value, true);
+                UpdateState(State.Value, true);
             }
 
             DefaultsApplied?.Invoke(this);
@@ -461,7 +461,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
             throw new InvalidOperationException(
                 $"Should never clear a {nameof(DrawableHitObject)} as the base implementation adds components. If attempting to use {nameof(InternalChild)} or {nameof(InternalChildren)}, using {nameof(AddInternal)} or {nameof(AddRangeInternal)} instead.");
 
-        private void updateState(ArmedState newState, bool force = false)
+        protected void UpdateState(ArmedState newState, bool force = false)
         {
             if (State.Value == newState && !force)
                 return;
@@ -506,7 +506,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <summary>
         /// Reapplies the current <see cref="ArmedState"/>.
         /// </summary>
-        public void RefreshStateTransforms() => updateState(State.Value, true);
+        public void RefreshStateTransforms() => UpdateState(State.Value, true);
 
         /// <summary>
         /// Apply (generally fade-in) transforms leading into the <see cref="HitObject"/> start time.
@@ -565,7 +565,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
             ApplySkin(CurrentSkin, true);
 
             if (IsLoaded)
-                updateState(State.Value, true);
+                UpdateState(State.Value, true);
         }
 
         protected void UpdateComboColour()
@@ -725,7 +725,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
             Result.GameplayRate = (Clock as IGameplayClock)?.GetTrueGameplayRate() ?? Clock.Rate;
 
             if (Result.HasResult)
-                updateState(Result.IsHit ? ArmedState.Hit : ArmedState.Miss);
+                UpdateState(Result.IsHit ? ArmedState.Hit : ArmedState.Miss);
 
             OnNewResult?.Invoke(this, Result);
         }
diff --git a/osu.Game/Rulesets/Objects/HitObject.cs b/osu.Game/Rulesets/Objects/HitObject.cs
index 04bdc35941..c547a7a718 100644
--- a/osu.Game/Rulesets/Objects/HitObject.cs
+++ b/osu.Game/Rulesets/Objects/HitObject.cs
@@ -12,6 +12,7 @@ using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.ListExtensions;
+using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Lists;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
@@ -223,11 +224,21 @@ namespace osu.Game.Rulesets.Objects
         /// <returns>A populated <see cref="HitSampleInfo"/>.</returns>
         public HitSampleInfo CreateHitSampleInfo(string sampleName = HitSampleInfo.HIT_NORMAL)
         {
-            if (Samples.FirstOrDefault(s => s.Name == HitSampleInfo.HIT_NORMAL) is HitSampleInfo existingSample)
-                return existingSample.With(newName: sampleName);
+            // As per stable, all non-normal "addition" samples should use the same bank.
+            if (sampleName != HitSampleInfo.HIT_NORMAL)
+            {
+                if (Samples.FirstOrDefault(s => s.Name != HitSampleInfo.HIT_NORMAL) is HitSampleInfo existingAddition)
+                    return existingAddition.With(newName: sampleName);
+            }
+
+            // Fall back to using the normal sample bank otherwise.
+            if (Samples.FirstOrDefault(s => s.Name == HitSampleInfo.HIT_NORMAL) is HitSampleInfo existingNormal)
+                return existingNormal.With(newName: sampleName);
 
             return new HitSampleInfo(sampleName);
         }
+
+        public override string ToString() => $"{GetType().ReadableName()} @ {StartTime}";
     }
 
     public static class HitObjectExtensions
diff --git a/osu.Game/Rulesets/Objects/Types/IHasRepeats.cs b/osu.Game/Rulesets/Objects/Types/IHasRepeats.cs
index 2a4215b960..9677ac4fbd 100644
--- a/osu.Game/Rulesets/Objects/Types/IHasRepeats.cs
+++ b/osu.Game/Rulesets/Objects/Types/IHasRepeats.cs
@@ -3,6 +3,7 @@
 
 using osu.Game.Audio;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace osu.Game.Rulesets.Objects.Types
 {
@@ -45,5 +46,19 @@ namespace osu.Game.Rulesets.Objects.Types
         public static IList<HitSampleInfo> GetNodeSamples<T>(this T obj, int nodeIndex)
             where T : HitObject, IHasRepeats
             => nodeIndex < obj.NodeSamples.Count ? obj.NodeSamples[nodeIndex] : obj.Samples;
+
+        /// <summary>
+        /// Ensures that the list of node samples is at least as long as the number of nodes.
+        /// </summary>
+        /// <param name="obj">The <see cref="HitObject"/>.</param>
+        public static void PopulateNodeSamples<T>(this T obj)
+            where T : HitObject, IHasRepeats
+        {
+            if (obj.NodeSamples.Count >= obj.RepeatCount + 2)
+                return;
+
+            while (obj.NodeSamples.Count < obj.RepeatCount + 2)
+                obj.NodeSamples.Add(obj.Samples.Select(o => o.With()).ToList());
+        }
     }
 }
diff --git a/osu.Game/Rulesets/Ruleset.cs b/osu.Game/Rulesets/Ruleset.cs
index c7d4779064..31131e05ad 100644
--- a/osu.Game/Rulesets/Ruleset.cs
+++ b/osu.Game/Rulesets/Ruleset.cs
@@ -413,6 +413,6 @@ namespace osu.Game.Rulesets
         /// <summary>
         /// Can be overridden to alter the difficulty section to the editor beatmap setup screen.
         /// </summary>
-        public virtual DifficultySection? CreateEditorDifficultySection() => null;
+        public virtual SetupSection? CreateEditorDifficultySection() => null;
     }
 }
diff --git a/osu.Game/Rulesets/Scoring/HealthProcessor.cs b/osu.Game/Rulesets/Scoring/HealthProcessor.cs
index 9e4c06b783..2799cd4b36 100644
--- a/osu.Game/Rulesets/Scoring/HealthProcessor.cs
+++ b/osu.Game/Rulesets/Scoring/HealthProcessor.cs
@@ -36,6 +36,9 @@ namespace osu.Game.Rulesets.Scoring
         /// </summary>
         public void TriggerFailure()
         {
+            if (HasFailed)
+                return;
+
             if (Failed?.Invoke() != false)
                 HasFailed = true;
         }
diff --git a/osu.Game/Rulesets/Scoring/ScoreProcessor.cs b/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
index 70d7f0fe37..44ddb8c187 100644
--- a/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
+++ b/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
@@ -369,9 +369,9 @@ namespace osu.Game.Rulesets.Scoring
             MaximumAccuracy.Value = maximumBaseScore > 0 ? (currentBaseScore + (maximumBaseScore - currentMaximumBaseScore)) / maximumBaseScore : 1;
 
             double comboProgress = maximumComboPortion > 0 ? currentComboPortion / maximumComboPortion : 1;
-            double accuracyProcess = maximumAccuracyJudgementCount > 0 ? (double)currentAccuracyJudgementCount / maximumAccuracyJudgementCount : 1;
+            double accuracyProgress = maximumAccuracyJudgementCount > 0 ? (double)currentAccuracyJudgementCount / maximumAccuracyJudgementCount : 1;
 
-            TotalScoreWithoutMods.Value = (long)Math.Round(ComputeTotalScore(comboProgress, accuracyProcess, currentBonusPortion));
+            TotalScoreWithoutMods.Value = (long)Math.Round(ComputeTotalScore(comboProgress, accuracyProgress, currentBonusPortion));
             TotalScore.Value = (long)Math.Round(TotalScoreWithoutMods.Value * scoreMultiplier);
         }
 
@@ -381,9 +381,12 @@ namespace osu.Game.Rulesets.Scoring
             if (rank.Value == ScoreRank.F)
                 return;
 
-            rank.Value = RankFromScore(Accuracy.Value, ScoreResultCounts);
+            ScoreRank newRank = RankFromScore(Accuracy.Value, ScoreResultCounts);
+
             foreach (var mod in Mods.Value.OfType<IApplicableToScoreProcessor>())
-                rank.Value = mod.AdjustRank(Rank.Value, Accuracy.Value);
+                newRank = mod.AdjustRank(newRank, Accuracy.Value);
+
+            rank.Value = newRank;
         }
 
         protected virtual double ComputeTotalScore(double comboProgress, double accuracyProgress, double bonusPortion)
diff --git a/osu.Game/Rulesets/UI/ModSwitchTiny.cs b/osu.Game/Rulesets/UI/ModSwitchTiny.cs
index 4d50e702af..4a3bc9e31b 100644
--- a/osu.Game/Rulesets/UI/ModSwitchTiny.cs
+++ b/osu.Game/Rulesets/UI/ModSwitchTiny.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.UI
         public BindableBool Active { get; } = new BindableBool();
 
         public const float DEFAULT_HEIGHT = 30;
-        private const float width = 73;
+        public const float WIDTH = 73;
 
         protected readonly IMod Mod;
         private readonly bool showExtendedInformation;
@@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.UI
                     Width = 100 + DEFAULT_HEIGHT / 2,
                     RelativeSizeAxes = Axes.Y,
                     Masking = true,
-                    X = width,
+                    X = WIDTH,
                     Margin = new MarginPadding { Left = -DEFAULT_HEIGHT },
                     Children = new Drawable[]
                     {
@@ -77,7 +77,7 @@ namespace osu.Game.Rulesets.UI
                 },
                 new CircularContainer
                 {
-                    Width = width,
+                    Width = WIDTH,
                     RelativeSizeAxes = Axes.Y,
                     Masking = true,
                     Children = new Drawable[]
diff --git a/osu.Game/Screens/Edit/BottomBar.cs b/osu.Game/Screens/Edit/BottomBar.cs
index bc7dfaab88..6118adc0d7 100644
--- a/osu.Game/Screens/Edit/BottomBar.cs
+++ b/osu.Game/Screens/Edit/BottomBar.cs
@@ -1,15 +1,13 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Overlays;
+using osu.Framework.Testing;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Screens.Edit.Components;
 using osu.Game.Screens.Edit.Components.Timelines.Summary;
@@ -20,10 +18,13 @@ namespace osu.Game.Screens.Edit
 {
     internal partial class BottomBar : CompositeDrawable
     {
-        public TestGameplayButton TestGameplayButton { get; private set; }
+        public TestGameplayButton TestGameplayButton { get; private set; } = null!;
+
+        private IBindable<bool> saveInProgress = null!;
+        private Bindable<bool> composerFocusMode = null!;
 
         [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colourProvider, Editor editor)
+        private void load(Editor editor)
         {
             Anchor = Anchor.BottomLeft;
             Origin = Anchor.BottomLeft;
@@ -42,11 +43,6 @@ namespace osu.Game.Screens.Edit
 
             InternalChildren = new Drawable[]
             {
-                new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Colour = colourProvider.Background4,
-                },
                 new GridContainer
                 {
                     RelativeSizeAxes = Axes.Both,
@@ -74,6 +70,23 @@ namespace osu.Game.Screens.Edit
                     }
                 }
             };
+
+            saveInProgress = editor.MutationTracker.InProgress.GetBoundCopy();
+            composerFocusMode = editor.ComposerFocusMode.GetBoundCopy();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            saveInProgress.BindValueChanged(_ => TestGameplayButton.Enabled.Value = !saveInProgress.Value, true);
+            composerFocusMode.BindValueChanged(_ =>
+            {
+                float targetAlpha = composerFocusMode.Value ? 0.5f : 1;
+
+                foreach (var c in this.ChildrenOfType<BottomBarContainer>())
+                    c.Background.FadeTo(targetAlpha, 400, Easing.OutQuint);
+            }, true);
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Components/BottomBarContainer.cs b/osu.Game/Screens/Edit/Components/BottomBarContainer.cs
index 0ba1ab9258..da71457004 100644
--- a/osu.Game/Screens/Edit/Components/BottomBarContainer.cs
+++ b/osu.Game/Screens/Edit/Components/BottomBarContainer.cs
@@ -20,7 +20,7 @@ namespace osu.Game.Screens.Edit.Components
 
         protected readonly IBindable<Track> Track = new Bindable<Track>();
 
-        protected readonly Drawable Background;
+        public readonly Drawable Background;
         private readonly Container content;
 
         protected override Container<Drawable> Content => content;
diff --git a/osu.Game/Screens/Edit/Components/EditorSidebarSection.cs b/osu.Game/Screens/Edit/Components/EditorSidebarSection.cs
index 279793c0a1..5dd8f78f6d 100644
--- a/osu.Game/Screens/Edit/Components/EditorSidebarSection.cs
+++ b/osu.Game/Screens/Edit/Components/EditorSidebarSection.cs
@@ -1,15 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
 using osu.Framework.Localisation;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Containers;
-using osu.Game.Overlays;
-using osuTK;
+using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Screens.Edit.Components
 {
@@ -38,46 +33,5 @@ namespace osu.Game.Screens.Edit.Components
                 }
             };
         }
-
-        public partial class SectionHeader : CompositeDrawable
-        {
-            private readonly LocalisableString text;
-
-            public SectionHeader(LocalisableString text)
-            {
-                this.text = text;
-
-                Margin = new MarginPadding { Vertical = 10, Horizontal = 5 };
-
-                RelativeSizeAxes = Axes.X;
-                AutoSizeAxes = Axes.Y;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load(OverlayColourProvider colourProvider)
-            {
-                InternalChild = new FillFlowContainer
-                {
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
-                    Direction = FillDirection.Vertical,
-                    Spacing = new Vector2(2),
-                    Children = new Drawable[]
-                    {
-                        new OsuTextFlowContainer(cp => cp.Font = OsuFont.Default.With(size: 16, weight: FontWeight.SemiBold))
-                        {
-                            Text = text,
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                        },
-                        new Circle
-                        {
-                            Colour = colourProvider.Highlight1,
-                            Size = new Vector2(28, 2),
-                        }
-                    }
-                };
-            }
-        }
     }
 }
diff --git a/osu.Game/Screens/Edit/Components/PlaybackControl.cs b/osu.Game/Screens/Edit/Components/PlaybackControl.cs
index a5ed0d680f..9e27f0e57d 100644
--- a/osu.Game/Screens/Edit/Components/PlaybackControl.cs
+++ b/osu.Game/Screens/Edit/Components/PlaybackControl.cs
@@ -32,8 +32,10 @@ namespace osu.Game.Screens.Edit.Components
         private readonly BindableNumber<double> freqAdjust = new BindableDouble(1);
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OverlayColourProvider colourProvider)
         {
+            Background.Colour = colourProvider.Background4;
+
             Children = new Drawable[]
             {
                 playButton = new IconButton
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BreakPart.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BreakPart.cs
index e502dd951b..ed42ade490 100644
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BreakPart.cs
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BreakPart.cs
@@ -2,9 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Graphics;
-using osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations;
 
 namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
 {
@@ -13,22 +15,34 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
     /// </summary>
     public partial class BreakPart : TimelinePart
     {
+        private readonly BindableList<BreakPeriod> breaks = new BindableList<BreakPeriod>();
+
         protected override void LoadBeatmap(EditorBeatmap beatmap)
         {
             base.LoadBeatmap(beatmap);
-            foreach (var breakPeriod in beatmap.Breaks)
-                Add(new BreakVisualisation(breakPeriod));
+
+            breaks.UnbindAll();
+            breaks.BindTo(beatmap.Breaks);
+            breaks.BindCollectionChanged((_, _) =>
+            {
+                Clear();
+                foreach (var breakPeriod in beatmap.Breaks)
+                    Add(new BreakVisualisation(breakPeriod));
+            }, true);
         }
 
-        private partial class BreakVisualisation : DurationVisualisation
+        private partial class BreakVisualisation : Circle
         {
             public BreakVisualisation(BreakPeriod breakPeriod)
-                : base(breakPeriod.StartTime, breakPeriod.EndTime)
             {
+                RelativePositionAxes = Axes.X;
+                RelativeSizeAxes = Axes.Both;
+                X = (float)breakPeriod.StartTime;
+                Width = (float)breakPeriod.Duration;
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuColour colours) => Colour = colours.GreyCarmineLight;
+            private void load(OsuColour colours) => Colour = colours.Gray7;
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/DurationVisualisation.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/DurationVisualisation.cs
deleted file mode 100644
index bfb50a05ea..0000000000
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/DurationVisualisation.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
-
-namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations
-{
-    /// <summary>
-    /// Represents a spanning point on a timeline part.
-    /// </summary>
-    public partial class DurationVisualisation : Circle
-    {
-        protected DurationVisualisation(double startTime, double endTime)
-        {
-            RelativePositionAxes = Axes.X;
-            RelativeSizeAxes = Axes.Both;
-
-            X = (float)startTime;
-            Width = (float)(endTime - startTime);
-        }
-    }
-}
diff --git a/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs b/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
index 005b96bfef..faab5e7f78 100644
--- a/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
@@ -580,7 +580,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             {
                 base.LoadComplete();
 
-                GetContainingFocusManager().ChangeFocus(this);
+                GetContainingFocusManager()!.ChangeFocus(this);
                 SelectAll();
             }
         }
diff --git a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
index 4fba798a26..fc8bce4c96 100644
--- a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
@@ -228,7 +228,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             yield return new TernaryButton(NewCombo, "New combo", () => new SpriteIcon { Icon = OsuIcon.EditorNewComboA });
 
             foreach (var kvp in SelectionHandler.SelectionSampleStates)
-                yield return new TernaryButton(kvp.Value, kvp.Key.Replace("hit", string.Empty).Titleize(), () => getIconForSample(kvp.Key));
+                yield return new TernaryButton(kvp.Value, kvp.Key.Replace("hit", string.Empty).Titleize(), () => GetIconForSample(kvp.Key));
         }
 
         private IEnumerable<TernaryButton> createSampleBankTernaryButtons()
@@ -264,7 +264,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             };
         }
 
-        private Drawable getIconForSample(string sampleName)
+        public static Drawable GetIconForSample(string sampleName)
         {
             switch (sampleName)
             {
@@ -372,7 +372,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }
         }
 
-        private void commitIfPlacementActive()
+        public void CommitIfPlacementActive()
         {
             CurrentPlacement?.EndPlacement(CurrentPlacement.PlacementActive == PlacementBlueprint.PlacementState.Active);
             removePlacement();
@@ -402,7 +402,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 currentTool = value;
 
                 // As per stable editor, when changing tools, we should forcefully commit any pending placement.
-                commitIfPlacementActive();
+                CommitIfPlacementActive();
             }
         }
     }
diff --git a/osu.Game/Screens/Edit/Compose/Components/EditorInspector.cs b/osu.Game/Screens/Edit/Compose/Components/EditorInspector.cs
index 442454f97a..5837dd7946 100644
--- a/osu.Game/Screens/Edit/Compose/Components/EditorInspector.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/EditorInspector.cs
@@ -10,7 +10,7 @@ using osu.Game.Overlays;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
-    internal partial class EditorInspector : CompositeDrawable
+    public partial class EditorInspector : CompositeDrawable
     {
         protected OsuTextFlowContainer InspectorText = null!;
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
index 7420362e19..7c30b73122 100644
--- a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
@@ -227,6 +227,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
                     return;
 
                 h.Samples.Add(h.CreateHitSampleInfo(sampleName));
+
                 EditorBeatmap.Update(h);
             });
         }
diff --git a/osu.Game/Screens/Edit/Compose/Components/HitObjectInspector.cs b/osu.Game/Screens/Edit/Compose/Components/HitObjectInspector.cs
index ac339dc9d9..2f19888e9e 100644
--- a/osu.Game/Screens/Edit/Compose/Components/HitObjectInspector.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/HitObjectInspector.cs
@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
-    internal partial class HitObjectInspector : EditorInspector
+    public partial class HitObjectInspector : EditorInspector
     {
         protected override void LoadComplete()
         {
@@ -29,6 +29,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
             rollingTextUpdate?.Cancel();
             rollingTextUpdate = null;
 
+            AddInspectorValues();
+
+            // I'd hope there's a better way to do this, but I don't want to bind to each and every property above to watch for changes.
+            // This is a good middle-ground for the time being.
+            if (EditorBeatmap.SelectedHitObjects.Count > 0)
+                rollingTextUpdate ??= Scheduler.AddDelayed(updateInspectorText, 250);
+        }
+
+        protected virtual void AddInspectorValues()
+        {
             switch (EditorBeatmap.SelectedHitObjects.Count)
             {
                 case 0:
@@ -90,9 +100,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
                         AddValue($"{duration.Duration:#,0.##}ms");
                     }
 
-                    // I'd hope there's a better way to do this, but I don't want to bind to each and every property above to watch for changes.
-                    // This is a good middle-ground for the time being.
-                    rollingTextUpdate ??= Scheduler.AddDelayed(updateInspectorText, 250);
                     break;
 
                 default:
diff --git a/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs
new file mode 100644
index 0000000000..79b4fa2841
--- /dev/null
+++ b/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs
@@ -0,0 +1,166 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Utils;
+using osuTK;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    public abstract partial class LinedPositionSnapGrid : PositionSnapGrid
+    {
+        protected void GenerateGridLines(Vector2 step, Vector2 drawSize)
+        {
+            if (Precision.AlmostEquals(step, Vector2.Zero))
+                return;
+
+            int index = 0;
+
+            // Make lines the same width independent of display resolution.
+            float lineWidth = DrawWidth / ScreenSpaceDrawQuad.Width;
+            float rotation = MathHelper.RadiansToDegrees(MathF.Atan2(step.Y, step.X));
+
+            List<Box> generatedLines = new List<Box>();
+
+            while (true)
+            {
+                Vector2 currentPosition = StartPosition.Value + index * step;
+                index++;
+
+                if (!lineDefinitelyIntersectsBox(currentPosition, step.PerpendicularLeft, drawSize, out var p1, out var p2))
+                {
+                    if (!isMovingTowardsBox(currentPosition, step, drawSize))
+                        break;
+
+                    continue;
+                }
+
+                var gridLine = new Box
+                {
+                    Colour = Colour4.White,
+                    Alpha = 0.1f,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.None,
+                    Width = lineWidth,
+                    Height = Vector2.Distance(p1, p2),
+                    Position = (p1 + p2) / 2,
+                    Rotation = rotation,
+                };
+
+                generatedLines.Add(gridLine);
+            }
+
+            if (generatedLines.Count == 0)
+                return;
+
+            generatedLines.First().Alpha = 0.2f;
+
+            AddRangeInternal(generatedLines);
+        }
+
+        private bool isMovingTowardsBox(Vector2 currentPosition, Vector2 step, Vector2 box)
+        {
+            return (currentPosition + step).LengthSquared < currentPosition.LengthSquared ||
+                   (currentPosition + step - box).LengthSquared < (currentPosition - box).LengthSquared;
+        }
+
+        /// <summary>
+        /// Determines if the line starting at <paramref name="lineStart"/> and going in the direction of <paramref name="lineDir"/>
+        /// definitely intersects the box on (0, 0) with the given width and height and returns the intersection points if it does.
+        /// </summary>
+        /// <param name="lineStart">The start point of the line.</param>
+        /// <param name="lineDir">The direction of the line.</param>
+        /// <param name="box">The width and height of the box.</param>
+        /// <param name="p1">The first intersection point.</param>
+        /// <param name="p2">The second intersection point.</param>
+        /// <returns>Whether the line definitely intersects the box.</returns>
+        private bool lineDefinitelyIntersectsBox(Vector2 lineStart, Vector2 lineDir, Vector2 box, out Vector2 p1, out Vector2 p2)
+        {
+            p1 = Vector2.Zero;
+            p2 = Vector2.Zero;
+
+            if (Precision.AlmostEquals(lineDir.X, 0))
+            {
+                // If the line is vertical, we only need to check if the X coordinate of the line is within the box.
+                if (!Precision.DefinitelyBigger(lineStart.X, 0) || !Precision.DefinitelyBigger(box.X, lineStart.X))
+                    return false;
+
+                p1 = new Vector2(lineStart.X, 0);
+                p2 = new Vector2(lineStart.X, box.Y);
+                return true;
+            }
+
+            if (Precision.AlmostEquals(lineDir.Y, 0))
+            {
+                // If the line is horizontal, we only need to check if the Y coordinate of the line is within the box.
+                if (!Precision.DefinitelyBigger(lineStart.Y, 0) || !Precision.DefinitelyBigger(box.Y, lineStart.Y))
+                    return false;
+
+                p1 = new Vector2(0, lineStart.Y);
+                p2 = new Vector2(box.X, lineStart.Y);
+                return true;
+            }
+
+            float m = lineDir.Y / lineDir.X;
+            float mInv = lineDir.X / lineDir.Y; // Use this to improve numerical stability if X is close to zero.
+            float b = lineStart.Y - m * lineStart.X;
+
+            // Calculate intersection points with the sides of the box.
+            var p = new List<Vector2>(4);
+
+            if (0 <= b && b <= box.Y)
+                p.Add(new Vector2(0, b));
+            if (0 <= (box.Y - b) * mInv && (box.Y - b) * mInv <= box.X)
+                p.Add(new Vector2((box.Y - b) * mInv, box.Y));
+            if (0 <= m * box.X + b && m * box.X + b <= box.Y)
+                p.Add(new Vector2(box.X, m * box.X + b));
+            if (0 <= -b * mInv && -b * mInv <= box.X)
+                p.Add(new Vector2(-b * mInv, 0));
+
+            switch (p.Count)
+            {
+                case 4:
+                    // If there are 4 intersection points, the line is a diagonal of the box.
+                    if (m > 0)
+                    {
+                        p1 = Vector2.Zero;
+                        p2 = box;
+                    }
+                    else
+                    {
+                        p1 = new Vector2(0, box.Y);
+                        p2 = new Vector2(box.X, 0);
+                    }
+
+                    break;
+
+                case 3:
+                    // If there are 3 intersection points, the line goes through a corner of the box.
+                    if (p[0] == p[1])
+                    {
+                        p1 = p[0];
+                        p2 = p[2];
+                    }
+                    else
+                    {
+                        p1 = p[0];
+                        p2 = p[1];
+                    }
+
+                    break;
+
+                case 2:
+                    p1 = p[0];
+                    p2 = p[1];
+
+                    break;
+            }
+
+            return !Precision.AlmostEquals(p1, p2);
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
new file mode 100644
index 0000000000..e576ac1e49
--- /dev/null
+++ b/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
@@ -0,0 +1,93 @@
+// Copyright (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.Shapes;
+using osu.Framework.Layout;
+using osuTK;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    public abstract partial class PositionSnapGrid : CompositeDrawable
+    {
+        /// <summary>
+        /// The position of the origin of this <see cref="PositionSnapGrid"/> in local coordinates.
+        /// </summary>
+        public Bindable<Vector2> StartPosition { get; } = new Bindable<Vector2>(Vector2.Zero);
+
+        protected readonly LayoutValue GridCache = new LayoutValue(Invalidation.RequiredParentSizeToFit);
+
+        protected PositionSnapGrid()
+        {
+            StartPosition.BindValueChanged(_ => GridCache.Invalidate());
+
+            AddLayout(GridCache);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (GridCache.IsValid) return;
+
+            ClearInternal();
+
+            if (DrawWidth > 0 && DrawHeight > 0)
+                CreateContent();
+
+            GridCache.Validate();
+        }
+
+        protected abstract void CreateContent();
+
+        protected void GenerateOutline(Vector2 drawSize)
+        {
+            // Make lines the same width independent of display resolution.
+            float lineWidth = DrawWidth / ScreenSpaceDrawQuad.Width;
+
+            AddRangeInternal(new[]
+            {
+                new Box
+                {
+                    Colour = Colour4.White,
+                    Alpha = 0.3f,
+                    Origin = Anchor.CentreLeft,
+                    RelativeSizeAxes = Axes.X,
+                    Height = lineWidth,
+                    Y = 0,
+                },
+                new Box
+                {
+                    Colour = Colour4.White,
+                    Alpha = 0.3f,
+                    Origin = Anchor.CentreLeft,
+                    RelativeSizeAxes = Axes.X,
+                    Height = lineWidth,
+                    Y = drawSize.Y,
+                },
+                new Box
+                {
+                    Colour = Colour4.White,
+                    Alpha = 0.3f,
+                    Origin = Anchor.TopCentre,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = lineWidth,
+                    X = 0,
+                },
+                new Box
+                {
+                    Colour = Colour4.White,
+                    Alpha = 0.3f,
+                    Origin = Anchor.TopCentre,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = lineWidth,
+                    X = drawSize.X,
+                },
+            });
+        }
+
+        public abstract Vector2 GetSnappedPosition(Vector2 original);
+    }
+}
diff --git a/osu.Game/Screens/Edit/Compose/Components/RectangularPositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/RectangularPositionSnapGrid.cs
index cfc01fe17b..3bf0ef8ac3 100644
--- a/osu.Game/Screens/Edit/Compose/Components/RectangularPositionSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/RectangularPositionSnapGrid.cs
@@ -2,132 +2,51 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Layout;
-using osu.Framework.Utils;
+using osu.Framework.Bindables;
+using osu.Game.Utils;
 using osuTK;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
-    public partial class RectangularPositionSnapGrid : CompositeDrawable
+    public partial class RectangularPositionSnapGrid : LinedPositionSnapGrid
     {
-        /// <summary>
-        /// The position of the origin of this <see cref="RectangularPositionSnapGrid"/> in local coordinates.
-        /// </summary>
-        public Vector2 StartPosition { get; }
-
-        private Vector2 spacing = Vector2.One;
-
         /// <summary>
         /// The spacing between grid lines of this <see cref="RectangularPositionSnapGrid"/>.
         /// </summary>
-        public Vector2 Spacing
-        {
-            get => spacing;
-            set
-            {
-                if (spacing.X <= 0 || spacing.Y <= 0)
-                    throw new ArgumentException("Grid spacing must be positive.");
+        public Bindable<Vector2> Spacing { get; } = new Bindable<Vector2>(Vector2.One);
 
-                spacing = value;
-                gridCache.Invalidate();
-            }
+        /// <summary>
+        /// The rotation in degrees of the grid lines of this <see cref="RectangularPositionSnapGrid"/>.
+        /// </summary>
+        public BindableFloat GridLineRotation { get; } = new BindableFloat();
+
+        public RectangularPositionSnapGrid()
+        {
+            Spacing.BindValueChanged(_ => GridCache.Invalidate());
+            GridLineRotation.BindValueChanged(_ => GridCache.Invalidate());
         }
 
-        private readonly LayoutValue gridCache = new LayoutValue(Invalidation.RequiredParentSizeToFit);
-
-        public RectangularPositionSnapGrid(Vector2 startPosition)
-        {
-            StartPosition = startPosition;
-
-            AddLayout(gridCache);
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            if (!gridCache.IsValid)
-            {
-                ClearInternal();
-
-                if (DrawWidth > 0 && DrawHeight > 0)
-                    createContent();
-
-                gridCache.Validate();
-            }
-        }
-
-        private void createContent()
+        protected override void CreateContent()
         {
             var drawSize = DrawSize;
+            var rot = Quaternion.FromAxisAngle(Vector3.UnitZ, MathHelper.DegreesToRadians(GridLineRotation.Value));
 
-            generateGridLines(Direction.Horizontal, StartPosition.Y, 0, -Spacing.Y);
-            generateGridLines(Direction.Horizontal, StartPosition.Y, drawSize.Y, Spacing.Y);
+            GenerateGridLines(Vector2.Transform(new Vector2(0, -Spacing.Value.Y), rot), drawSize);
+            GenerateGridLines(Vector2.Transform(new Vector2(0, Spacing.Value.Y), rot), drawSize);
 
-            generateGridLines(Direction.Vertical, StartPosition.X, 0, -Spacing.X);
-            generateGridLines(Direction.Vertical, StartPosition.X, drawSize.X, Spacing.X);
+            GenerateGridLines(Vector2.Transform(new Vector2(-Spacing.Value.X, 0), rot), drawSize);
+            GenerateGridLines(Vector2.Transform(new Vector2(Spacing.Value.X, 0), rot), drawSize);
+
+            GenerateOutline(drawSize);
         }
 
-        private void generateGridLines(Direction direction, float startPosition, float endPosition, float step)
+        public override Vector2 GetSnappedPosition(Vector2 original)
         {
-            int index = 0;
-            float currentPosition = startPosition;
-
-            // Make lines the same width independent of display resolution.
-            float lineWidth = DrawWidth / ScreenSpaceDrawQuad.Width;
-
-            List<Box> generatedLines = new List<Box>();
-
-            while (Precision.AlmostBigger((endPosition - currentPosition) * Math.Sign(step), 0))
-            {
-                var gridLine = new Box
-                {
-                    Colour = Colour4.White,
-                    Alpha = 0.1f,
-                };
-
-                if (direction == Direction.Horizontal)
-                {
-                    gridLine.Origin = Anchor.CentreLeft;
-                    gridLine.RelativeSizeAxes = Axes.X;
-                    gridLine.Height = lineWidth;
-                    gridLine.Y = currentPosition;
-                }
-                else
-                {
-                    gridLine.Origin = Anchor.TopCentre;
-                    gridLine.RelativeSizeAxes = Axes.Y;
-                    gridLine.Width = lineWidth;
-                    gridLine.X = currentPosition;
-                }
-
-                generatedLines.Add(gridLine);
-
-                index += 1;
-                currentPosition = startPosition + index * step;
-            }
-
-            if (generatedLines.Count == 0)
-                return;
-
-            generatedLines.First().Alpha = 0.3f;
-            generatedLines.Last().Alpha = 0.3f;
-
-            AddRangeInternal(generatedLines);
-        }
-
-        public Vector2 GetSnappedPosition(Vector2 original)
-        {
-            Vector2 relativeToStart = original - StartPosition;
-            Vector2 offset = Vector2.Divide(relativeToStart, Spacing);
+            Vector2 relativeToStart = GeometryUtils.RotateVector(original - StartPosition.Value, GridLineRotation.Value);
+            Vector2 offset = Vector2.Divide(relativeToStart, Spacing.Value);
             Vector2 roundedOffset = new Vector2(MathF.Round(offset.X), MathF.Round(offset.Y));
 
-            return StartPosition + Vector2.Multiply(roundedOffset, Spacing);
+            return StartPosition.Value + GeometryUtils.RotateVector(Vector2.Multiply(roundedOffset, Spacing.Value), -GridLineRotation.Value);
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs
index 5270162189..b9383f1bad 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxRotationHandle.cs
@@ -67,6 +67,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             if (rotationHandler == null) return false;
 
+            if (rotationHandler.OperationInProgress.Value)
+                return false;
+
             rotationHandler.Begin();
             return true;
         }
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxScaleHandle.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxScaleHandle.cs
index eca0c08ba1..3f4f2c2854 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxScaleHandle.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxScaleHandle.cs
@@ -32,6 +32,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             if (scaleHandler == null) return false;
 
+            if (scaleHandler.OperationInProgress.Value)
+                return false;
+
             originalAnchor = Anchor;
 
             scaleHandler.Begin();
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs
index dd6bd43f4d..b68d5cd540 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs
@@ -313,7 +313,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <summary>
         /// Given a selection target and a function of truth, retrieve the correct ternary state for display.
         /// </summary>
-        protected static TernaryState GetStateFromSelection<TObject>(IEnumerable<TObject> selection, Func<TObject, bool> func)
+        public static TernaryState GetStateFromSelection<TObject>(IEnumerable<TObject> selection, Func<TObject, bool> func)
         {
             if (selection.Any(func))
                 return selection.All(func) ? TernaryState.True : TernaryState.Indeterminate;
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
index 787716a38c..532daaf7fa 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionRotationHandler.cs
@@ -12,6 +12,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
     /// </summary>
     public partial class SelectionRotationHandler : Component
     {
+        /// <summary>
+        /// Whether there is any ongoing scale operation right now.
+        /// </summary>
+        public Bindable<bool> OperationInProgress { get; private set; } = new BindableBool();
+
         /// <summary>
         /// Whether rotation anchored by the selection origin can currently be performed.
         /// </summary>
@@ -50,6 +55,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </remarks>
         public virtual void Begin()
         {
+            OperationInProgress.Value = true;
         }
 
         /// <summary>
@@ -85,6 +91,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </remarks>
         public virtual void Commit()
         {
+            OperationInProgress.Value = false;
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
index a96f627e56..c91362219c 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
@@ -13,6 +13,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
     /// </summary>
     public partial class SelectionScaleHandler : Component
     {
+        /// <summary>
+        /// Whether there is any ongoing scale operation right now.
+        /// </summary>
+        public Bindable<bool> OperationInProgress { get; private set; } = new BindableBool();
+
         /// <summary>
         /// Whether horizontal scaling (from the left or right edge) support should be enabled.
         /// </summary>
@@ -63,6 +68,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </remarks>
         public virtual void Begin()
         {
+            OperationInProgress.Value = true;
         }
 
         /// <summary>
@@ -99,6 +105,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </remarks>
         public virtual void Commit()
         {
+            OperationInProgress.Value = false;
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/DifficultyPointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/DifficultyPointPiece.cs
index d9084a7477..3ad6095965 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/DifficultyPointPiece.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/DifficultyPointPiece.cs
@@ -138,7 +138,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             protected override void LoadComplete()
             {
                 base.LoadComplete();
-                ScheduleAfterChildren(() => GetContainingFocusManager().ChangeFocus(sliderVelocitySlider));
+                ScheduleAfterChildren(() => GetContainingFocusManager()!.ChangeFocus(sliderVelocitySlider));
             }
         }
     }
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/NodeSamplePointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/NodeSamplePointPiece.cs
new file mode 100644
index 0000000000..ae3838bc41
--- /dev/null
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/NodeSamplePointPiece.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 System.Collections.Generic;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Audio;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public partial class NodeSamplePointPiece : SamplePointPiece
+    {
+        public readonly int NodeIndex;
+
+        public NodeSamplePointPiece(HitObject hitObject, int nodeIndex)
+            : base(hitObject)
+        {
+            if (hitObject is not IHasRepeats)
+                throw new System.ArgumentException($"HitObject must implement {nameof(IHasRepeats)}", nameof(hitObject));
+
+            NodeIndex = nodeIndex;
+        }
+
+        protected override IList<HitSampleInfo> GetSamples()
+        {
+            var hasRepeats = (IHasRepeats)HitObject;
+            return NodeIndex < hasRepeats.NodeSamples.Count ? hasRepeats.NodeSamples[NodeIndex] : HitObject.Samples;
+        }
+
+        public override Popover GetPopover() => new NodeSampleEditPopover(HitObject, NodeIndex);
+
+        public partial class NodeSampleEditPopover : SampleEditPopover
+        {
+            private readonly int nodeIndex;
+
+            protected override IList<HitSampleInfo> GetRelevantSamples(HitObject ho)
+            {
+                if (ho is not IHasRepeats hasRepeats)
+                    return ho.Samples;
+
+                return nodeIndex < hasRepeats.NodeSamples.Count ? hasRepeats.NodeSamples[nodeIndex] : ho.Samples;
+            }
+
+            public NodeSampleEditPopover(HitObject hitObject, int nodeIndex)
+                : base(hitObject)
+            {
+                this.nodeIndex = nodeIndex;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
index 5c4a9faaca..930b78b468 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
@@ -1,8 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using Humanizer;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
@@ -14,12 +16,15 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Game.Audio;
 using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Screens.Edit.Timing;
 using osuTK;
 using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 {
@@ -27,20 +32,20 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
     {
         public readonly HitObject HitObject;
 
-        private readonly BindableList<HitSampleInfo> samplesBindable;
-
         public SamplePointPiece(HitObject hitObject)
         {
             HitObject = hitObject;
-            samplesBindable = hitObject.SamplesBindable.GetBoundCopy();
         }
 
-        protected override Color4 GetRepresentingColour(OsuColour colours) => colours.Pink;
+        public bool AlternativeColor { get; init; }
+
+        protected override Color4 GetRepresentingColour(OsuColour colours) => AlternativeColor ? colours.Pink2 : colours.Pink1;
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            samplesBindable.BindCollectionChanged((_, _) => updateText(), true);
+            HitObject.DefaultsApplied += _ => updateText();
+            updateText();
         }
 
         protected override bool OnClick(ClickEvent e)
@@ -51,12 +56,28 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private void updateText()
         {
-            Label.Text = $"{GetBankValue(samplesBindable)} {GetVolumeValue(samplesBindable)}";
+            Label.Text = $"{abbreviateBank(GetBankValue(GetSamples()))} {GetVolumeValue(GetSamples())}";
+        }
+
+        private static string? abbreviateBank(string? bank)
+        {
+            return bank switch
+            {
+                HitSampleInfo.BANK_NORMAL => @"N",
+                HitSampleInfo.BANK_SOFT => @"S",
+                HitSampleInfo.BANK_DRUM => @"D",
+                _ => bank
+            };
         }
 
         public static string? GetBankValue(IEnumerable<HitSampleInfo> samples)
         {
-            return samples.FirstOrDefault()?.Bank;
+            return samples.FirstOrDefault(o => o.Name == HitSampleInfo.HIT_NORMAL)?.Bank;
+        }
+
+        public static string? GetAdditionBankValue(IEnumerable<HitSampleInfo> samples)
+        {
+            return samples.FirstOrDefault(o => o.Name != HitSampleInfo.HIT_NORMAL)?.Bank;
         }
 
         public static int GetVolumeValue(ICollection<HitSampleInfo> samples)
@@ -64,15 +85,36 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             return samples.Count == 0 ? 0 : samples.Max(o => o.Volume);
         }
 
-        public Popover GetPopover() => new SampleEditPopover(HitObject);
+        /// <summary>
+        /// Gets the samples to be edited by this sample point piece.
+        /// This could be the samples of the hit object itself, or of one of the nested hit objects. For example a slider repeat.
+        /// </summary>
+        /// <returns>The samples to be edited.</returns>
+        protected virtual IList<HitSampleInfo> GetSamples() => HitObject.Samples;
+
+        public virtual Popover GetPopover() => new SampleEditPopover(HitObject);
 
         public partial class SampleEditPopover : OsuPopover
         {
             private readonly HitObject hitObject;
 
             private LabelledTextBox bank = null!;
+            private LabelledTextBox additionBank = null!;
             private IndeterminateSliderWithTextBoxInput<int> volume = null!;
 
+            private FillFlowContainer togglesCollection = null!;
+
+            private HitObject[] relevantObjects = null!;
+            private IList<HitSampleInfo>[] allRelevantSamples = null!;
+
+            /// <summary>
+            /// Gets the sub-set of samples relevant to this sample point piece.
+            /// For example, to edit node samples this should return the samples at the index of the node.
+            /// </summary>
+            /// <param name="ho">The hit object to get the relevant samples from.</param>
+            /// <returns>The relevant list of samples.</returns>
+            protected virtual IList<HitSampleInfo> GetRelevantSamples(HitObject ho) => ho.Samples;
+
             [Resolved(canBeNull: true)]
             private EditorBeatmap beatmap { get; set; } = null!;
 
@@ -96,10 +138,21 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                         Spacing = new Vector2(0, 10),
                         Children = new Drawable[]
                         {
+                            togglesCollection = new FillFlowContainer
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
+                                Direction = FillDirection.Horizontal,
+                                Spacing = new Vector2(5, 5),
+                            },
                             bank = new LabelledTextBox
                             {
                                 Label = "Bank Name",
                             },
+                            additionBank = new LabelledTextBox
+                            {
+                                Label = "Addition Bank",
+                            },
                             volume = new IndeterminateSliderWithTextBoxInput<int>("Volume", new BindableInt(100)
                             {
                                 MinValue = DrawableHitObject.MINIMUM_SAMPLE_VOLUME,
@@ -110,89 +163,273 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 };
 
                 bank.TabbableContentContainer = flow;
+                additionBank.TabbableContentContainer = flow;
                 volume.TabbableContentContainer = flow;
 
                 // if the piece belongs to a currently selected object, assume that the user wants to change all selected objects.
                 // if the piece belongs to an unselected object, operate on that object alone, independently of the selection.
-                var relevantObjects = (beatmap.SelectedHitObjects.Contains(hitObject) ? beatmap.SelectedHitObjects : hitObject.Yield()).ToArray();
-                var relevantSamples = relevantObjects.Select(h => h.Samples).ToArray();
+                relevantObjects = (beatmap.SelectedHitObjects.Contains(hitObject) ? beatmap.SelectedHitObjects : hitObject.Yield()).ToArray();
+                allRelevantSamples = relevantObjects.Select(GetRelevantSamples).ToArray();
 
                 // even if there are multiple objects selected, we can still display sample volume or bank if they all have the same value.
-                string? commonBank = getCommonBank(relevantSamples);
-                if (!string.IsNullOrEmpty(commonBank))
-                    bank.Current.Value = commonBank;
-
-                int? commonVolume = getCommonVolume(relevantSamples);
+                int? commonVolume = getCommonVolume();
                 if (commonVolume != null)
                     volume.Current.Value = commonVolume.Value;
 
-                updateBankPlaceholderText(relevantObjects);
+                updatePrimaryBankState();
                 bank.Current.BindValueChanged(val =>
                 {
-                    updateBankFor(relevantObjects, val.NewValue);
-                    updateBankPlaceholderText(relevantObjects);
+                    if (string.IsNullOrEmpty(val.NewValue))
+                        return;
+
+                    setBank(val.NewValue);
+                    updatePrimaryBankState();
                 });
                 // on commit, ensure that the value is correct by sourcing it from the objects' samples again.
                 // this ensures that committing empty text causes a revert to the previous value.
-                bank.OnCommit += (_, _) => bank.Current.Value = getCommonBank(relevantSamples);
+                bank.OnCommit += (_, _) => updatePrimaryBankState();
 
-                volume.Current.BindValueChanged(val => updateVolumeFor(relevantObjects, val.NewValue));
-            }
-
-            protected override void LoadComplete()
-            {
-                base.LoadComplete();
-                ScheduleAfterChildren(() => GetContainingFocusManager().ChangeFocus(volume));
-            }
-
-            private static string? getCommonBank(IList<HitSampleInfo>[] relevantSamples) => relevantSamples.Select(GetBankValue).Distinct().Count() == 1 ? GetBankValue(relevantSamples.First()) : null;
-            private static int? getCommonVolume(IList<HitSampleInfo>[] relevantSamples) => relevantSamples.Select(GetVolumeValue).Distinct().Count() == 1 ? GetVolumeValue(relevantSamples.First()) : null;
-
-            private void updateBankFor(IEnumerable<HitObject> objects, string? newBank)
-            {
-                if (string.IsNullOrEmpty(newBank))
-                    return;
-
-                beatmap.BeginChange();
-
-                foreach (var h in objects)
+                updateAdditionBankState();
+                additionBank.Current.BindValueChanged(val =>
                 {
-                    for (int i = 0; i < h.Samples.Count; i++)
-                    {
-                        h.Samples[i] = h.Samples[i].With(newBank: newBank);
-                    }
+                    if (string.IsNullOrEmpty(val.NewValue))
+                        return;
 
-                    beatmap.Update(h);
-                }
+                    setAdditionBank(val.NewValue);
+                    updateAdditionBankState();
+                });
+                additionBank.OnCommit += (_, _) => updateAdditionBankState();
 
-                beatmap.EndChange();
+                volume.Current.BindValueChanged(val =>
+                {
+                    if (val.NewValue != null)
+                        setVolume(val.NewValue.Value);
+                });
+
+                createStateBindables();
+                updateTernaryStates();
+                togglesCollection.AddRange(createTernaryButtons().Select(b => new DrawableTernaryButton(b) { RelativeSizeAxes = Axes.None, Size = new Vector2(40, 40) }));
             }
 
-            private void updateBankPlaceholderText(IEnumerable<HitObject> objects)
+            private string? getCommonBank() => allRelevantSamples.Select(GetBankValue).Distinct().Count() == 1 ? GetBankValue(allRelevantSamples.First()) : null;
+            private string? getCommonAdditionBank() => allRelevantSamples.Select(GetAdditionBankValue).Where(o => o is not null).Distinct().Count() == 1 ? GetAdditionBankValue(allRelevantSamples.First()) : null;
+            private int? getCommonVolume() => allRelevantSamples.Select(GetVolumeValue).Distinct().Count() == 1 ? GetVolumeValue(allRelevantSamples.First()) : null;
+
+            private void updatePrimaryBankState()
             {
-                string? commonBank = getCommonBank(objects.Select(h => h.Samples).ToArray());
+                string? commonBank = getCommonBank();
+                bank.Current.Value = commonBank;
                 bank.PlaceholderText = string.IsNullOrEmpty(commonBank) ? "(multiple)" : string.Empty;
             }
 
-            private void updateVolumeFor(IEnumerable<HitObject> objects, int? newVolume)
+            private void updateAdditionBankState()
             {
-                if (newVolume == null)
-                    return;
+                string? commonAdditionBank = getCommonAdditionBank();
+                additionBank.PlaceholderText = string.IsNullOrEmpty(commonAdditionBank) ? "(multiple)" : string.Empty;
+                additionBank.Current.Value = commonAdditionBank;
 
+                bool anyAdditions = allRelevantSamples.Any(o => o.Any(s => s.Name != HitSampleInfo.HIT_NORMAL));
+                if (anyAdditions)
+                    additionBank.Show();
+                else
+                    additionBank.Hide();
+            }
+
+            /// <summary>
+            /// Applies the given update action on all samples of <see cref="allRelevantSamples"/>
+            /// and invokes the necessary update notifiers for the beatmap and hit objects.
+            /// </summary>
+            /// <param name="updateAction">The action to perform on each element of <see cref="allRelevantSamples"/>.</param>
+            private void updateAllRelevantSamples(Action<HitObject, IList<HitSampleInfo>> updateAction)
+            {
                 beatmap.BeginChange();
 
-                foreach (var h in objects)
+                foreach (var relevantHitObject in relevantObjects)
                 {
-                    for (int i = 0; i < h.Samples.Count; i++)
-                    {
-                        h.Samples[i] = h.Samples[i].With(newVolume: newVolume.Value);
-                    }
-
-                    beatmap.Update(h);
+                    var relevantSamples = GetRelevantSamples(relevantHitObject);
+                    updateAction(relevantHitObject, relevantSamples);
+                    beatmap.Update(relevantHitObject);
                 }
 
                 beatmap.EndChange();
             }
+
+            private void setBank(string newBank)
+            {
+                updateAllRelevantSamples((_, relevantSamples) =>
+                {
+                    for (int i = 0; i < relevantSamples.Count; i++)
+                    {
+                        if (relevantSamples[i].Name != HitSampleInfo.HIT_NORMAL) continue;
+
+                        relevantSamples[i] = relevantSamples[i].With(newBank: newBank);
+                    }
+                });
+            }
+
+            private void setAdditionBank(string newBank)
+            {
+                updateAllRelevantSamples((_, relevantSamples) =>
+                {
+                    for (int i = 0; i < relevantSamples.Count; i++)
+                    {
+                        if (relevantSamples[i].Name == HitSampleInfo.HIT_NORMAL) continue;
+
+                        relevantSamples[i] = relevantSamples[i].With(newBank: newBank);
+                    }
+                });
+            }
+
+            private void setVolume(int newVolume)
+            {
+                updateAllRelevantSamples((_, relevantSamples) =>
+                {
+                    for (int i = 0; i < relevantSamples.Count; i++)
+                    {
+                        relevantSamples[i] = relevantSamples[i].With(newVolume: newVolume);
+                    }
+                });
+            }
+
+            #region hitsound toggles
+
+            private readonly Dictionary<string, Bindable<TernaryState>> selectionSampleStates = new Dictionary<string, Bindable<TernaryState>>();
+
+            private readonly List<string> banks = new List<string>();
+
+            private void createStateBindables()
+            {
+                foreach (string sampleName in HitSampleInfo.AllAdditions)
+                {
+                    var bindable = new Bindable<TernaryState>
+                    {
+                        Description = sampleName.Replace("hit", string.Empty).Titleize()
+                    };
+
+                    bindable.ValueChanged += state =>
+                    {
+                        switch (state.NewValue)
+                        {
+                            case TernaryState.False:
+                                removeHitSample(sampleName);
+                                break;
+
+                            case TernaryState.True:
+                                addHitSample(sampleName);
+                                break;
+                        }
+                    };
+
+                    selectionSampleStates[sampleName] = bindable;
+                }
+
+                banks.AddRange(HitSampleInfo.AllBanks);
+            }
+
+            private void updateTernaryStates()
+            {
+                foreach ((string sampleName, var bindable) in selectionSampleStates)
+                {
+                    bindable.Value = SelectionHandler<HitObject>.GetStateFromSelection(relevantObjects, h => GetRelevantSamples(h).Any(s => s.Name == sampleName));
+                }
+            }
+
+            private IEnumerable<TernaryButton> createTernaryButtons()
+            {
+                foreach ((string sampleName, var bindable) in selectionSampleStates)
+                    yield return new TernaryButton(bindable, string.Empty, () => ComposeBlueprintContainer.GetIconForSample(sampleName));
+            }
+
+            private void addHitSample(string sampleName)
+            {
+                if (string.IsNullOrEmpty(sampleName))
+                    return;
+
+                updateAllRelevantSamples((h, relevantSamples) =>
+                {
+                    // Make sure there isn't already an existing sample
+                    if (relevantSamples.Any(s => s.Name == sampleName))
+                        return;
+
+                    // First try inheriting the sample info from the node samples instead of the samples of the hitobject
+                    var relevantSample = relevantSamples.FirstOrDefault(s => s.Name != HitSampleInfo.HIT_NORMAL) ?? relevantSamples.FirstOrDefault();
+                    relevantSamples.Add(relevantSample?.With(sampleName) ?? h.CreateHitSampleInfo(sampleName));
+                });
+
+                updateAdditionBankState();
+            }
+
+            private void removeHitSample(string sampleName)
+            {
+                if (string.IsNullOrEmpty(sampleName))
+                    return;
+
+                updateAllRelevantSamples((_, relevantSamples) =>
+                {
+                    for (int i = 0; i < relevantSamples.Count; i++)
+                    {
+                        if (relevantSamples[i].Name == sampleName)
+                            relevantSamples.RemoveAt(i--);
+                    }
+                });
+
+                updateAdditionBankState();
+            }
+
+            protected override bool OnKeyDown(KeyDownEvent e)
+            {
+                if (e.ControlPressed || e.AltPressed || e.SuperPressed || !checkRightToggleFromKey(e.Key, out int rightIndex))
+                    return base.OnKeyDown(e);
+
+                if (e.ShiftPressed)
+                {
+                    string? newBank = banks.ElementAtOrDefault(rightIndex);
+
+                    if (string.IsNullOrEmpty(newBank))
+                        return true;
+
+                    setBank(newBank);
+                    updatePrimaryBankState();
+                    setAdditionBank(newBank);
+                    updateAdditionBankState();
+                }
+                else
+                {
+                    var item = togglesCollection.ElementAtOrDefault(rightIndex);
+
+                    if (item is not DrawableTernaryButton button) return base.OnKeyDown(e);
+
+                    button.Button.Toggle();
+                }
+
+                return true;
+            }
+
+            private bool checkRightToggleFromKey(Key key, out int index)
+            {
+                switch (key)
+                {
+                    case Key.W:
+                        index = 0;
+                        break;
+
+                    case Key.E:
+                        index = 1;
+                        break;
+
+                    case Key.R:
+                        index = 2;
+                        break;
+
+                    default:
+                        index = -1;
+                        break;
+                }
+
+                return index >= 0;
+            }
+
+            #endregion
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
index a2704e550c..fa9964b104 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/Timeline.cs
@@ -30,12 +30,6 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private readonly Drawable userContent;
 
-        public readonly Bindable<bool> WaveformVisible = new Bindable<bool>();
-
-        public readonly Bindable<bool> ControlPointsVisible = new Bindable<bool>();
-
-        public readonly Bindable<bool> TicksVisible = new Bindable<bool>();
-
         [Resolved]
         private EditorClock editorClock { get; set; }
 
@@ -88,6 +82,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         private Container mainContent;
 
         private Bindable<float> waveformOpacity;
+        private Bindable<bool> controlPointsVisible;
+        private Bindable<bool> ticksVisible;
 
         private double trackLengthForZoom;
 
@@ -139,6 +135,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             });
 
             waveformOpacity = config.GetBindable<float>(OsuSetting.EditorWaveformOpacity);
+            controlPointsVisible = config.GetBindable<bool>(OsuSetting.EditorTimelineShowTimingChanges);
+            ticksVisible = config.GetBindable<bool>(OsuSetting.EditorTimelineShowTicks);
 
             track.BindTo(editorClock.Track);
             track.BindValueChanged(_ =>
@@ -168,12 +166,11 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         {
             base.LoadComplete();
 
-            WaveformVisible.BindValueChanged(_ => updateWaveformOpacity());
             waveformOpacity.BindValueChanged(_ => updateWaveformOpacity(), true);
 
-            TicksVisible.BindValueChanged(visible => ticks.FadeTo(visible.NewValue ? 1 : 0, 200, Easing.OutQuint), true);
+            ticksVisible.BindValueChanged(visible => ticks.FadeTo(visible.NewValue ? 1 : 0, 200, Easing.OutQuint), true);
 
-            ControlPointsVisible.BindValueChanged(visible =>
+            controlPointsVisible.BindValueChanged(visible =>
             {
                 if (visible.NewValue)
                 {
@@ -195,7 +192,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         }
 
         private void updateWaveformOpacity() =>
-            waveform.FadeTo(WaveformVisible.Value ? waveformOpacity.Value : 0, 200, Easing.OutQuint);
+            waveform.FadeTo(waveformOpacity.Value, 200, Easing.OutQuint);
 
         protected override void Update()
         {
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineArea.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineArea.cs
index b973ac3731..cee7212a5d 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineArea.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineArea.cs
@@ -2,15 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Localisation;
 using osu.Game.Overlays;
-using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets.Edit;
 using osuTK;
 
@@ -22,6 +20,9 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         private readonly Drawable userContent;
 
+        private Box timelineBackground = null!;
+        private readonly Bindable<bool> composerFocusMode = new Bindable<bool>();
+
         public TimelineArea(Drawable? content = null)
         {
             RelativeSizeAxes = Axes.X;
@@ -31,16 +32,20 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         }
 
         [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colourProvider, OsuColour colours)
+        private void load(OverlayColourProvider colourProvider, OsuColour colours, Editor? editor)
         {
-            OsuCheckbox waveformCheckbox;
-            OsuCheckbox controlPointsCheckbox;
-            OsuCheckbox ticksCheckbox;
-
             const float padding = 10;
 
             InternalChildren = new Drawable[]
             {
+                new Box
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                    Width = 35 + HitObjectComposer.TOOLBOX_CONTRACTED_SIZE_RIGHT,
+                    RelativeSizeAxes = Axes.Y,
+                    Colour = colourProvider.Background4
+                },
                 new GridContainer
                 {
                     RelativeSizeAxes = Axes.X,
@@ -51,70 +56,21 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                     },
                     ColumnDimensions = new[]
                     {
-                        new Dimension(GridSizeMode.Absolute, 135),
                         new Dimension(),
                         new Dimension(GridSizeMode.Absolute, 35),
-                        new Dimension(GridSizeMode.Absolute, HitObjectComposer.TOOLBOX_CONTRACTED_SIZE_RIGHT - padding * 2),
+                        new Dimension(GridSizeMode.Absolute, HitObjectComposer.TOOLBOX_CONTRACTED_SIZE_RIGHT),
                     },
                     Content = new[]
                     {
                         new Drawable[]
                         {
-                            new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Name = @"Toggle controls",
-                                Children = new Drawable[]
-                                {
-                                    new Box
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Colour = colourProvider.Background2,
-                                    },
-                                    new FillFlowContainer
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Padding = new MarginPadding(padding),
-                                        Direction = FillDirection.Vertical,
-                                        Spacing = new Vector2(0, 4),
-                                        Children = new[]
-                                        {
-                                            waveformCheckbox = new OsuCheckbox(nubSize: 30f)
-                                            {
-                                                LabelText = EditorStrings.TimelineWaveform,
-                                                Current = { Value = true },
-                                            },
-                                            ticksCheckbox = new OsuCheckbox(nubSize: 30f)
-                                            {
-                                                LabelText = EditorStrings.TimelineTicks,
-                                                Current = { Value = true },
-                                            },
-                                            controlPointsCheckbox = new OsuCheckbox(nubSize: 30f)
-                                            {
-                                                LabelText = BeatmapsetsStrings.ShowStatsBpm,
-                                                Current = { Value = true },
-                                            },
-                                        }
-                                    }
-                                }
-                            },
                             new Container
                             {
                                 RelativeSizeAxes = Axes.X,
                                 AutoSizeAxes = Axes.Y,
                                 Children = new Drawable[]
                                 {
-                                    // the out-of-bounds portion of the centre marker.
-                                    new Box
-                                    {
-                                        Width = 24,
-                                        Height = EditorScreenWithTimeline.PADDING,
-                                        Depth = float.MaxValue,
-                                        Colour = colours.Red1,
-                                        Anchor = Anchor.TopCentre,
-                                        Origin = Anchor.BottomCentre,
-                                    },
-                                    new Box
+                                    timelineBackground = new Box
                                     {
                                         RelativeSizeAxes = Axes.Both,
                                         Depth = float.MaxValue,
@@ -168,9 +124,15 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 }
             };
 
-            Timeline.WaveformVisible.BindTo(waveformCheckbox.Current);
-            Timeline.ControlPointsVisible.BindTo(controlPointsCheckbox.Current);
-            Timeline.TicksVisible.BindTo(ticksCheckbox.Current);
+            if (editor != null)
+                composerFocusMode.BindTo(editor.ComposerFocusMode);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            composerFocusMode.BindValueChanged(_ => timelineBackground.FadeTo(composerFocusMode.Value ? 0.5f : 1, 400, Easing.OutQuint), true);
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
index 6ebd1961a2..9a8fdc3dac 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
@@ -170,6 +170,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
         protected override void UpdateSelectionFromDragBox()
         {
+            Composer.BlueprintContainer.CommitIfPlacementActive();
+
             var dragBox = (TimelineDragBox)DragBox;
             double minTime = dragBox.MinTime;
             double maxTime = dragBox.MaxTime;
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBreak.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBreak.cs
new file mode 100644
index 0000000000..025eb8bede
--- /dev/null
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBreak.cs
@@ -0,0 +1,224 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Diagnostics;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Objects;
+using osuTK;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public partial class TimelineBreak : CompositeDrawable
+    {
+        public Bindable<BreakPeriod> Break { get; } = new Bindable<BreakPeriod>();
+
+        public TimelineBreak(BreakPeriod b)
+        {
+            Break.Value = b;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            RelativePositionAxes = Axes.X;
+            RelativeSizeAxes = Axes.Both;
+            Origin = Anchor.TopLeft;
+            Padding = new MarginPadding { Horizontal = -5 };
+
+            InternalChildren = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Horizontal = 5 },
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colours.Gray5,
+                        Alpha = 0.7f,
+                    },
+                },
+                new DragHandle(isStartHandle: true)
+                {
+                    Break = { BindTarget = Break },
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.TopLeft,
+                    Action = (time, breakPeriod) => new ManualBreakPeriod(time, breakPeriod.EndTime),
+                },
+                new DragHandle(isStartHandle: false)
+                {
+                    Break = { BindTarget = Break },
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                    Action = (time, breakPeriod) => new ManualBreakPeriod(breakPeriod.StartTime, time),
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Break.BindValueChanged(_ =>
+            {
+                X = (float)Break.Value.StartTime;
+                Width = (float)Break.Value.Duration;
+            }, true);
+        }
+
+        private partial class DragHandle : FillFlowContainer
+        {
+            public Bindable<BreakPeriod> Break { get; } = new Bindable<BreakPeriod>();
+
+            public new Anchor Anchor
+            {
+                get => base.Anchor;
+                init => base.Anchor = value;
+            }
+
+            public Func<double, BreakPeriod, BreakPeriod>? Action { get; init; }
+
+            private readonly bool isStartHandle;
+
+            private Container handle = null!;
+            private (double min, double max)? allowedDragRange;
+
+            [Resolved]
+            private EditorBeatmap beatmap { get; set; } = null!;
+
+            [Resolved]
+            private Timeline timeline { get; set; } = null!;
+
+            [Resolved]
+            private IEditorChangeHandler? changeHandler { get; set; }
+
+            [Resolved]
+            private OsuColour colours { get; set; } = null!;
+
+            public DragHandle(bool isStartHandle)
+            {
+                this.isStartHandle = isStartHandle;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AutoSizeAxes = Axes.X;
+                RelativeSizeAxes = Axes.Y;
+                Direction = FillDirection.Horizontal;
+                Spacing = new Vector2(5);
+
+                Children = new Drawable[]
+                {
+                    handle = new Container
+                    {
+                        Anchor = Anchor,
+                        Origin = Anchor,
+                        RelativeSizeAxes = Axes.Y,
+                        CornerRadius = 5,
+                        Masking = true,
+                        Child = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Colour4.White,
+                        },
+                    },
+                    new OsuSpriteText
+                    {
+                        BypassAutoSizeAxes = Axes.X,
+                        Anchor = Anchor,
+                        Origin = Anchor,
+                        Text = "Break",
+                        Margin = new MarginPadding { Top = 2, },
+                    },
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                updateState();
+                FinishTransforms(true);
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                updateState();
+                return true;
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                updateState();
+                base.OnHoverLost(e);
+            }
+
+            protected override bool OnDragStart(DragStartEvent e)
+            {
+                changeHandler?.BeginChange();
+                updateState();
+
+                double min = beatmap.HitObjects.LastOrDefault(ho => ho.GetEndTime() <= Break.Value.StartTime)?.GetEndTime() ?? double.NegativeInfinity;
+                double max = beatmap.HitObjects.FirstOrDefault(ho => ho.StartTime >= Break.Value.EndTime)?.StartTime ?? double.PositiveInfinity;
+
+                if (isStartHandle)
+                    max = Math.Min(max, Break.Value.EndTime - BreakPeriod.MIN_BREAK_DURATION);
+                else
+                    min = Math.Max(min, Break.Value.StartTime + BreakPeriod.MIN_BREAK_DURATION);
+
+                allowedDragRange = (min, max);
+
+                return true;
+            }
+
+            protected override void OnDrag(DragEvent e)
+            {
+                base.OnDrag(e);
+
+                Debug.Assert(allowedDragRange != null);
+
+                if (Action != null
+                    && timeline.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition).Time is double time
+                    && time > allowedDragRange.Value.min
+                    && time < allowedDragRange.Value.max)
+                {
+                    int index = beatmap.Breaks.IndexOf(Break.Value);
+                    beatmap.Breaks[index] = Break.Value = Action.Invoke(time, Break.Value);
+                }
+
+                updateState();
+            }
+
+            protected override void OnDragEnd(DragEndEvent e)
+            {
+                changeHandler?.EndChange();
+                updateState();
+                base.OnDragEnd(e);
+            }
+
+            private void updateState()
+            {
+                bool active = IsHovered || IsDragged;
+
+                var colour = colours.Gray8;
+                if (active)
+                    colour = colour.Lighten(0.3f);
+
+                this.FadeColour(colour, 400, Easing.OutQuint);
+                handle.ResizeWidthTo(active ? 20 : 10, 400, Easing.OutElasticHalf);
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBreakDisplay.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBreakDisplay.cs
new file mode 100644
index 0000000000..eaa31aea1e
--- /dev/null
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBreakDisplay.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 System.Collections.Specialized;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Caching;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
+
+namespace osu.Game.Screens.Edit.Compose.Components.Timeline
+{
+    public partial class TimelineBreakDisplay : TimelinePart<TimelineBreak>
+    {
+        [Resolved]
+        private Timeline timeline { get; set; } = null!;
+
+        /// <summary>
+        /// The visible time/position range of the timeline.
+        /// </summary>
+        private (float min, float max) visibleRange = (float.MinValue, float.MaxValue);
+
+        private readonly Cached breakCache = new Cached();
+
+        private readonly BindableList<BreakPeriod> breaks = new BindableList<BreakPeriod>();
+
+        protected override void LoadBeatmap(EditorBeatmap beatmap)
+        {
+            base.LoadBeatmap(beatmap);
+
+            breaks.UnbindAll();
+            breaks.BindTo(beatmap.Breaks);
+            breaks.BindCollectionChanged((_, e) =>
+            {
+                if (e.Action != NotifyCollectionChangedAction.Replace)
+                    breakCache.Invalidate();
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (DrawWidth <= 0) return;
+
+            (float, float) newRange = (
+                (ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopLeft).X) / DrawWidth * Content.RelativeChildSize.X,
+                (ToLocalSpace(timeline.ScreenSpaceDrawQuad.TopRight).X) / DrawWidth * Content.RelativeChildSize.X);
+
+            if (visibleRange != newRange)
+            {
+                visibleRange = newRange;
+                breakCache.Invalidate();
+            }
+
+            if (!breakCache.IsValid)
+            {
+                recreateBreaks();
+                breakCache.Validate();
+            }
+        }
+
+        private void recreateBreaks()
+        {
+            Clear();
+
+            for (int i = 0; i < breaks.Count; i++)
+            {
+                var breakPeriod = breaks[i];
+
+                if (!shouldBeVisible(breakPeriod))
+                    continue;
+
+                Add(new TimelineBreak(breakPeriod));
+            }
+        }
+
+        private bool shouldBeVisible(BreakPeriod breakPeriod) => breakPeriod.EndTime >= visibleRange.min && breakPeriod.StartTime <= visibleRange.max;
+    }
+}
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
index 7e6e886ff7..753856199a 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
@@ -50,6 +50,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         private readonly Border border;
 
         private readonly Container colouredComponents;
+        private readonly Container sampleComponents;
         private readonly OsuSpriteText comboIndexText;
         private readonly SamplePointPiece samplePointPiece;
         private readonly DifficultyPointPiece? difficultyPointPiece;
@@ -107,7 +108,13 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 samplePointPiece = new SamplePointPiece(Item)
                 {
                     Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.TopCentre
+                    Origin = Anchor.TopCentre,
+                    RelativePositionAxes = Axes.X,
+                    AlternativeColor = Item is IHasRepeats
+                },
+                sampleComponents = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
                 },
             });
 
@@ -236,6 +243,22 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                     X = (float)(i + 1) / (repeats.RepeatCount + 1)
                 });
             }
+
+            // Add node sample pieces
+            sampleComponents.Clear();
+
+            for (int i = 0; i < repeats.RepeatCount + 2; i++)
+            {
+                sampleComponents.Add(new NodeSamplePointPiece(Item, i)
+                {
+                    X = (float)i / (repeats.RepeatCount + 1),
+                    RelativePositionAxes = Axes.X,
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.TopCentre
+                });
+            }
+
+            samplePointPiece.X = 1f / (repeats.RepeatCount + 1) / 2;
         }
 
         protected override bool ShouldBeConsideredForInput(Drawable child) => true;
diff --git a/osu.Game/Screens/Edit/Compose/ComposeScreen.cs b/osu.Game/Screens/Edit/Compose/ComposeScreen.cs
index 0a58b34da6..9b945e1d6d 100644
--- a/osu.Game/Screens/Edit/Compose/ComposeScreen.cs
+++ b/osu.Game/Screens/Edit/Compose/ComposeScreen.cs
@@ -69,7 +69,15 @@ namespace osu.Game.Screens.Edit.Compose
             if (ruleset == null || composer == null)
                 return base.CreateTimelineContent();
 
-            return wrapSkinnableContent(new TimelineBlueprintContainer(composer));
+            return wrapSkinnableContent(new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    new TimelineBlueprintContainer(composer),
+                    new TimelineBreakDisplay { RelativeSizeAxes = Axes.Both, },
+                }
+            });
         }
 
         private Drawable wrapSkinnableContent(Drawable content)
diff --git a/osu.Game/Screens/Edit/Editor.cs b/osu.Game/Screens/Edit/Editor.cs
index 07c32983f5..22fc6fccdc 100644
--- a/osu.Game/Screens/Edit/Editor.cs
+++ b/osu.Game/Screens/Edit/Editor.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 using osu.Framework;
 using osu.Framework.Allocation;
@@ -35,6 +36,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
 using osu.Game.Localisation;
 using osu.Game.Online.API;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Overlays.OSD;
@@ -49,6 +51,7 @@ using osu.Game.Screens.Edit.GameplayTest;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Screens.Edit.Timing;
 using osu.Game.Screens.Edit.Verify;
+using osu.Game.Screens.OnlinePlay;
 using osu.Game.Screens.Play;
 using osu.Game.Users;
 using osuTK.Input;
@@ -142,6 +145,13 @@ namespace osu.Game.Screens.Edit
         private readonly Bindable<bool> samplePlaybackDisabled = new Bindable<bool>();
 
         private bool canSave;
+        private readonly List<MenuItem> saveRelatedMenuItems = new List<MenuItem>();
+
+        /// <summary>
+        /// Tracks ongoing mutually-exclusive operations related to changing the beatmap
+        /// (e.g. save, export).
+        /// </summary>
+        public OngoingOperationTracker MutationTracker { get; } = new OngoingOperationTracker();
 
         protected bool ExitConfirmed { get; private set; }
 
@@ -201,6 +211,14 @@ namespace osu.Game.Screens.Edit
         private Bindable<bool> editorHitMarkers;
         private Bindable<bool> editorAutoSeekOnPlacement;
         private Bindable<bool> editorLimitedDistanceSnap;
+        private Bindable<bool> editorTimelineShowTimingChanges;
+        private Bindable<bool> editorTimelineShowTicks;
+
+        /// <summary>
+        /// This controls the opacity of components like the timelines, sidebars, etc.
+        /// In "composer focus" mode the opacity of the aforementioned components is reduced so that the user can focus on the composer better.
+        /// </summary>
+        public Bindable<bool> ComposerFocusMode { get; } = new Bindable<bool>();
 
         public Editor(EditorLoader loader = null)
         {
@@ -274,7 +292,7 @@ namespace osu.Game.Screens.Edit
                 dependencies.CacheAs<IEditorChangeHandler>(changeHandler);
             }
 
-            beatDivisor.Value = editorBeatmap.BeatmapInfo.BeatDivisor;
+            beatDivisor.SetArbitraryDivisor(editorBeatmap.BeatmapInfo.BeatDivisor);
             beatDivisor.BindValueChanged(divisor => editorBeatmap.BeatmapInfo.BeatDivisor = divisor.NewValue);
 
             updateLastSavedHash();
@@ -295,6 +313,8 @@ namespace osu.Game.Screens.Edit
             editorHitMarkers = config.GetBindable<bool>(OsuSetting.EditorShowHitMarkers);
             editorAutoSeekOnPlacement = config.GetBindable<bool>(OsuSetting.EditorAutoSeekOnPlacement);
             editorLimitedDistanceSnap = config.GetBindable<bool>(OsuSetting.EditorLimitedDistanceSnap);
+            editorTimelineShowTimingChanges = config.GetBindable<bool>(OsuSetting.EditorTimelineShowTimingChanges);
+            editorTimelineShowTicks = config.GetBindable<bool>(OsuSetting.EditorTimelineShowTicks);
 
             AddInternal(new OsuContextMenuContainer
             {
@@ -309,7 +329,6 @@ namespace osu.Game.Screens.Edit
                         Child = screenContainer = new Container<EditorScreen>
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Masking = true
                         }
                     },
                     new Container
@@ -328,7 +347,7 @@ namespace osu.Game.Screens.Edit
                                 {
                                     new MenuItem(CommonStrings.MenuBarFile)
                                     {
-                                        Items = createFileMenuItems()
+                                        Items = createFileMenuItems().ToList()
                                     },
                                     new MenuItem(CommonStrings.MenuBarEdit)
                                     {
@@ -345,9 +364,23 @@ namespace osu.Game.Screens.Edit
                                     },
                                     new MenuItem(CommonStrings.MenuBarView)
                                     {
-                                        Items = new MenuItem[]
+                                        Items = new[]
                                         {
-                                            new WaveformOpacityMenuItem(config.GetBindable<float>(OsuSetting.EditorWaveformOpacity)),
+                                            new MenuItem(EditorStrings.Timeline)
+                                            {
+                                                Items =
+                                                [
+                                                    new WaveformOpacityMenuItem(config.GetBindable<float>(OsuSetting.EditorWaveformOpacity)),
+                                                    new ToggleMenuItem(EditorStrings.TimelineShowTimingChanges)
+                                                    {
+                                                        State = { BindTarget = editorTimelineShowTimingChanges }
+                                                    },
+                                                    new ToggleMenuItem(EditorStrings.TimelineShowTicks)
+                                                    {
+                                                        State = { BindTarget = editorTimelineShowTicks }
+                                                    },
+                                                ]
+                                            },
                                             new BackgroundDimMenuItem(editorBackgroundDim),
                                             new ToggleMenuItem(EditorStrings.ShowHitMarkers)
                                             {
@@ -382,6 +415,7 @@ namespace osu.Game.Screens.Edit
                         },
                     },
                     bottomBar = new BottomBar(),
+                    MutationTracker,
                 }
             });
             changeHandler?.CanUndo.BindValueChanged(v => undoMenuItem.Action.Disabled = !v.NewValue, true);
@@ -402,6 +436,12 @@ namespace osu.Game.Screens.Edit
             Mode.BindValueChanged(onModeChanged, true);
 
             musicController.TrackChanged += onTrackChanged;
+
+            MutationTracker.InProgress.BindValueChanged(_ =>
+            {
+                foreach (var item in saveRelatedMenuItems)
+                    item.Action.Disabled = MutationTracker.InProgress.Value;
+            }, true);
         }
 
         protected override void Dispose(bool isDisposing)
@@ -440,12 +480,13 @@ namespace osu.Game.Screens.Edit
         {
             if (HasUnsavedChanges)
             {
-                dialogOverlay.Push(new SaveRequiredPopupDialog("The beatmap will be saved in order to test it.", () =>
+                dialogOverlay.Push(new SaveRequiredPopupDialog("The beatmap will be saved in order to test it.", () => attemptMutationOperation(() =>
                 {
-                    if (!Save()) return;
+                    if (!Save()) return false;
 
                     pushEditorPlayer();
-                }));
+                    return true;
+                })));
             }
             else
             {
@@ -455,6 +496,26 @@ namespace osu.Game.Screens.Edit
             void pushEditorPlayer() => this.Push(new EditorPlayerLoader(this));
         }
 
+        private bool attemptMutationOperation(Func<bool> mutationOperation)
+        {
+            if (MutationTracker.InProgress.Value)
+                return false;
+
+            using (MutationTracker.BeginOperation())
+                return mutationOperation.Invoke();
+        }
+
+        private bool attemptAsyncMutationOperation(Func<Task> mutationTask)
+        {
+            if (MutationTracker.InProgress.Value)
+                return false;
+
+            var operation = MutationTracker.BeginOperation();
+            var task = mutationTask.Invoke();
+            task.FireAndForget(operation.Dispose, _ => operation.Dispose());
+            return true;
+        }
+
         /// <summary>
         /// Saves the currently edited beatmap.
         /// </summary>
@@ -520,8 +581,7 @@ namespace osu.Game.Screens.Edit
                     if (e.Repeat)
                         return false;
 
-                    Save();
-                    return true;
+                    return attemptMutationOperation(Save);
             }
 
             return false;
@@ -787,7 +847,8 @@ namespace osu.Game.Screens.Edit
 
         private void confirmExitWithSave()
         {
-            if (!Save()) return;
+            if (!attemptMutationOperation(Save))
+                return;
 
             ExitConfirmed = true;
             this.Exit();
@@ -958,6 +1019,15 @@ namespace osu.Game.Screens.Edit
             }
         }
 
+        /// <summary>
+        /// Forces a reload of the compose screen after significant configuration changes.
+        /// </summary>
+        /// <remarks>
+        /// This can be necessary for scrolling rulesets, as they do not easily support control points changing under them.
+        /// The reason that this works is that <see cref="onModeChanged"/> will re-instantiate the screen whenever it is requested next.
+        /// </remarks>
+        public void ReloadComposeScreen() => screenContainer.SingleOrDefault(s => s.Type == EditorScreenMode.Compose)?.RemoveAndDisposeImmediately();
+
         [CanBeNull]
         private ScheduledDelegate playbackDisabledDebounce;
 
@@ -1020,25 +1090,35 @@ namespace osu.Game.Screens.Edit
             lastSavedHash = changeHandler?.CurrentStateHash;
         }
 
-        private List<MenuItem> createFileMenuItems() => new List<MenuItem>
+        private IEnumerable<MenuItem> createFileMenuItems()
         {
-            createDifficultyCreationMenu(),
-            createDifficultySwitchMenu(),
-            new OsuMenuItemSpacer(),
-            new EditorMenuItem(EditorStrings.DeleteDifficulty, MenuItemType.Standard, deleteDifficulty) { Action = { Disabled = Beatmap.Value.BeatmapSetInfo.Beatmaps.Count < 2 } },
-            new OsuMenuItemSpacer(),
-            new EditorMenuItem(WebCommonStrings.ButtonsSave, MenuItemType.Standard, () => Save()),
-            createExportMenu(),
-            new OsuMenuItemSpacer(),
-            new EditorMenuItem(CommonStrings.Exit, MenuItemType.Standard, this.Exit)
-        };
+            yield return createDifficultyCreationMenu();
+            yield return createDifficultySwitchMenu();
+            yield return new OsuMenuItemSpacer();
+            yield return new EditorMenuItem(EditorStrings.DeleteDifficulty, MenuItemType.Standard, deleteDifficulty) { Action = { Disabled = Beatmap.Value.BeatmapSetInfo.Beatmaps.Count < 2 } };
+            yield return new OsuMenuItemSpacer();
+
+            var save = new EditorMenuItem(WebCommonStrings.ButtonsSave, MenuItemType.Standard, () => attemptMutationOperation(Save));
+            saveRelatedMenuItems.Add(save);
+            yield return save;
+
+            if (RuntimeInfo.IsDesktop)
+            {
+                var export = createExportMenu();
+                saveRelatedMenuItems.AddRange(export.Items);
+                yield return export;
+            }
+
+            yield return new OsuMenuItemSpacer();
+            yield return new EditorMenuItem(CommonStrings.Exit, MenuItemType.Standard, this.Exit);
+        }
 
         private EditorMenuItem createExportMenu()
         {
             var exportItems = new List<MenuItem>
             {
-                new EditorMenuItem(EditorStrings.ExportForEditing, MenuItemType.Standard, () => exportBeatmap(false)) { Action = { Disabled = !RuntimeInfo.IsDesktop } },
-                new EditorMenuItem(EditorStrings.ExportForCompatibility, MenuItemType.Standard, () => exportBeatmap(true)) { Action = { Disabled = !RuntimeInfo.IsDesktop } },
+                new EditorMenuItem(EditorStrings.ExportForEditing, MenuItemType.Standard, () => exportBeatmap(false)),
+                new EditorMenuItem(EditorStrings.ExportForCompatibility, MenuItemType.Standard, () => exportBeatmap(true)),
             };
 
             return new EditorMenuItem(CommonStrings.Export) { Items = exportItems };
@@ -1048,24 +1128,25 @@ namespace osu.Game.Screens.Edit
         {
             if (HasUnsavedChanges)
             {
-                dialogOverlay.Push(new SaveRequiredPopupDialog("The beatmap will be saved in order to export it.", () =>
+                dialogOverlay.Push(new SaveRequiredPopupDialog("The beatmap will be saved in order to export it.", () => attemptAsyncMutationOperation(() =>
                 {
-                    if (!Save()) return;
+                    if (!Save())
+                        return Task.CompletedTask;
 
-                    runExport();
-                }));
+                    return runExport();
+                })));
             }
             else
             {
-                runExport();
+                attemptAsyncMutationOperation(runExport);
             }
 
-            void runExport()
+            Task runExport()
             {
                 if (legacy)
-                    beatmapManager.ExportLegacy(Beatmap.Value.BeatmapSetInfo);
+                    return beatmapManager.ExportLegacy(Beatmap.Value.BeatmapSetInfo);
                 else
-                    beatmapManager.Export(Beatmap.Value.BeatmapSetInfo);
+                    return beatmapManager.Export(Beatmap.Value.BeatmapSetInfo);
             }
         }
 
@@ -1116,6 +1197,8 @@ namespace osu.Game.Screens.Edit
             foreach (var ruleset in rulesets.AvailableRulesets)
                 rulesetItems.Add(new EditorMenuItem(ruleset.Name, MenuItemType.Standard, () => CreateNewDifficulty(ruleset)));
 
+            saveRelatedMenuItems.AddRange(rulesetItems);
+
             return new EditorMenuItem(EditorStrings.CreateNewDifficulty) { Items = rulesetItems };
         }
 
@@ -1125,10 +1208,14 @@ namespace osu.Game.Screens.Edit
             {
                 dialogOverlay.Push(new SaveRequiredPopupDialog("This beatmap will be saved in order to create another difficulty.", () =>
                 {
-                    if (!Save())
-                        return;
+                    attemptMutationOperation(() =>
+                    {
+                        if (!Save())
+                            return false;
 
-                    CreateNewDifficulty(rulesetInfo);
+                        CreateNewDifficulty(rulesetInfo);
+                        return true;
+                    });
                 }));
 
                 return;
@@ -1176,6 +1263,27 @@ namespace osu.Game.Screens.Edit
             loader?.CancelPendingDifficultySwitch();
         }
 
+        public Task<bool> Reload()
+        {
+            var tcs = new TaskCompletionSource<bool>();
+
+            dialogOverlay.Push(new ReloadEditorDialog(
+                reload: () =>
+                {
+                    bool reloadedSuccessfully = attemptMutationOperation(() =>
+                    {
+                        if (!Save())
+                            return false;
+
+                        SwitchToDifficulty(editorBeatmap.BeatmapInfo);
+                        return true;
+                    });
+                    tcs.SetResult(reloadedSuccessfully);
+                },
+                cancel: () => tcs.SetResult(false)));
+            return tcs.Task;
+        }
+
         public void HandleTimestamp(string timestamp)
         {
             if (!EditorTimestampParser.TryParse(timestamp, out var timeSpan, out string selection))
diff --git a/osu.Game/Screens/Edit/EditorBeatmap.cs b/osu.Game/Screens/Edit/EditorBeatmap.cs
index 6363ed2854..ae0fd9130f 100644
--- a/osu.Game/Screens/Edit/EditorBeatmap.cs
+++ b/osu.Game/Screens/Edit/EditorBeatmap.cs
@@ -105,7 +105,7 @@ namespace osu.Game.Screens.Edit
                 BeatmapSkin.BeatmapSkinChanged += SaveState;
             }
 
-            beatmapProcessor = playableBeatmap.BeatmapInfo.Ruleset.CreateInstance().CreateBeatmapProcessor(PlayableBeatmap);
+            beatmapProcessor = new EditorBeatmapProcessor(this, playableBeatmap.BeatmapInfo.Ruleset.CreateInstance());
 
             foreach (var obj in HitObjects)
                 trackStartTime(obj);
@@ -172,7 +172,7 @@ namespace osu.Game.Screens.Edit
             set => PlayableBeatmap.ControlPointInfo = value;
         }
 
-        public List<BreakPeriod> Breaks => PlayableBeatmap.Breaks;
+        public BindableList<BreakPeriod> Breaks => PlayableBeatmap.Breaks;
 
         public List<string> UnhandledEventLines => PlayableBeatmap.UnhandledEventLines;
 
@@ -349,13 +349,13 @@ namespace osu.Game.Screens.Edit
             if (batchPendingUpdates.Count == 0 && batchPendingDeletes.Count == 0 && batchPendingInserts.Count == 0)
                 return;
 
-            beatmapProcessor?.PreProcess();
+            beatmapProcessor.PreProcess();
 
             foreach (var h in batchPendingDeletes) processHitObject(h);
             foreach (var h in batchPendingInserts) processHitObject(h);
             foreach (var h in batchPendingUpdates) processHitObject(h);
 
-            beatmapProcessor?.PostProcess();
+            beatmapProcessor.PostProcess();
 
             BeatmapReprocessed?.Invoke();
 
diff --git a/osu.Game/Screens/Edit/EditorBeatmapProcessor.cs b/osu.Game/Screens/Edit/EditorBeatmapProcessor.cs
new file mode 100644
index 0000000000..99c8c3572b
--- /dev/null
+++ b/osu.Game/Screens/Edit/EditorBeatmapProcessor.cs
@@ -0,0 +1,81 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit
+{
+    public class EditorBeatmapProcessor : IBeatmapProcessor
+    {
+        public IBeatmap Beatmap { get; }
+
+        private readonly IBeatmapProcessor? rulesetBeatmapProcessor;
+
+        public EditorBeatmapProcessor(IBeatmap beatmap, Ruleset ruleset)
+        {
+            Beatmap = beatmap;
+            rulesetBeatmapProcessor = ruleset.CreateBeatmapProcessor(beatmap);
+        }
+
+        public void PreProcess()
+        {
+            rulesetBeatmapProcessor?.PreProcess();
+        }
+
+        public void PostProcess()
+        {
+            rulesetBeatmapProcessor?.PostProcess();
+
+            autoGenerateBreaks();
+        }
+
+        private void autoGenerateBreaks()
+        {
+            Beatmap.Breaks.RemoveAll(b => b is not ManualBreakPeriod);
+
+            foreach (var manualBreak in Beatmap.Breaks.ToList())
+            {
+                if (manualBreak.EndTime <= Beatmap.HitObjects.FirstOrDefault()?.StartTime
+                    || manualBreak.StartTime >= Beatmap.GetLastObjectTime()
+                    || Beatmap.HitObjects.Any(ho => ho.StartTime <= manualBreak.EndTime && ho.GetEndTime() >= manualBreak.StartTime))
+                {
+                    Beatmap.Breaks.Remove(manualBreak);
+                }
+            }
+
+            double currentMaxEndTime = double.MinValue;
+
+            for (int i = 1; i < Beatmap.HitObjects.Count; ++i)
+            {
+                // Keep track of the maximum end time encountered thus far.
+                // This handles cases like osu!mania's hold notes, which could have concurrent other objects after their start time.
+                // Note that we're relying on the implicit assumption that objects are sorted by start time,
+                // which is why similar tracking is not done for start time.
+                currentMaxEndTime = Math.Max(currentMaxEndTime, Beatmap.HitObjects[i - 1].GetEndTime());
+
+                double nextObjectStartTime = Beatmap.HitObjects[i].StartTime;
+
+                if (nextObjectStartTime - currentMaxEndTime < BreakPeriod.MIN_GAP_DURATION)
+                    continue;
+
+                double breakStartTime = currentMaxEndTime + BreakPeriod.GAP_BEFORE_BREAK;
+                double breakEndTime = nextObjectStartTime - Math.Max(BreakPeriod.GAP_AFTER_BREAK, Beatmap.ControlPointInfo.TimingPointAt(nextObjectStartTime).BeatLength * 2);
+
+                if (breakEndTime - breakStartTime < BreakPeriod.MIN_BREAK_DURATION)
+                    continue;
+
+                var breakPeriod = new BreakPeriod(breakStartTime, breakEndTime);
+
+                if (Beatmap.Breaks.Any(b => b.Intersects(breakPeriod)))
+                    continue;
+
+                Beatmap.Breaks.Add(breakPeriod);
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/EditorChangeHandler.cs b/osu.Game/Screens/Edit/EditorChangeHandler.cs
index 0bb17e4c5d..f8ef133549 100644
--- a/osu.Game/Screens/Edit/EditorChangeHandler.cs
+++ b/osu.Game/Screens/Edit/EditorChangeHandler.cs
@@ -83,10 +83,6 @@ namespace osu.Game.Screens.Edit
             }
         }
 
-        /// <summary>
-        /// Restores an older or newer state.
-        /// </summary>
-        /// <param name="direction">The direction to restore in. If less than 0, an older state will be used. If greater than 0, a newer state will be used.</param>
         public void RestoreState(int direction)
         {
             if (TransactionActive)
diff --git a/osu.Game/Screens/Edit/EditorScreenWithTimeline.cs b/osu.Game/Screens/Edit/EditorScreenWithTimeline.cs
index 2b97d363f1..cdc8a26c35 100644
--- a/osu.Game/Screens/Edit/EditorScreenWithTimeline.cs
+++ b/osu.Game/Screens/Edit/EditorScreenWithTimeline.cs
@@ -4,7 +4,6 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
@@ -52,17 +51,11 @@ namespace osu.Game.Screens.Edit
                             AutoSizeAxes = Axes.Y,
                             Children = new Drawable[]
                             {
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = colourProvider.Background4
-                                },
                                 new GridContainer
                                 {
                                     Name = "Timeline content",
                                     RelativeSizeAxes = Axes.X,
                                     AutoSizeAxes = Axes.Y,
-                                    Padding = new MarginPadding { Horizontal = PADDING, Top = PADDING },
                                     Content = new[]
                                     {
                                         new Drawable[]
diff --git a/osu.Game/Screens/Edit/EditorTable.cs b/osu.Game/Screens/Edit/EditorTable.cs
deleted file mode 100644
index 4d8393e829..0000000000
--- a/osu.Game/Screens/Edit/EditorTable.cs
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Diagnostics;
-using osu.Framework.Allocation;
-using osu.Framework.Extensions.LocalisationExtensions;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.Events;
-using osu.Framework.Localisation;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Overlays;
-using osuTK.Graphics;
-
-namespace osu.Game.Screens.Edit
-{
-    public abstract partial class EditorTable : TableContainer
-    {
-        public event Action<Drawable>? OnRowSelected;
-
-        private const float horizontal_inset = 20;
-
-        protected const float ROW_HEIGHT = 25;
-
-        public const int TEXT_SIZE = 14;
-
-        protected readonly FillFlowContainer<RowBackground> BackgroundFlow;
-
-        // We can avoid potentially thousands of objects being added to the input sub-tree since item selection is being handled by the BackgroundFlow
-        // and no items in the underlying table are clickable.
-        protected override bool ShouldBeConsideredForInput(Drawable child) => child == BackgroundFlow && base.ShouldBeConsideredForInput(child);
-
-        protected EditorTable()
-        {
-            RelativeSizeAxes = Axes.X;
-            AutoSizeAxes = Axes.Y;
-
-            Padding = new MarginPadding { Horizontal = horizontal_inset };
-            RowSize = new Dimension(GridSizeMode.Absolute, ROW_HEIGHT);
-
-            AddInternal(BackgroundFlow = new FillFlowContainer<RowBackground>
-            {
-                RelativeSizeAxes = Axes.Both,
-                Depth = 1f,
-                Padding = new MarginPadding { Horizontal = -horizontal_inset },
-                Margin = new MarginPadding { Top = ROW_HEIGHT }
-            });
-        }
-
-        protected int GetIndexForObject(object? item)
-        {
-            for (int i = 0; i < BackgroundFlow.Count; i++)
-            {
-                if (BackgroundFlow[i].Item == item)
-                    return i;
-            }
-
-            return -1;
-        }
-
-        protected virtual bool SetSelectedRow(object? item)
-        {
-            bool foundSelection = false;
-
-            foreach (var b in BackgroundFlow)
-            {
-                b.Selected = ReferenceEquals(b.Item, item);
-
-                if (b.Selected)
-                {
-                    Debug.Assert(!foundSelection);
-                    OnRowSelected?.Invoke(b);
-                    foundSelection = true;
-                }
-            }
-
-            return foundSelection;
-        }
-
-        protected object? GetObjectAtIndex(int index)
-        {
-            if (index < 0 || index > BackgroundFlow.Count - 1)
-                return null;
-
-            return BackgroundFlow[index].Item;
-        }
-
-        protected override Drawable CreateHeader(int index, TableColumn? column) => new HeaderText(column?.Header ?? default);
-
-        private partial class HeaderText : OsuSpriteText
-        {
-            public HeaderText(LocalisableString text)
-            {
-                Text = text.ToUpper();
-                Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold);
-            }
-        }
-
-        public partial class RowBackground : OsuClickableContainer
-        {
-            public readonly object Item;
-
-            private const int fade_duration = 100;
-
-            private readonly Box hoveredBackground;
-
-            public RowBackground(object item)
-            {
-                Item = item;
-
-                RelativeSizeAxes = Axes.X;
-                Height = 25;
-
-                AlwaysPresent = true;
-
-                CornerRadius = 3;
-                Masking = true;
-
-                Children = new Drawable[]
-                {
-                    hoveredBackground = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Alpha = 0,
-                    },
-                };
-            }
-
-            private Color4 colourHover;
-            private Color4 colourSelected;
-
-            [BackgroundDependencyLoader]
-            private void load(OverlayColourProvider colours)
-            {
-                colourHover = colours.Background1;
-                colourSelected = colours.Colour3;
-            }
-
-            protected override void LoadComplete()
-            {
-                base.LoadComplete();
-
-                updateState();
-                FinishTransforms(true);
-            }
-
-            private bool selected;
-
-            public bool Selected
-            {
-                get => selected;
-                set
-                {
-                    if (value == selected)
-                        return;
-
-                    selected = value;
-                    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()
-            {
-                hoveredBackground.FadeColour(selected ? colourSelected : colourHover, 450, Easing.OutQuint);
-
-                if (selected || IsHovered)
-                    hoveredBackground.FadeIn(fade_duration, Easing.OutQuint);
-                else
-                    hoveredBackground.FadeOut(fade_duration, Easing.OutQuint);
-            }
-        }
-    }
-}
diff --git a/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs b/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
index 55607cbb7c..69851d0d35 100644
--- a/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
+++ b/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
@@ -1,11 +1,14 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Screens.Play;
 using osu.Game.Users;
 
@@ -43,6 +46,10 @@ namespace osu.Game.Screens.Edit.GameplayTest
         protected override void LoadComplete()
         {
             base.LoadComplete();
+
+            markPreviousObjectsHit();
+            markVisibleDrawableObjectsHit();
+
             ScoreProcessor.HasCompleted.BindValueChanged(completed =>
             {
                 if (completed.NewValue)
@@ -56,6 +63,69 @@ namespace osu.Game.Screens.Edit.GameplayTest
             });
         }
 
+        private void markPreviousObjectsHit()
+        {
+            foreach (var hitObject in enumerateHitObjects(DrawableRuleset.Objects, editorState.Time))
+            {
+                var judgement = hitObject.Judgement;
+                var result = new JudgementResult(hitObject, judgement) { Type = judgement.MaxResult };
+
+                HealthProcessor.ApplyResult(result);
+                ScoreProcessor.ApplyResult(result);
+            }
+
+            static IEnumerable<HitObject> enumerateHitObjects(IEnumerable<HitObject> hitObjects, double cutoffTime)
+            {
+                foreach (var hitObject in hitObjects)
+                {
+                    foreach (var nested in enumerateHitObjects(hitObject.NestedHitObjects, cutoffTime))
+                    {
+                        if (nested.GetEndTime() < cutoffTime)
+                            yield return nested;
+                    }
+
+                    if (hitObject.GetEndTime() < cutoffTime)
+                        yield return hitObject;
+                }
+            }
+        }
+
+        private void markVisibleDrawableObjectsHit()
+        {
+            if (!DrawableRuleset.Playfield.IsLoaded)
+            {
+                Schedule(markVisibleDrawableObjectsHit);
+                return;
+            }
+
+            foreach (var drawableObjectEntry in enumerateDrawableEntries(
+                         DrawableRuleset.Playfield.AllHitObjects
+                                        .Select(ho => ho.Entry)
+                                        .Where(e => e != null)
+                                        .Cast<HitObjectLifetimeEntry>(), editorState.Time))
+            {
+                drawableObjectEntry.Result = new JudgementResult(drawableObjectEntry.HitObject, drawableObjectEntry.HitObject.Judgement)
+                {
+                    Type = drawableObjectEntry.HitObject.Judgement.MaxResult
+                };
+            }
+
+            static IEnumerable<HitObjectLifetimeEntry> enumerateDrawableEntries(IEnumerable<HitObjectLifetimeEntry> entries, double cutoffTime)
+            {
+                foreach (var entry in entries)
+                {
+                    foreach (var nested in enumerateDrawableEntries(entry.NestedEntries, cutoffTime))
+                    {
+                        if (nested.HitObject.GetEndTime() < cutoffTime)
+                            yield return nested;
+                    }
+
+                    if (entry.HitObject.GetEndTime() < cutoffTime)
+                        yield return entry;
+                }
+            }
+        }
+
         protected override void PrepareReplay()
         {
             // don't record replays.
diff --git a/osu.Game/Screens/Edit/IEditorChangeHandler.cs b/osu.Game/Screens/Edit/IEditorChangeHandler.cs
index 9fe40ba1b1..2259b52ea8 100644
--- a/osu.Game/Screens/Edit/IEditorChangeHandler.cs
+++ b/osu.Game/Screens/Edit/IEditorChangeHandler.cs
@@ -43,5 +43,11 @@ namespace osu.Game.Screens.Edit
         /// Note that this will be a no-op if there is a change in progress via <see cref="BeginChange"/>.
         /// </summary>
         void SaveState();
+
+        /// <summary>
+        /// Restores an older or newer state.
+        /// </summary>
+        /// <param name="direction">The direction to restore in. If less than 0, an older state will be used. If greater than 0, a newer state will be used.</param>
+        void RestoreState(int direction);
     }
 }
diff --git a/osu.Game/Screens/Edit/LegacyEditorBeatmapPatcher.cs b/osu.Game/Screens/Edit/LegacyEditorBeatmapPatcher.cs
index bb9f702cb5..a1ee41fc48 100644
--- a/osu.Game/Screens/Edit/LegacyEditorBeatmapPatcher.cs
+++ b/osu.Game/Screens/Edit/LegacyEditorBeatmapPatcher.cs
@@ -45,6 +45,7 @@ namespace osu.Game.Screens.Edit
             editorBeatmap.BeginChange();
             processHitObjects(result, () => newBeatmap ??= readBeatmap(newState));
             processTimingPoints(() => newBeatmap ??= readBeatmap(newState));
+            processBreaks(() => newBeatmap ??= readBeatmap(newState));
             processHitObjectLocalData(() => newBeatmap ??= readBeatmap(newState));
             editorBeatmap.EndChange();
         }
@@ -75,6 +76,27 @@ namespace osu.Game.Screens.Edit
             }
         }
 
+        private void processBreaks(Func<IBeatmap> getNewBeatmap)
+        {
+            var newBreaks = getNewBeatmap().Breaks.ToArray();
+
+            foreach (var oldBreak in editorBeatmap.Breaks.ToArray())
+            {
+                if (newBreaks.Any(b => b.Equals(oldBreak)))
+                    continue;
+
+                editorBeatmap.Breaks.Remove(oldBreak);
+            }
+
+            foreach (var newBreak in newBreaks)
+            {
+                if (editorBeatmap.Breaks.Any(b => b.Equals(newBreak)))
+                    continue;
+
+                editorBeatmap.Breaks.Add(newBreak);
+            }
+        }
+
         private void processHitObjects(DiffResult result, Func<IBeatmap> getNewBeatmap)
         {
             findChangedIndices(result, LegacyDecoder<Beatmap>.Section.HitObjects, out var removedIndices, out var addedIndices);
diff --git a/osu.Game/Screens/Edit/ManualBreakPeriod.cs b/osu.Game/Screens/Edit/ManualBreakPeriod.cs
new file mode 100644
index 0000000000..3ab77d84ce
--- /dev/null
+++ b/osu.Game/Screens/Edit/ManualBreakPeriod.cs
@@ -0,0 +1,15 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Beatmaps.Timing;
+
+namespace osu.Game.Screens.Edit
+{
+    public class ManualBreakPeriod : BreakPeriod
+    {
+        public ManualBreakPeriod(double startTime, double endTime)
+            : base(startTime, endTime)
+        {
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/ReloadEditorDialog.cs b/osu.Game/Screens/Edit/ReloadEditorDialog.cs
new file mode 100644
index 0000000000..72a9f81347
--- /dev/null
+++ b/osu.Game/Screens/Edit/ReloadEditorDialog.cs
@@ -0,0 +1,34 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Overlays.Dialog;
+using osu.Game.Localisation;
+
+namespace osu.Game.Screens.Edit
+{
+    public partial class ReloadEditorDialog : PopupDialog
+    {
+        public ReloadEditorDialog(Action reload, Action cancel)
+        {
+            HeaderText = EditorDialogsStrings.EditorReloadDialogHeader;
+
+            Icon = FontAwesome.Solid.Sync;
+
+            Buttons = new PopupDialogButton[]
+            {
+                new PopupDialogOkButton
+                {
+                    Text = DialogStrings.Confirm,
+                    Action = reload
+                },
+                new PopupDialogCancelButton
+                {
+                    Text = DialogStrings.Cancel,
+                    Action = cancel
+                }
+            };
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/Setup/LabelledTextBoxWithPopover.cs b/osu.Game/Screens/Edit/Setup/LabelledTextBoxWithPopover.cs
index 5abf40dda7..f9e93e7b0e 100644
--- a/osu.Game/Screens/Edit/Setup/LabelledTextBoxWithPopover.cs
+++ b/osu.Game/Screens/Edit/Setup/LabelledTextBoxWithPopover.cs
@@ -45,7 +45,7 @@ namespace osu.Game.Screens.Edit.Setup
                 OnFocused?.Invoke();
                 base.OnFocus(e);
 
-                GetContainingFocusManager().TriggerFocusContention(this);
+                GetContainingFocusManager()!.TriggerFocusContention(this);
             }
         }
     }
diff --git a/osu.Game/Screens/Edit/Setup/MetadataSection.cs b/osu.Game/Screens/Edit/Setup/MetadataSection.cs
index b575472a18..19071dc806 100644
--- a/osu.Game/Screens/Edit/Setup/MetadataSection.cs
+++ b/osu.Game/Screens/Edit/Setup/MetadataSection.cs
@@ -70,7 +70,7 @@ namespace osu.Game.Screens.Edit.Setup
             base.LoadComplete();
 
             if (string.IsNullOrEmpty(ArtistTextBox.Current.Value))
-                ScheduleAfterChildren(() => GetContainingFocusManager().ChangeFocus(ArtistTextBox));
+                ScheduleAfterChildren(() => GetContainingFocusManager()!.ChangeFocus(ArtistTextBox));
 
             ArtistTextBox.Current.BindValueChanged(artist => transferIfRomanised(artist.NewValue, RomanisedArtistTextBox));
             TitleTextBox.Current.BindValueChanged(title => transferIfRomanised(title.NewValue, RomanisedTitleTextBox));
diff --git a/osu.Game/Screens/Edit/TableHeaderText.cs b/osu.Game/Screens/Edit/TableHeaderText.cs
new file mode 100644
index 0000000000..61301f86ed
--- /dev/null
+++ b/osu.Game/Screens/Edit/TableHeaderText.cs
@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Localisation;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Screens.Edit
+{
+    public partial class TableHeaderText : OsuSpriteText
+    {
+        public TableHeaderText(LocalisableString text)
+        {
+            Text = text.ToUpper();
+            Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold);
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/Timing/ControlPointList.cs b/osu.Game/Screens/Edit/Timing/ControlPointList.cs
index 4e4090ccd0..b7367dddda 100644
--- a/osu.Game/Screens/Edit/Timing/ControlPointList.cs
+++ b/osu.Game/Screens/Edit/Timing/ControlPointList.cs
@@ -7,10 +7,8 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Overlays;
@@ -21,12 +19,8 @@ namespace osu.Game.Screens.Edit.Timing
     public partial class ControlPointList : CompositeDrawable
     {
         private OsuButton deleteButton = null!;
-        private ControlPointTable table = null!;
-        private OsuScrollContainer scroll = null!;
         private RoundedButton addButton = null!;
 
-        private readonly IBindableList<ControlPointGroup> controlPointGroups = new BindableList<ControlPointGroup>();
-
         [Resolved]
         private EditorClock clock { get; set; } = null!;
 
@@ -36,9 +30,6 @@ namespace osu.Game.Screens.Edit.Timing
         [Resolved]
         private Bindable<ControlPointGroup?> selectedGroup { get; set; } = null!;
 
-        [Resolved]
-        private IEditorChangeHandler? changeHandler { get; set; }
-
         [BackgroundDependencyLoader]
         private void load(OverlayColourProvider colours)
         {
@@ -47,21 +38,10 @@ namespace osu.Game.Screens.Edit.Timing
             const float margins = 10;
             InternalChildren = new Drawable[]
             {
-                new Box
-                {
-                    Colour = colours.Background4,
-                    RelativeSizeAxes = Axes.Both,
-                },
-                new Box
-                {
-                    Colour = colours.Background3,
-                    RelativeSizeAxes = Axes.Y,
-                    Width = ControlPointTable.TIMING_COLUMN_WIDTH + margins,
-                },
-                scroll = new OsuScrollContainer
+                new ControlPointTable
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Child = table = new ControlPointTable(),
+                    Groups = { BindTarget = Beatmap.ControlPointInfo.Groups, },
                 },
                 new FillFlowContainer
                 {
@@ -105,20 +85,6 @@ namespace osu.Game.Screens.Edit.Timing
                     ? "+ Clone to current time"
                     : "+ Add at current time";
             }, true);
-
-            controlPointGroups.BindTo(Beatmap.ControlPointInfo.Groups);
-            controlPointGroups.BindCollectionChanged((_, _) =>
-            {
-                // This callback can happen many times in a change operation. It gets expensive.
-                // We really should be handling the `CollectionChanged` event properly.
-                Scheduler.AddOnce(() =>
-                {
-                    table.ControlGroups = controlPointGroups;
-                    changeHandler?.SaveState();
-                });
-            }, true);
-
-            table.OnRowSelected += drawable => scroll.ScrollIntoView(drawable);
         }
 
         protected override bool OnClick(ClickEvent e)
diff --git a/osu.Game/Screens/Edit/Timing/ControlPointTable.cs b/osu.Game/Screens/Edit/Timing/ControlPointTable.cs
index 219575a380..75b86650af 100644
--- a/osu.Game/Screens/Edit/Timing/ControlPointTable.cs
+++ b/osu.Game/Screens/Edit/Timing/ControlPointTable.cs
@@ -2,149 +2,281 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Extensions;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays;
 using osu.Game.Screens.Edit.Timing.RowAttributes;
 using osuTK;
 
 namespace osu.Game.Screens.Edit.Timing
 {
-    public partial class ControlPointTable : EditorTable
+    public partial class ControlPointTable : CompositeDrawable
     {
-        [Resolved]
-        private Bindable<ControlPointGroup?> selectedGroup { get; set; } = null!;
+        public BindableList<ControlPointGroup> Groups { get; } = new BindableList<ControlPointGroup>();
 
-        [Resolved]
-        private EditorClock clock { get; set; } = null!;
+        private const float timing_column_width = 300;
+        private const float row_height = 25;
+        private const float row_horizontal_padding = 20;
 
-        public const float TIMING_COLUMN_WIDTH = 300;
-
-        public IEnumerable<ControlPointGroup> ControlGroups
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colours)
         {
-            set
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
             {
-                int selectedIndex = GetIndexForObject(selectedGroup.Value);
-
-                Content = null;
-                BackgroundFlow.Clear();
-
-                if (!value.Any())
-                    return;
-
-                foreach (var group in value)
+                new Box
                 {
-                    BackgroundFlow.Add(new RowBackground(group)
+                    Colour = colours.Background4,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new Box
+                {
+                    Colour = colours.Background3,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = timing_column_width + 10,
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = row_height,
+                    Padding = new MarginPadding { Horizontal = row_horizontal_padding },
+                    Children = new Drawable[]
                     {
-                        // schedule to give time for any modified focused text box to lose focus and commit changes (e.g. BPM / time signature textboxes) before switching to new point.
-                        Action = () => Schedule(() =>
+                        new TableHeaderText("Time")
                         {
-                            SetSelectedRow(group);
-                            clock.SeekSmoothlyTo(group.Time);
-                        })
-                    });
-                }
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                        },
+                        new TableHeaderText("Attributes")
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Margin = new MarginPadding { Left = ControlPointTable.timing_column_width }
+                        },
+                    }
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = row_height },
+                    Child = new ControlPointRowList
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        RowData = { BindTarget = Groups, },
+                    },
+                },
+            };
+        }
 
-                Columns = createHeaders();
-                Content = value.Select(createContent).ToArray().ToRectangular();
+        private partial class ControlPointRowList : VirtualisedListContainer<ControlPointGroup, DrawableControlGroup>
+        {
+            [Resolved]
+            private Bindable<ControlPointGroup?> selectedGroup { get; set; } = null!;
 
-                // Attempt to retain selection.
-                if (SetSelectedRow(selectedGroup.Value))
-                    return;
+            public ControlPointRowList()
+                : base(row_height, 50)
+            {
+            }
 
-                // Some operations completely obliterate references, so best-effort reselect based on index.
-                if (SetSelectedRow(GetObjectAtIndex(selectedIndex)))
-                    return;
+            protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer();
 
-                // Selection could not be retained.
-                selectedGroup.Value = null;
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                selectedGroup.BindValueChanged(val =>
+                {
+                    // can't use `.ScrollIntoView()` here because of the list virtualisation not giving
+                    // child items valid coordinates from the start, so ballpark something similar
+                    // using estimated row height.
+                    var row = Items.FlowingChildren.SingleOrDefault(item => item.Row.Equals(val.NewValue));
+                    if (row == null)
+                        return;
+
+                    float minPos = Items.GetLayoutPosition(row) * row_height;
+                    float maxPos = minPos + row_height;
+
+                    if (minPos < Scroll.Current)
+                        Scroll.ScrollTo(minPos);
+                    else if (maxPos > Scroll.Current + Scroll.DisplayableContent)
+                        Scroll.ScrollTo(maxPos - Scroll.DisplayableContent);
+                });
             }
         }
 
-        protected override void LoadComplete()
+        public partial class DrawableControlGroup : PoolableDrawable, IHasCurrentValue<ControlPointGroup>
         {
-            base.LoadComplete();
-
-            // Handle external selections.
-            selectedGroup.BindValueChanged(g => SetSelectedRow(g.NewValue), true);
-        }
-
-        protected override bool SetSelectedRow(object? item)
-        {
-            if (!base.SetSelectedRow(item))
-                return false;
-
-            selectedGroup.Value = item as ControlPointGroup;
-            return true;
-        }
-
-        private TableColumn[] createHeaders()
-        {
-            var columns = new List<TableColumn>
+            public Bindable<ControlPointGroup> Current
             {
-                new TableColumn("Time", Anchor.CentreLeft, new Dimension(GridSizeMode.Absolute, TIMING_COLUMN_WIDTH)),
-                new TableColumn("Attributes", Anchor.CentreLeft),
-            };
+                get => current.Current;
+                set => current.Current = value;
+            }
 
-            return columns.ToArray();
-        }
+            private readonly BindableWithCurrent<ControlPointGroup> current = new BindableWithCurrent<ControlPointGroup>();
 
-        private Drawable[] createContent(ControlPointGroup group)
-        {
-            return new Drawable[]
+            private Box background = null!;
+
+            [Resolved]
+            private OverlayColourProvider colourProvider { get; set; } = null!;
+
+            [Resolved]
+            private Bindable<ControlPointGroup?> selectedGroup { get; set; } = null!;
+
+            [Resolved]
+            private EditorClock editorClock { get; set; } = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
             {
-                new ControlGroupTiming(group),
-                new ControlGroupAttributes(group, c => c is not TimingControlPoint)
-            };
+                RelativeSizeAxes = Axes.Both;
+
+                InternalChildren = new Drawable[]
+                {
+                    background = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colourProvider.Background1,
+                        Alpha = 0,
+                    },
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding { Horizontal = row_horizontal_padding, },
+                        Children = new Drawable[]
+                        {
+                            new ControlGroupTiming { Group = { BindTarget = current }, },
+                            new ControlGroupAttributes(point => point is not TimingControlPoint)
+                            {
+                                Group = { BindTarget = current },
+                                Margin = new MarginPadding { Left = timing_column_width }
+                            }
+                        }
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                selectedGroup.BindValueChanged(_ => updateState(), true);
+                FinishTransforms(true);
+            }
+
+            protected override void PrepareForUse()
+            {
+                base.PrepareForUse();
+
+                updateState();
+            }
+
+            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)
+            {
+                // schedule to give time for any modified focused text box to lose focus and commit changes (e.g. BPM / time signature textboxes) before switching to new point.
+                var currentGroup = Current.Value;
+                Schedule(() =>
+                {
+                    selectedGroup.Value = currentGroup;
+                    editorClock.SeekSmoothlyTo(currentGroup.Time);
+                });
+                return true;
+            }
+
+            private void updateState()
+            {
+                bool isSelected = selectedGroup.Value?.Equals(current.Value) == true;
+
+                if (IsHovered || isSelected)
+                    background.FadeIn(100, Easing.OutQuint);
+                else
+                    background.FadeOut(100, Easing.OutQuint);
+
+                background.Colour = isSelected ? colourProvider.Colour3 : colourProvider.Background1;
+            }
         }
 
         private partial class ControlGroupTiming : FillFlowContainer
         {
-            public ControlGroupTiming(ControlPointGroup group)
+            public Bindable<ControlPointGroup> Group { get; } = new Bindable<ControlPointGroup>();
+
+            private OsuSpriteText timeText = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
             {
                 Name = @"ControlGroupTiming";
                 RelativeSizeAxes = Axes.Y;
-                Width = TIMING_COLUMN_WIDTH;
+                Width = timing_column_width;
                 Spacing = new Vector2(5);
                 Children = new Drawable[]
                 {
-                    new OsuSpriteText
+                    timeText = new OsuSpriteText
                     {
-                        Text = group.Time.ToEditorFormattedString(),
-                        Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Bold),
+                        Font = OsuFont.GetFont(size: 14, weight: FontWeight.Bold),
                         Width = 70,
                         Anchor = Anchor.CentreLeft,
                         Origin = Anchor.CentreLeft,
                     },
-                    new ControlGroupAttributes(group, c => c is TimingControlPoint)
+                    new ControlGroupAttributes(c => c is TimingControlPoint)
                     {
                         Anchor = Anchor.CentreLeft,
                         Origin = Anchor.CentreLeft,
+                        Group = { BindTarget = Group },
                     }
                 };
             }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                Group.BindValueChanged(_ => timeText.Text = Group.Value?.Time.ToEditorFormattedString() ?? default(LocalisableString), true);
+            }
         }
 
         private partial class ControlGroupAttributes : CompositeDrawable
         {
+            public Bindable<ControlPointGroup> Group { get; } = new Bindable<ControlPointGroup>();
+            private BindableList<ControlPoint> controlPoints { get; } = new BindableList<ControlPoint>();
+
             private readonly Func<ControlPoint, bool> matchFunction;
 
-            private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
+            private FillFlowContainer fill = null!;
 
-            private readonly FillFlowContainer fill;
-
-            public ControlGroupAttributes(ControlPointGroup group, Func<ControlPoint, bool> matchFunction)
+            public ControlGroupAttributes(Func<ControlPoint, bool> matchFunction)
             {
                 this.matchFunction = matchFunction;
+            }
 
+            [BackgroundDependencyLoader]
+            private void load()
+            {
                 AutoSizeAxes = Axes.X;
                 RelativeSizeAxes = Axes.Y;
                 Name = @"ControlGroupAttributes";
@@ -156,20 +288,21 @@ namespace osu.Game.Screens.Edit.Timing
                     Direction = FillDirection.Horizontal,
                     Spacing = new Vector2(2)
                 };
-
-                controlPoints.BindTo(group.ControlPoints);
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                createChildren();
             }
 
             protected override void LoadComplete()
             {
                 base.LoadComplete();
-                controlPoints.CollectionChanged += (_, _) => createChildren();
+
+                Group.BindValueChanged(_ =>
+                {
+                    controlPoints.UnbindBindings();
+                    controlPoints.Clear();
+                    if (Group.Value != null)
+                        ((IBindableList<ControlPoint>)controlPoints).BindTo(Group.Value.ControlPoints);
+                }, true);
+
+                controlPoints.BindCollectionChanged((_, _) => createChildren(), true);
             }
 
             private void createChildren()
diff --git a/osu.Game/Screens/Edit/Timing/IndeterminateSliderWithTextBoxInput.cs b/osu.Game/Screens/Edit/Timing/IndeterminateSliderWithTextBoxInput.cs
index 4f7a1bf589..01e1856e6c 100644
--- a/osu.Game/Screens/Edit/Timing/IndeterminateSliderWithTextBoxInput.cs
+++ b/osu.Game/Screens/Edit/Timing/IndeterminateSliderWithTextBoxInput.cs
@@ -126,7 +126,7 @@ namespace osu.Game.Screens.Edit.Timing
         protected override void OnFocus(FocusEvent e)
         {
             base.OnFocus(e);
-            GetContainingFocusManager().ChangeFocus(textBox);
+            GetContainingFocusManager()!.ChangeFocus(textBox);
         }
 
         private void updateState()
diff --git a/osu.Game/Screens/Edit/Timing/RowAttributes/AttributeProgressBar.cs b/osu.Game/Screens/Edit/Timing/RowAttributes/AttributeProgressBar.cs
index 4cae774078..0a89f196fa 100644
--- a/osu.Game/Screens/Edit/Timing/RowAttributes/AttributeProgressBar.cs
+++ b/osu.Game/Screens/Edit/Timing/RowAttributes/AttributeProgressBar.cs
@@ -36,6 +36,7 @@ namespace osu.Game.Screens.Edit.Timing.RowAttributes
 
             BackgroundColour = overlayColours.Background6;
             FillColour = controlPoint.GetRepresentingColour(colours);
+            FinishTransforms(true);
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Verify/IssueList.cs b/osu.Game/Screens/Edit/Verify/IssueList.cs
index d07190fca0..de7b760bcd 100644
--- a/osu.Game/Screens/Edit/Verify/IssueList.cs
+++ b/osu.Game/Screens/Edit/Verify/IssueList.cs
@@ -11,7 +11,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Edit;
@@ -56,10 +55,9 @@ namespace osu.Game.Screens.Edit.Verify
                     Colour = colours.Background3,
                     RelativeSizeAxes = Axes.Both,
                 },
-                new OsuScrollContainer
+                table = new IssueTable
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Child = table = new IssueTable(),
                 },
                 new FillFlowContainer
                 {
@@ -101,9 +99,10 @@ namespace osu.Game.Screens.Edit.Verify
 
             issues = filter(issues);
 
-            table.Issues = issues
-                           .OrderBy(issue => issue.Template.Type)
-                           .ThenBy(issue => issue.Check.Metadata.Category);
+            table.Issues.Clear();
+            table.Issues.AddRange(issues
+                                  .OrderBy(issue => issue.Template.Type)
+                                  .ThenBy(issue => issue.Check.Metadata.Category));
         }
 
         private IEnumerable<Issue> filter(IEnumerable<Issue> issues)
diff --git a/osu.Game/Screens/Edit/Verify/IssueTable.cs b/osu.Game/Screens/Edit/Verify/IssueTable.cs
index ba5f98a772..fbe789d452 100644
--- a/osu.Game/Screens/Edit/Verify/IssueTable.cs
+++ b/osu.Game/Screens/Edit/Verify/IssueTable.cs
@@ -1,132 +1,239 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Input.Bindings;
+using osu.Game.Overlays;
 using osu.Game.Rulesets.Edit.Checks.Components;
 
 namespace osu.Game.Screens.Edit.Verify
 {
-    public partial class IssueTable : EditorTable
+    public partial class IssueTable : CompositeDrawable
     {
-        private Bindable<Issue> selectedIssue = null!;
+        public BindableList<Issue> Issues { get; } = new BindableList<Issue>();
 
-        [Resolved]
-        private VerifyScreen verify { get; set; } = null!;
+        public const float COLUMN_WIDTH = 70;
+        public const float COLUMN_GAP = 10;
+        public const float ROW_HEIGHT = 25;
+        public const float ROW_HORIZONTAL_PADDING = 20;
+        public const int TEXT_SIZE = 14;
 
-        [Resolved]
-        private EditorClock clock { get; set; } = null!;
-
-        [Resolved]
-        private EditorBeatmap editorBeatmap { get; set; } = null!;
-
-        [Resolved]
-        private Editor editor { get; set; } = null!;
-
-        public IEnumerable<Issue> Issues
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            set
+            InternalChildren = new Drawable[]
             {
-                Content = null;
-                BackgroundFlow.Clear();
-
-                if (!value.Any())
-                    return;
-
-                foreach (var issue in value)
+                new Container
                 {
-                    BackgroundFlow.Add(new RowBackground(issue)
+                    RelativeSizeAxes = Axes.X,
+                    Height = ROW_HEIGHT,
+                    Padding = new MarginPadding { Horizontal = ROW_HORIZONTAL_PADDING, },
+                    Children = new[]
                     {
-                        Action = () =>
+                        new TableHeaderText("Type")
                         {
-                            selectedIssue.Value = issue;
-
-                            if (issue.Time != null)
-                            {
-                                clock.Seek(issue.Time.Value);
-                                editor.OnPressed(new KeyBindingPressEvent<GlobalAction>(GetContainingInputManager().CurrentState, GlobalAction.EditorComposeMode));
-                            }
-
-                            if (!issue.HitObjects.Any())
-                                return;
-
-                            editorBeatmap.SelectedHitObjects.Clear();
-                            editorBeatmap.SelectedHitObjects.AddRange(issue.HitObjects);
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
                         },
-                    });
+                        new TableHeaderText("Time")
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Margin = new MarginPadding { Left = COLUMN_WIDTH + COLUMN_GAP },
+                        },
+                        new TableHeaderText("Message")
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Margin = new MarginPadding { Left = 2 * (COLUMN_WIDTH + COLUMN_GAP) },
+                        },
+                        new TableHeaderText("Category")
+                        {
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreRight,
+                        },
+                    }
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = ROW_HEIGHT, },
+                    Child = new IssueRowList
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        RowData = { BindTarget = Issues }
+                    }
+                }
+            };
+        }
+
+        private partial class IssueRowList : VirtualisedListContainer<Issue, DrawableIssue>
+        {
+            public IssueRowList()
+                : base(ROW_HEIGHT, 50)
+            {
+            }
+
+            protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer();
+        }
+
+        public partial class DrawableIssue : PoolableDrawable, IHasCurrentValue<Issue>
+        {
+            private readonly BindableWithCurrent<Issue> current = new BindableWithCurrent<Issue>();
+
+            private readonly Bindable<Issue> selectedIssue = new Bindable<Issue>();
+
+            private Box background = null!;
+            private OsuSpriteText issueTypeText = null!;
+            private OsuSpriteText issueTimestampText = null!;
+            private OsuSpriteText issueDetailText = null!;
+            private OsuSpriteText issueCategoryText = null!;
+
+            [Resolved]
+            private EditorClock clock { get; set; } = null!;
+
+            [Resolved]
+            private EditorBeatmap editorBeatmap { get; set; } = null!;
+
+            [Resolved]
+            private Editor editor { get; set; } = null!;
+
+            [Resolved]
+            private OverlayColourProvider colourProvider { get; set; } = null!;
+
+            public Bindable<Issue> Current
+            {
+                get => current.Current;
+                set => current.Current = value;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(VerifyScreen verify)
+            {
+                RelativeSizeAxes = Axes.X;
+                Height = ROW_HEIGHT;
+
+                InternalChildren = new Drawable[]
+                {
+                    background = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding { Horizontal = 20, },
+                        Children = new Drawable[]
+                        {
+                            issueTypeText = new OsuSpriteText
+                            {
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Bold),
+                            },
+                            issueTimestampText = new OsuSpriteText
+                            {
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Bold),
+                                Margin = new MarginPadding { Left = COLUMN_WIDTH + COLUMN_GAP },
+                            },
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding
+                                {
+                                    Left = 2 * (COLUMN_GAP + COLUMN_WIDTH),
+                                    Right = COLUMN_GAP + COLUMN_WIDTH,
+                                },
+                                Child = issueDetailText = new OsuSpriteText
+                                {
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Medium)
+                                },
+                            },
+                            issueCategoryText = new OsuSpriteText
+                            {
+                                Anchor = Anchor.CentreRight,
+                                Origin = Anchor.CentreRight,
+                                Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Bold),
+                            }
+                        }
+                    }
+                };
+
+                selectedIssue.BindTo(verify.SelectedIssue);
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                selectedIssue.BindValueChanged(_ => updateState());
+                Current.BindValueChanged(_ => updateState(), true);
+                FinishTransforms(true);
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                updateState();
+                return true;
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                updateState();
+                base.OnHoverLost(e);
+            }
+
+            protected override bool OnClick(ClickEvent e)
+            {
+                selectedIssue.Value = current.Value;
+
+                if (current.Value.Time != null)
+                {
+                    clock.Seek(current.Value.Time.Value);
+                    editor.OnPressed(new KeyBindingPressEvent<GlobalAction>(GetContainingInputManager()!.CurrentState, GlobalAction.EditorComposeMode));
                 }
 
-                Columns = createHeaders();
-                Content = value.Select((g, i) => createContent(i, g)).ToArray().ToRectangular();
+                if (current.Value.HitObjects.Any())
+                {
+                    editorBeatmap.SelectedHitObjects.Clear();
+                    editorBeatmap.SelectedHitObjects.AddRange(current.Value.HitObjects);
+                }
+
+                return true;
+            }
+
+            private void updateState()
+            {
+                issueTypeText.Text = Current.Value.Template.Type.ToString();
+                issueTypeText.Colour = Current.Value.Template.Colour;
+                issueTimestampText.Text = Current.Value.GetEditorTimestamp();
+                issueDetailText.Text = Current.Value.ToString();
+                issueCategoryText.Text = Current.Value.Check.Metadata.Category.ToString();
+
+                bool isSelected = selectedIssue.Value == current.Value;
+
+                if (IsHovered || isSelected)
+                    background.FadeIn(100, Easing.OutQuint);
+                else
+                    background.FadeOut(100, Easing.OutQuint);
+
+                background.Colour = isSelected ? colourProvider.Colour3 : colourProvider.Background1;
             }
         }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            selectedIssue = verify.SelectedIssue.GetBoundCopy();
-            selectedIssue.BindValueChanged(issue =>
-            {
-                SetSelectedRow(issue.NewValue);
-            }, true);
-        }
-
-        private TableColumn[] createHeaders()
-        {
-            var columns = new List<TableColumn>
-            {
-                new TableColumn(string.Empty, Anchor.CentreLeft, new Dimension(GridSizeMode.AutoSize)),
-                new TableColumn("Type", Anchor.CentreLeft, new Dimension(GridSizeMode.AutoSize, minSize: 60)),
-                new TableColumn("Time", Anchor.CentreLeft, new Dimension(GridSizeMode.AutoSize, minSize: 60)),
-                new TableColumn("Message", Anchor.CentreLeft),
-                new TableColumn("Category", Anchor.CentreRight, new Dimension(GridSizeMode.AutoSize)),
-            };
-
-            return columns.ToArray();
-        }
-
-        private Drawable[] createContent(int index, Issue issue) => new Drawable[]
-        {
-            new OsuSpriteText
-            {
-                Text = $"#{index + 1}",
-                Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Medium),
-                Margin = new MarginPadding { Right = 10 }
-            },
-            new OsuSpriteText
-            {
-                Text = issue.Template.Type.ToString(),
-                Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Bold),
-                Margin = new MarginPadding { Right = 10 },
-                Colour = issue.Template.Colour
-            },
-            new OsuSpriteText
-            {
-                Text = issue.GetEditorTimestamp(),
-                Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Bold),
-                Margin = new MarginPadding { Right = 10 },
-            },
-            new OsuSpriteText
-            {
-                Text = issue.ToString(),
-                Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Medium)
-            },
-            new OsuSpriteText
-            {
-                Text = issue.Check.Metadata.Category.ToString(),
-                Font = OsuFont.GetFont(size: TEXT_SIZE, weight: FontWeight.Bold),
-                Margin = new MarginPadding(10)
-            }
-        };
     }
 }
diff --git a/osu.Game/Screens/Edit/WaveformOpacityMenuItem.cs b/osu.Game/Screens/Edit/WaveformOpacityMenuItem.cs
index 9dc0ea0d07..c379e56940 100644
--- a/osu.Game/Screens/Edit/WaveformOpacityMenuItem.cs
+++ b/osu.Game/Screens/Edit/WaveformOpacityMenuItem.cs
@@ -20,6 +20,7 @@ namespace osu.Game.Screens.Edit
         {
             Items = new[]
             {
+                createMenuItem(0f),
                 createMenuItem(0.25f),
                 createMenuItem(0.5f),
                 createMenuItem(0.75f),
diff --git a/osu.Game/Screens/Footer/ScreenFooter.cs b/osu.Game/Screens/Footer/ScreenFooter.cs
index 4a10a4cdab..594cb3b9c9 100644
--- a/osu.Game/Screens/Footer/ScreenFooter.cs
+++ b/osu.Game/Screens/Footer/ScreenFooter.cs
@@ -1,38 +1,175 @@
 // Copyright (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.Diagnostics;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics.Containers;
+using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
+using osu.Game.Screens.Menu;
 using osuTK;
 
 namespace osu.Game.Screens.Footer
 {
-    public partial class ScreenFooter : InputBlockingContainer
+    public partial class ScreenFooter : OverlayContainer
     {
-        private const int height = 60;
         private const int padding = 60;
+        private const float delay_per_button = 30;
+
+        public const int HEIGHT = 60;
 
         private readonly List<OverlayContainer> overlays = new List<OverlayContainer>();
 
-        /// <param name="button">The button to be added.</param>
-        /// <param name="overlay">The <see cref="OverlayContainer"/> to be toggled by this button.</param>
-        public void AddButton(ScreenFooterButton button, OverlayContainer? overlay = null)
+        private ScreenBackButton backButton = null!;
+        private FillFlowContainer<ScreenFooterButton> buttonsFlow = null!;
+        private Container<ScreenFooterButton> removedButtonsContainer = null!;
+        private LogoTrackingContainer logoTrackingContainer = null!;
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
+        public Action? OnBack;
+
+        public ScreenFooter(BackReceptor? receptor = null)
         {
-            if (overlay != null)
+            RelativeSizeAxes = Axes.X;
+            Height = HEIGHT;
+            Anchor = Anchor.BottomLeft;
+            Origin = Anchor.BottomLeft;
+
+            if (receptor == null)
+                Add(receptor = new BackReceptor());
+
+            receptor.OnBackPressed = () => backButton.TriggerClick();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
             {
-                overlays.Add(overlay);
-                button.Action = () => showOverlay(overlay);
-                button.OverlayState.BindTo(overlay.State);
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background5
+                },
+                buttonsFlow = new FillFlowContainer<ScreenFooterButton>
+                {
+                    Margin = new MarginPadding { Left = 12f + ScreenBackButton.BUTTON_WIDTH + padding },
+                    Y = 10f,
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                    Direction = FillDirection.Horizontal,
+                    Spacing = new Vector2(7, 0),
+                    AutoSizeAxes = Axes.Both
+                },
+                backButton = new ScreenBackButton
+                {
+                    Margin = new MarginPadding { Bottom = 10f, Left = 12f },
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                    Action = () => OnBack?.Invoke(),
+                },
+                removedButtonsContainer = new Container<ScreenFooterButton>
+                {
+                    Margin = new MarginPadding { Left = 12f + ScreenBackButton.BUTTON_WIDTH + padding },
+                    Y = 10f,
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                    AutoSizeAxes = Axes.Both,
+                },
+                (logoTrackingContainer = new LogoTrackingContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                }).WithChild(logoTrackingContainer.LogoFacade.With(f =>
+                {
+                    f.Anchor = Anchor.BottomRight;
+                    f.Origin = Anchor.Centre;
+                    f.Position = new Vector2(-76, -36);
+                })),
+            };
+        }
+
+        public void StartTrackingLogo(OsuLogo logo, float duration = 0, Easing easing = Easing.None) => logoTrackingContainer.StartTracking(logo, duration, easing);
+        public void StopTrackingLogo() => logoTrackingContainer.StopTracking();
+
+        protected override void PopIn()
+        {
+            this.MoveToY(0, 400, Easing.OutQuint)
+                .FadeIn(400, Easing.OutQuint);
+        }
+
+        protected override void PopOut()
+        {
+            this.MoveToY(HEIGHT, 400, Easing.OutQuint)
+                .FadeOut(400, Easing.OutQuint);
+        }
+
+        public void SetButtons(IReadOnlyList<ScreenFooterButton> buttons)
+        {
+            overlays.Clear();
+
+            var oldButtons = buttonsFlow.ToArray();
+
+            for (int i = 0; i < oldButtons.Length; i++)
+            {
+                var oldButton = oldButtons[i];
+
+                buttonsFlow.Remove(oldButton, false);
+                removedButtonsContainer.Add(oldButton);
+
+                if (buttons.Count > 0)
+                    makeButtonDisappearToRightAndExpire(oldButton, i, oldButtons.Length);
+                else
+                    makeButtonDisappearToBottomAndExpire(oldButton, i, oldButtons.Length);
             }
 
-            buttons.Add(button);
+            for (int i = 0; i < buttons.Count; i++)
+            {
+                var newButton = buttons[i];
+
+                if (newButton.Overlay != null)
+                {
+                    newButton.Action = () => showOverlay(newButton.Overlay);
+                    overlays.Add(newButton.Overlay);
+                }
+
+                Debug.Assert(!newButton.IsLoaded);
+                buttonsFlow.Add(newButton);
+
+                int index = i;
+
+                // ensure transforms are added after LoadComplete to not be aborted by the FinishTransforms call.
+                newButton.OnLoadComplete += _ =>
+                {
+                    if (oldButtons.Length > 0)
+                        makeButtonAppearFromLeft(newButton, index, buttons.Count, 240);
+                    else
+                        makeButtonAppearFromBottom(newButton, index);
+                };
+            }
         }
 
+        private void makeButtonAppearFromLeft(ScreenFooterButton button, int index, int count, float startDelay)
+            => button.AppearFromLeft(startDelay + (count - index) * delay_per_button);
+
+        private void makeButtonAppearFromBottom(ScreenFooterButton button, int index)
+            => button.AppearFromBottom(index * delay_per_button);
+
+        private void makeButtonDisappearToRightAndExpire(ScreenFooterButton button, int index, int count)
+            => button.DisappearToRightAndExpire((count - index) * delay_per_button);
+
+        private void makeButtonDisappearToBottomAndExpire(ScreenFooterButton button, int index, int count)
+            => button.DisappearToBottomAndExpire((count - index) * delay_per_button);
+
         private void showOverlay(OverlayContainer overlay)
         {
             foreach (var o in overlays)
@@ -44,43 +181,28 @@ namespace osu.Game.Screens.Footer
             }
         }
 
-        private FillFlowContainer<ScreenFooterButton> buttons = null!;
-
-        public ScreenFooter()
+        public partial class BackReceptor : Drawable, IKeyBindingHandler<GlobalAction>
         {
-            RelativeSizeAxes = Axes.X;
-            Height = height;
-            Anchor = Anchor.BottomLeft;
-            Origin = Anchor.BottomLeft;
-        }
+            public Action? OnBackPressed;
 
-        [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colourProvider)
-        {
-            InternalChildren = new Drawable[]
+            public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
             {
-                new Box
+                if (e.Repeat)
+                    return false;
+
+                switch (e.Action)
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    Colour = colourProvider.Background5
-                },
-                buttons = new FillFlowContainer<ScreenFooterButton>
-                {
-                    Position = new Vector2(ScreenBackButton.BUTTON_WIDTH + padding, 10),
-                    Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.BottomLeft,
-                    Direction = FillDirection.Horizontal,
-                    Spacing = new Vector2(7, 0),
-                    AutoSizeAxes = Axes.Both
-                },
-                new ScreenBackButton
-                {
-                    Margin = new MarginPadding { Bottom = 10f, Left = 12f },
-                    Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.BottomLeft,
-                    Action = () => { },
-                },
-            };
+                    case GlobalAction.Back:
+                        OnBackPressed?.Invoke();
+                        return true;
+                }
+
+                return false;
+            }
+
+            public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+            {
+            }
         }
     }
 }
diff --git a/osu.Game/Screens/Footer/ScreenFooterButton.cs b/osu.Game/Screens/Footer/ScreenFooterButton.cs
index 8fbd9f6cba..1e5576e47a 100644
--- a/osu.Game/Screens/Footer/ScreenFooterButton.cs
+++ b/osu.Game/Screens/Footer/ScreenFooterButton.cs
@@ -55,7 +55,7 @@ namespace osu.Game.Screens.Footer
             set => icon.Icon = value;
         }
 
-        protected LocalisableString Text
+        public LocalisableString Text
         {
             set => text.Text = value;
         }
@@ -69,87 +69,94 @@ namespace osu.Game.Screens.Footer
         private readonly Box glowBox;
         private readonly Box flashLayer;
 
-        public ScreenFooterButton()
+        public readonly OverlayContainer? Overlay;
+
+        public ScreenFooterButton(OverlayContainer? overlay = null)
         {
+            Overlay = overlay;
+
             Size = new Vector2(BUTTON_WIDTH, BUTTON_HEIGHT);
 
-            Child = new Container
+            Children = new Drawable[]
             {
-                EdgeEffect = new EdgeEffectParameters
+                new Container
                 {
-                    Type = EdgeEffectType.Shadow,
-                    Radius = 4,
-                    // Figma says 50% opacity, but it does not match up visually if taken at face value, and looks bad.
-                    Colour = Colour4.Black.Opacity(0.25f),
-                    Offset = new Vector2(0, 2),
-                },
-                Shear = BUTTON_SHEAR,
-                Masking = true,
-                CornerRadius = CORNER_RADIUS,
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    backgroundBox = new Box
+                    EdgeEffect = new EdgeEffectParameters
                     {
-                        RelativeSizeAxes = Axes.Both
+                        Type = EdgeEffectType.Shadow,
+                        Radius = 4,
+                        // Figma says 50% opacity, but it does not match up visually if taken at face value, and looks bad.
+                        Colour = Colour4.Black.Opacity(0.25f),
+                        Offset = new Vector2(0, 2),
                     },
-                    glowBox = new Box
+                    Shear = BUTTON_SHEAR,
+                    Masking = true,
+                    CornerRadius = CORNER_RADIUS,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
                     {
-                        RelativeSizeAxes = Axes.Both
-                    },
-                    // For elements that should not be sheared.
-                    new Container
-                    {
-                        Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
-                        Shear = -BUTTON_SHEAR,
-                        RelativeSizeAxes = Axes.Both,
-                        Children = new Drawable[]
+                        backgroundBox = new Box
                         {
-                            TextContainer = new Container
+                            RelativeSizeAxes = Axes.Both
+                        },
+                        glowBox = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        },
+                        // For elements that should not be sheared.
+                        new Container
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Shear = -BUTTON_SHEAR,
+                            RelativeSizeAxes = Axes.Both,
+                            Children = new Drawable[]
                             {
-                                Anchor = Anchor.TopCentre,
-                                Origin = Anchor.TopCentre,
-                                Y = 42,
-                                AutoSizeAxes = Axes.Both,
-                                Child = text = new OsuSpriteText
+                                TextContainer = new Container
                                 {
-                                    // figma design says the size is 16, but due to the issues with font sizes 19 matches better
-                                    Font = OsuFont.TorusAlternate.With(size: 19),
-                                    AlwaysPresent = true
-                                }
-                            },
-                            icon = new SpriteIcon
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    Y = 42,
+                                    AutoSizeAxes = Axes.Both,
+                                    Child = text = new OsuSpriteText
+                                    {
+                                        // figma design says the size is 16, but due to the issues with font sizes 19 matches better
+                                        Font = OsuFont.TorusAlternate.With(size: 19),
+                                        AlwaysPresent = true
+                                    }
+                                },
+                                icon = new SpriteIcon
+                                {
+                                    Y = 12,
+                                    Size = new Vector2(20),
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre
+                                },
+                            }
+                        },
+                        new Container
+                        {
+                            Shear = -BUTTON_SHEAR,
+                            Anchor = Anchor.BottomCentre,
+                            Origin = Anchor.Centre,
+                            Y = -CORNER_RADIUS,
+                            Size = new Vector2(120, 6),
+                            Masking = true,
+                            CornerRadius = 3,
+                            Child = bar = new Box
                             {
-                                Y = 12,
-                                Size = new Vector2(20),
-                                Anchor = Anchor.TopCentre,
-                                Origin = Anchor.TopCentre
-                            },
-                        }
-                    },
-                    new Container
-                    {
-                        Shear = -BUTTON_SHEAR,
-                        Anchor = Anchor.BottomCentre,
-                        Origin = Anchor.Centre,
-                        Y = -CORNER_RADIUS,
-                        Size = new Vector2(120, 6),
-                        Masking = true,
-                        CornerRadius = 3,
-                        Child = bar = new Box
+                                RelativeSizeAxes = Axes.Both,
+                            }
+                        },
+                        flashLayer = new Box
                         {
                             RelativeSizeAxes = Axes.Both,
-                        }
+                            Colour = Colour4.White.Opacity(0.9f),
+                            Blending = BlendingParameters.Additive,
+                            Alpha = 0,
+                        },
                     },
-                    flashLayer = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = Colour4.White.Opacity(0.9f),
-                        Blending = BlendingParameters.Additive,
-                        Alpha = 0,
-                    },
-                },
+                }
             };
         }
 
@@ -157,6 +164,9 @@ namespace osu.Game.Screens.Footer
         {
             base.LoadComplete();
 
+            if (Overlay != null)
+                OverlayState.BindTo(Overlay.State);
+
             OverlayState.BindValueChanged(_ => updateDisplay());
             Enabled.BindValueChanged(_ => updateDisplay(), true);
 
@@ -215,5 +225,41 @@ namespace osu.Game.Screens.Footer
 
             glowBox.FadeColour(ColourInfo.GradientVertical(buttonAccentColour.Opacity(0f), buttonAccentColour.Opacity(0.2f)), 150, Easing.OutQuint);
         }
+
+        public void AppearFromLeft(double delay)
+        {
+            Content.MoveToX(-300f)
+                   .FadeOut()
+                   .Delay(delay)
+                   .MoveToX(0f, 240, Easing.OutCubic)
+                   .FadeIn(240, Easing.OutCubic);
+        }
+
+        public void AppearFromBottom(double delay)
+        {
+            Content.MoveToY(100f)
+                   .FadeOut()
+                   .Delay(delay)
+                   .MoveToY(0f, 240, Easing.OutCubic)
+                   .FadeIn(240, Easing.OutCubic);
+        }
+
+        public void DisappearToRightAndExpire(double delay)
+        {
+            Content.Delay(delay)
+                   .FadeOut(240, Easing.InOutCubic)
+                   .MoveToX(300f, 360, Easing.InOutCubic);
+
+            this.Delay(Content.LatestTransformEndTime - Time.Current).Expire();
+        }
+
+        public void DisappearToBottomAndExpire(double delay)
+        {
+            Content.Delay(delay)
+                   .FadeOut(240, Easing.InOutCubic)
+                   .MoveToY(100f, 240, Easing.InOutCubic);
+
+            this.Delay(Content.LatestTransformEndTime - Time.Current).Expire();
+        }
     }
 }
diff --git a/osu.Game/Screens/IOsuScreen.cs b/osu.Game/Screens/IOsuScreen.cs
index 5b4e2d75f4..b80c1f87a4 100644
--- a/osu.Game/Screens/IOsuScreen.cs
+++ b/osu.Game/Screens/IOsuScreen.cs
@@ -1,11 +1,13 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using osu.Framework.Bindables;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
+using osu.Game.Screens.Footer;
 using osu.Game.Users;
 
 namespace osu.Game.Screens
@@ -19,10 +21,18 @@ namespace osu.Game.Screens
         bool DisallowExternalBeatmapRulesetChanges { get; }
 
         /// <summary>
-        /// Whether the user can exit this this <see cref="IOsuScreen"/> by pressing the back button.
+        /// Whether the user can exit this <see cref="IOsuScreen"/> by pressing the back button.
         /// </summary>
         bool AllowBackButton { get; }
 
+        /// <summary>
+        /// Whether a footer (and a back button) should be displayed underneath the screen.
+        /// </summary>
+        /// <remarks>
+        /// Temporarily, the back button is shown regardless of whether <see cref="AllowBackButton"/> is true.
+        /// </remarks>
+        bool ShowFooter { get; }
+
         /// <summary>
         /// Whether a top-level component should be allowed to exit the current screen to, for example,
         /// complete an import. Note that this can be overridden by a user if they specifically request.
@@ -63,6 +73,11 @@ namespace osu.Game.Screens
 
         Bindable<RulesetInfo> Ruleset { get; }
 
+        /// <summary>
+        /// A list of footer buttons to be added to the game footer, or empty to display no buttons.
+        /// </summary>
+        IReadOnlyList<ScreenFooterButton> CreateFooterButtons();
+
         /// <summary>
         /// Whether mod track adjustments should be applied on entering this screen.
         /// A <see langword="null"/> value means that the parent screen's value of this setting will be used.
diff --git a/osu.Game/Screens/Menu/MainMenu.cs b/osu.Game/Screens/Menu/MainMenu.cs
index 722e776e3d..00b9d909a1 100644
--- a/osu.Game/Screens/Menu/MainMenu.cs
+++ b/osu.Game/Screens/Menu/MainMenu.cs
@@ -31,6 +31,7 @@ using osu.Game.Overlays.SkinEditor;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Backgrounds;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.OnlinePlay.DailyChallenge;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Playlists;
 using osu.Game.Screens.Select;
@@ -149,9 +150,7 @@ namespace osu.Game.Screens.Menu
                             OnPlaylists = () => this.Push(new Playlists()),
                             OnDailyChallenge = room =>
                             {
-                                Playlists playlistsScreen;
-                                this.Push(playlistsScreen = new Playlists());
-                                playlistsScreen.Join(room);
+                                this.Push(new DailyChallenge(room));
                             },
                             OnExit = () =>
                             {
diff --git a/osu.Game/Screens/OnlinePlay/Components/ListingPollingComponent.cs b/osu.Game/Screens/OnlinePlay/Components/ListingPollingComponent.cs
index c296e2a86b..4b38ea68b3 100644
--- a/osu.Game/Screens/OnlinePlay/Components/ListingPollingComponent.cs
+++ b/osu.Game/Screens/OnlinePlay/Components/ListingPollingComponent.cs
@@ -53,6 +53,8 @@ namespace osu.Game.Screens.OnlinePlay.Components
 
             req.Success += result =>
             {
+                result = result.Where(r => r.Category.Value != RoomCategory.DailyChallenge).ToList();
+
                 foreach (var existing in RoomManager.Rooms.ToArray())
                 {
                     if (result.All(r => r.RoomID.Value != existing.RoomID.Value))
diff --git a/osu.Game/Screens/OnlinePlay/Components/OverlinedPlaylistHeader.cs b/osu.Game/Screens/OnlinePlay/Components/OverlinedPlaylistHeader.cs
index fc86cbbbdd..dd728e460b 100644
--- a/osu.Game/Screens/OnlinePlay/Components/OverlinedPlaylistHeader.cs
+++ b/osu.Game/Screens/OnlinePlay/Components/OverlinedPlaylistHeader.cs
@@ -1,12 +1,17 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Allocation;
 using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
 
 namespace osu.Game.Screens.OnlinePlay.Components
 {
     public partial class OverlinedPlaylistHeader : OverlinedHeader
     {
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
         public OverlinedPlaylistHeader()
             : base("Playlist")
         {
@@ -16,7 +21,7 @@ namespace osu.Game.Screens.OnlinePlay.Components
         {
             base.LoadComplete();
 
-            Playlist.BindCollectionChanged((_, _) => Details.Value = Playlist.GetTotalDuration(), true);
+            Playlist.BindCollectionChanged((_, _) => Details.Value = Playlist.GetTotalDuration(rulesets), true);
         }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs
new file mode 100644
index 0000000000..e2927617f8
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs
@@ -0,0 +1,380 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Screens;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Localisation;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Screens.OnlinePlay.Components;
+using osu.Game.Screens.OnlinePlay.Match;
+using osu.Game.Screens.OnlinePlay.Match.Components;
+using osu.Game.Screens.OnlinePlay.Playlists;
+using osu.Game.Screens.Play;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.DailyChallenge
+{
+    public partial class DailyChallenge : OsuScreen
+    {
+        private readonly Room room;
+        private readonly PlaylistItem playlistItem;
+
+        /// <summary>
+        /// Any mods applied by/to the local user.
+        /// </summary>
+        private readonly Bindable<IReadOnlyList<Mod>> userMods = new Bindable<IReadOnlyList<Mod>>(Array.Empty<Mod>());
+
+        private OnlinePlayScreenWaveContainer waves = null!;
+        private MatchLeaderboard leaderboard = null!;
+        private RoomModSelectOverlay userModsSelectOverlay = null!;
+        private Sample? sampleStart;
+        private IDisposable? userModsSelectOverlayRegistration;
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
+
+        [Cached(Type = typeof(IRoomManager))]
+        private RoomManager roomManager { get; set; }
+
+        [Cached]
+        private readonly OnlinePlayBeatmapAvailabilityTracker beatmapAvailabilityTracker = new OnlinePlayBeatmapAvailabilityTracker();
+
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; } = null!;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
+        [Resolved]
+        private MusicController musicController { get; set; } = null!;
+
+        [Resolved]
+        private IOverlayManager? overlayManager { get; set; }
+
+        public override bool DisallowExternalBeatmapRulesetChanges => true;
+
+        public DailyChallenge(Room room)
+        {
+            this.room = room;
+            playlistItem = room.Playlist.Single();
+            roomManager = new RoomManager();
+        }
+
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+        {
+            return new CachedModelDependencyContainer<Room>(base.CreateChildDependencies(parent))
+            {
+                Model = { Value = room }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            sampleStart = audio.Samples.Get(@"SongSelect/confirm-selection");
+
+            FillFlowContainer footerButtons;
+
+            InternalChild = waves = new OnlinePlayScreenWaveContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    roomManager,
+                    beatmapAvailabilityTracker,
+                    new ScreenStack(new RoomBackgroundScreen(playlistItem))
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    new Header(ButtonSystemStrings.DailyChallenge.ToSentence(), null),
+                    new GridContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding
+                        {
+                            Horizontal = WaveOverlayContainer.WIDTH_PADDING,
+                            Top = Header.HEIGHT,
+                        },
+                        RowDimensions =
+                        [
+                            new Dimension(GridSizeMode.AutoSize),
+                            new Dimension(GridSizeMode.Absolute, 10),
+                            new Dimension(),
+                            new Dimension(GridSizeMode.Absolute, 30),
+                            new Dimension(GridSizeMode.Absolute, 50)
+                        ],
+                        Content = new[]
+                        {
+                            new Drawable[]
+                            {
+                                new DrawableRoomPlaylistItem(playlistItem)
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    AllowReordering = false,
+                                    Scale = new Vector2(1.4f),
+                                    Width = 1 / 1.4f,
+                                }
+                            },
+                            null,
+                            [
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Masking = true,
+                                    CornerRadius = 10,
+                                    Children = new Drawable[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Colour = Color4Extensions.FromHex(@"3e3a44") // Temporary.
+                                        },
+                                        new GridContainer
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Padding = new MarginPadding(10),
+                                            ColumnDimensions =
+                                            [
+                                                new Dimension(),
+                                                new Dimension(GridSizeMode.Absolute, 10),
+                                                new Dimension(),
+                                                new Dimension(GridSizeMode.Absolute, 10),
+                                                new Dimension()
+                                            ],
+                                            Content = new[]
+                                            {
+                                                new Drawable?[]
+                                                {
+                                                    new DailyChallengeTimeRemainingRing
+                                                    {
+                                                        RelativeSizeAxes = Axes.Both,
+                                                    },
+                                                    null,
+                                                    // Middle column (leaderboard)
+                                                    new GridContainer
+                                                    {
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Content = new[]
+                                                        {
+                                                            new Drawable[]
+                                                            {
+                                                                new SectionHeader("Leaderboard")
+                                                            },
+                                                            [leaderboard = new MatchLeaderboard { RelativeSizeAxes = Axes.Both }],
+                                                        },
+                                                        RowDimensions = new[]
+                                                        {
+                                                            new Dimension(GridSizeMode.AutoSize),
+                                                            new Dimension(),
+                                                        }
+                                                    },
+                                                    // Spacer
+                                                    null,
+                                                    // Main right column
+                                                    new GridContainer
+                                                    {
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Content = new[]
+                                                        {
+                                                            new Drawable[]
+                                                            {
+                                                                new SectionHeader("Chat")
+                                                            },
+                                                            [new MatchChatDisplay(room) { RelativeSizeAxes = Axes.Both }]
+                                                        },
+                                                        RowDimensions =
+                                                        [
+                                                            new Dimension(GridSizeMode.AutoSize),
+                                                            new Dimension()
+                                                        ]
+                                                    },
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            ],
+                            null,
+                            [
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding
+                                    {
+                                        Horizontal = -WaveOverlayContainer.WIDTH_PADDING,
+                                    },
+                                    Children = new Drawable[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Colour = Color4Extensions.FromHex(@"28242d") // Temporary.
+                                        },
+                                        footerButtons = new FillFlowContainer
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Padding = new MarginPadding(5),
+                                            Spacing = new Vector2(10),
+                                            Children = new Drawable[]
+                                            {
+                                                new PlaylistsReadyButton
+                                                {
+                                                    Anchor = Anchor.Centre,
+                                                    Origin = Anchor.Centre,
+                                                    RelativeSizeAxes = Axes.Y,
+                                                    Size = new Vector2(250, 1),
+                                                    Action = startPlay
+                                                }
+                                            }
+                                        },
+                                    }
+                                }
+                            ],
+                        }
+                    }
+                }
+            };
+
+            LoadComponent(userModsSelectOverlay = new RoomModSelectOverlay
+            {
+                SelectedMods = { BindTarget = userMods },
+                IsValidMod = _ => false
+            });
+
+            if (playlistItem.AllowedMods.Any())
+            {
+                footerButtons.Insert(-1, new UserModSelectButton
+                {
+                    Text = "Free mods",
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Y,
+                    Size = new Vector2(250, 1),
+                    Action = () => userModsSelectOverlay.Show(),
+                });
+
+                var rulesetInstance = rulesets.GetRuleset(playlistItem.RulesetID)!.CreateInstance();
+                var allowedMods = playlistItem.AllowedMods.Select(m => m.ToMod(rulesetInstance));
+                userModsSelectOverlay.IsValidMod = m => allowedMods.Any(a => a.GetType() == m.GetType());
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            beatmapAvailabilityTracker.SelectedItem.Value = playlistItem;
+            beatmapAvailabilityTracker.Availability.BindValueChanged(_ => trySetDailyChallengeBeatmap(), true);
+
+            userModsSelectOverlayRegistration = overlayManager?.RegisterBlockingOverlay(userModsSelectOverlay);
+            userModsSelectOverlay.SelectedItem.Value = playlistItem;
+            userMods.BindValueChanged(_ => Scheduler.AddOnce(updateMods), true);
+        }
+
+        private void trySetDailyChallengeBeatmap()
+        {
+            var beatmap = beatmapManager.QueryBeatmap(b => b.OnlineID == playlistItem.Beatmap.OnlineID);
+            Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmap); // this will gracefully fall back to dummy beatmap if missing locally.
+            Ruleset.Value = rulesets.GetRuleset(playlistItem.RulesetID);
+        }
+
+        public override void OnEntering(ScreenTransitionEvent e)
+        {
+            base.OnEntering(e);
+
+            waves.Show();
+            roomManager.JoinRoom(room);
+            applyLoopingToTrack();
+        }
+
+        public override void OnResuming(ScreenTransitionEvent e)
+        {
+            base.OnResuming(e);
+            applyLoopingToTrack();
+        }
+
+        public override void OnSuspending(ScreenTransitionEvent e)
+        {
+            base.OnSuspending(e);
+
+            userModsSelectOverlay.Hide();
+            cancelTrackLooping();
+        }
+
+        public override bool OnExiting(ScreenExitEvent e)
+        {
+            waves.Hide();
+            userModsSelectOverlay.Hide();
+            cancelTrackLooping();
+            this.Delay(WaveContainer.DISAPPEAR_DURATION).FadeOut();
+
+            roomManager.PartRoom();
+
+            return base.OnExiting(e);
+        }
+
+        private void applyLoopingToTrack()
+        {
+            if (!this.IsCurrentScreen())
+                return;
+
+            var track = Beatmap.Value?.Track;
+
+            if (track != null)
+            {
+                Beatmap.Value?.PrepareTrackForPreview(true);
+                musicController.EnsurePlayingSomething();
+            }
+        }
+
+        private void cancelTrackLooping()
+        {
+            var track = Beatmap.Value?.Track;
+
+            if (track != null)
+                track.Looping = false;
+        }
+
+        private void updateMods()
+        {
+            if (!this.IsCurrentScreen())
+                return;
+
+            Mods.Value = userMods.Value.Concat(playlistItem.RequiredMods.Select(m => m.ToMod(Ruleset.Value.CreateInstance()))).ToList();
+        }
+
+        private void startPlay()
+        {
+            sampleStart?.Play();
+            this.Push(new PlayerLoader(() => new PlaylistsPlayer(room, playlistItem)
+            {
+                Exited = () => leaderboard.RefetchScores()
+            }));
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            userModsSelectOverlayRegistration?.Dispose();
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeCarousel.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeCarousel.cs
new file mode 100644
index 0000000000..a9f9a5cd78
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeCarousel.cs
@@ -0,0 +1,234 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.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;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.DailyChallenge
+{
+    public partial class DailyChallengeCarousel : Container
+    {
+        private const int switch_interval = 20_500;
+
+        private readonly Container content;
+        private readonly FillFlowContainer<NavigationDot> navigationFlow;
+
+        protected override Container<Drawable> Content => content;
+
+        private double clockStartTime;
+        private int lastDisplayed = -1;
+
+        public DailyChallengeCarousel()
+        {
+            InternalChildren = new Drawable[]
+            {
+                content = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Bottom = 40 },
+                },
+                navigationFlow = new FillFlowContainer<NavigationDot>
+                {
+                    AutoSizeAxes = Axes.X,
+                    Height = 15,
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    Spacing = new Vector2(10),
+                }
+            };
+        }
+
+        public override void Add(Drawable drawable)
+        {
+            drawable.RelativeSizeAxes = Axes.Both;
+            drawable.Size = Vector2.One;
+            drawable.AlwaysPresent = true;
+            drawable.Alpha = 0;
+
+            base.Add(drawable);
+
+            navigationFlow.Add(new NavigationDot { Clicked = onManualNavigation });
+        }
+
+        public override bool Remove(Drawable drawable, bool disposeImmediately)
+        {
+            int index = content.IndexOf(drawable);
+
+            if (index > 0)
+                navigationFlow.Remove(navigationFlow[index], true);
+
+            return base.Remove(drawable, disposeImmediately);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            clockStartTime = Clock.CurrentTime;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (content.Count == 0)
+            {
+                lastDisplayed = -1;
+                return;
+            }
+
+            double elapsed = Clock.CurrentTime - clockStartTime;
+
+            int currentDisplay = (int)(elapsed / switch_interval) % content.Count;
+            double displayProgress = (elapsed % switch_interval) / switch_interval;
+
+            navigationFlow[currentDisplay].Active.Value = true;
+
+            if (content.Count > 1)
+                navigationFlow[currentDisplay].Progress = (float)displayProgress;
+
+            if (currentDisplay == lastDisplayed)
+                return;
+
+            if (lastDisplayed >= 0)
+            {
+                content[lastDisplayed].FadeOutFromOne(250, Easing.OutQuint);
+                navigationFlow[lastDisplayed].Active.Value = false;
+            }
+
+            content[currentDisplay].Delay(250).Then().FadeInFromZero(250, Easing.OutQuint);
+
+            lastDisplayed = currentDisplay;
+        }
+
+        private void onManualNavigation(NavigationDot dot)
+        {
+            int index = navigationFlow.IndexOf(dot);
+
+            if (index < 0)
+                return;
+
+            clockStartTime = Clock.CurrentTime - index * switch_interval;
+        }
+
+        private partial class NavigationDot : CompositeDrawable
+        {
+            public required Action<NavigationDot> Clicked { get; init; }
+
+            public BindableBool Active { get; } = new BindableBool();
+
+            private double progress;
+
+            public float Progress
+            {
+                set
+                {
+                    if (progress == value)
+                        return;
+
+                    progress = value;
+                    progressLayer.Width = value;
+                }
+            }
+
+            [Resolved]
+            private OverlayColourProvider colourProvider { get; set; } = null!;
+
+            private Box background = null!;
+            private Box progressLayer = null!;
+            private Box hoverLayer = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Size = new Vector2(15);
+
+                InternalChildren = new Drawable[]
+                {
+                    new CircularContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        Children = new Drawable[]
+                        {
+                            background = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Colour = colourProvider.Light4,
+                            },
+                            progressLayer = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Width = 0,
+                                Colour = colourProvider.Highlight1,
+                                Blending = BlendingParameters.Additive,
+                                Alpha = 0,
+                            },
+                            hoverLayer = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Colour = Colour4.White,
+                                Blending = BlendingParameters.Additive,
+                                Alpha = 0,
+                            }
+                        }
+                    },
+                    new HoverClickSounds()
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                Active.BindValueChanged(val =>
+                {
+                    if (val.NewValue)
+                    {
+                        background.FadeColour(colourProvider.Highlight1, 250, Easing.OutQuint);
+                        this.ResizeWidthTo(30, 250, Easing.OutQuint);
+                        progressLayer.Width = 0;
+                        progressLayer.Alpha = 0.5f;
+                    }
+                    else
+                    {
+                        background.FadeColour(colourProvider.Light4, 250, Easing.OutQuint);
+                        this.ResizeWidthTo(15, 250, Easing.OutQuint);
+                        progressLayer.FadeOut(250, Easing.OutQuint);
+                    }
+                }, true);
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                base.OnHover(e);
+                hoverLayer.FadeTo(0.2f, 250, Easing.OutQuint);
+                return true;
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                hoverLayer.FadeOut(250, Easing.OutQuint);
+                base.OnHoverLost(e);
+            }
+
+            protected override bool OnClick(ClickEvent e)
+            {
+                Clicked(this);
+
+                hoverLayer.FadeTo(1)
+                          .Then().FadeTo(IsHovered ? 0.2f : 0, 250, Easing.OutQuint);
+
+                return true;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeEventFeed.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeEventFeed.cs
new file mode 100644
index 0000000000..b415b15b65
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeEventFeed.cs
@@ -0,0 +1,131 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Scoring;
+using osu.Game.Users.Drawables;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.DailyChallenge
+{
+    public partial class DailyChallengeEventFeed : CompositeDrawable
+    {
+        private DailyChallengeEventFeedFlow flow = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
+            {
+                new SectionHeader("Events"),
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = 35 },
+                    Child = flow = new DailyChallengeEventFeedFlow
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Direction = FillDirection.Vertical,
+                        Origin = Anchor.BottomCentre,
+                        Anchor = Anchor.BottomCentre,
+                        Spacing = new Vector2(5),
+                        Masking = true,
+                    }
+                }
+            };
+        }
+
+        public void AddNewScore(NewScoreEvent newScoreEvent)
+        {
+            var row = new NewScoreEventRow(newScoreEvent)
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+            };
+            flow.Add(row);
+            row.Delay(15000).Then().FadeOut(300, Easing.OutQuint).Expire();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            for (int i = 0; i < flow.Count; ++i)
+            {
+                var row = flow[i];
+
+                if (row.Y < -flow.DrawHeight)
+                {
+                    row.RemoveAndDisposeImmediately();
+                    i -= 1;
+                }
+            }
+        }
+
+        public record NewScoreEvent(IScoreInfo Score, int? NewRank);
+
+        private partial class DailyChallengeEventFeedFlow : FillFlowContainer
+        {
+            public override IEnumerable<Drawable> FlowingChildren => base.FlowingChildren.Reverse();
+        }
+
+        private partial class NewScoreEventRow : CompositeDrawable
+        {
+            private readonly NewScoreEvent newScore;
+
+            public NewScoreEventRow(NewScoreEvent newScore)
+            {
+                this.newScore = newScore;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                LinkFlowContainer text;
+
+                RelativeSizeAxes = Axes.X;
+                AutoSizeAxes = Axes.Y;
+                AutoSizeDuration = 300;
+                AutoSizeEasing = Easing.OutQuint;
+
+                InternalChildren = new Drawable[]
+                {
+                    // TODO: cast is temporary, will be removed later
+                    new ClickableAvatar((APIUser)newScore.Score.User)
+                    {
+                        Size = new Vector2(16),
+                        Masking = true,
+                        CornerRadius = 8,
+                    },
+                    text = new LinkFlowContainer(t =>
+                    {
+                        t.Font = OsuFont.Default.With(weight: newScore.NewRank == null ? FontWeight.Medium : FontWeight.Bold);
+                        t.Colour = newScore.NewRank < 10 ? colours.Orange1 : Colour4.White;
+                    })
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Padding = new MarginPadding { Left = 21 },
+                    }
+                };
+
+                text.AddUserLink(newScore.Score.User);
+                text.AddText(" got ");
+                text.AddLink($"{newScore.Score.TotalScore:N0} points", () => { }); // TODO: present the score here
+
+                if (newScore.NewRank != null)
+                    text.AddText($" and achieved rank #{newScore.NewRank.Value:N0}");
+
+                text.AddText("!");
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeScoreBreakdown.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeScoreBreakdown.cs
new file mode 100644
index 0000000000..d251a10f9a
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeScoreBreakdown.cs
@@ -0,0 +1,194 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Localisation;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Metadata;
+using osu.Game.Overlays;
+using osu.Game.Scoring;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.DailyChallenge
+{
+    public partial class DailyChallengeScoreBreakdown : CompositeDrawable
+    {
+        private FillFlowContainer<Bar> barsContainer = null!;
+
+        private const int bin_count = MultiplayerPlaylistItemStats.TOTAL_SCORE_DISTRIBUTION_BINS;
+        private long[] bins = new long[bin_count];
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
+            {
+                new SectionHeader("Score breakdown"),
+                barsContainer = new FillFlowContainer<Bar>
+                {
+                    Direction = FillDirection.Horizontal,
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.9f,
+                    Padding = new MarginPadding { Top = 35 },
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                }
+            };
+
+            for (int i = 0; i < bin_count; ++i)
+            {
+                LocalisableString? label = null;
+
+                switch (i)
+                {
+                    case 2:
+                    case 4:
+                    case 6:
+                    case 8:
+                        label = @$"{100 * i}k";
+                        break;
+
+                    case 10:
+                        label = @"1M";
+                        break;
+                }
+
+                barsContainer.Add(new Bar(label)
+                {
+                    Width = 1f / bin_count,
+                });
+            }
+        }
+
+        public void AddNewScore(IScoreInfo scoreInfo)
+        {
+            int targetBin = (int)Math.Clamp(Math.Floor((float)scoreInfo.TotalScore / 100000), 0, bin_count - 1);
+            bins[targetBin] += 1;
+            updateCounts();
+
+            var text = new OsuSpriteText
+            {
+                Text = scoreInfo.TotalScore.ToString(@"N0"),
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.BottomCentre,
+                Font = OsuFont.Default.With(size: 30),
+                RelativePositionAxes = Axes.X,
+                X = (targetBin + 0.5f) / bin_count - 0.5f,
+                Alpha = 0,
+            };
+            AddInternal(text);
+
+            Scheduler.AddDelayed(() =>
+            {
+                float startY = ToLocalSpace(barsContainer[targetBin].CircularBar.ScreenSpaceDrawQuad.TopLeft).Y;
+                text.FadeInFromZero()
+                    .ScaleTo(new Vector2(0.8f), 500, Easing.OutElasticHalf)
+                    .MoveToY(startY)
+                    .MoveToOffset(new Vector2(0, -50), 2500, Easing.OutQuint)
+                    .FadeOut(2500, Easing.OutQuint)
+                    .Expire();
+            }, 150);
+        }
+
+        public void SetInitialCounts(long[] counts)
+        {
+            if (counts.Length != bin_count)
+                throw new ArgumentException(@"Incorrect number of bins.", nameof(counts));
+
+            bins = counts;
+            updateCounts();
+        }
+
+        private void updateCounts()
+        {
+            long max = bins.Max();
+            for (int i = 0; i < bin_count; ++i)
+                barsContainer[i].UpdateCounts(bins[i], max);
+        }
+
+        private partial class Bar : CompositeDrawable
+        {
+            private readonly LocalisableString? label;
+
+            private long count;
+            private long max;
+
+            public Container CircularBar { get; private set; } = null!;
+
+            public Bar(LocalisableString? label = null)
+            {
+                this.label = label;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider)
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                AddInternal(new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding
+                    {
+                        Bottom = 20,
+                        Horizontal = 3,
+                    },
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    Masking = true,
+                    Child = CircularBar = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.BottomCentre,
+                        Origin = Anchor.BottomCentre,
+                        Height = 0.01f,
+                        Masking = true,
+                        CornerRadius = 10,
+                        Colour = colourProvider.Highlight1,
+                        Child = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        }
+                    }
+                });
+
+                if (label != null)
+                {
+                    AddInternal(new OsuSpriteText
+                    {
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomCentre,
+                        Text = label.Value,
+                        Colour = colourProvider.Content2,
+                    });
+                }
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                CircularBar.CornerRadius = Math.Min(CircularBar.DrawHeight / 2, CircularBar.DrawWidth / 4);
+            }
+
+            public void UpdateCounts(long newCount, long newMax)
+            {
+                bool isIncrement = newCount > count;
+
+                count = newCount;
+                max = newMax;
+
+                CircularBar.ResizeHeightTo(0.01f + 0.99f * count / max, 300, Easing.OutQuint);
+                if (isIncrement)
+                    CircularBar.FlashColour(Colour4.White, 600, Easing.OutQuint);
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeTimeRemainingRing.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeTimeRemainingRing.cs
new file mode 100644
index 0000000000..e86f26ad6b
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeTimeRemainingRing.cs
@@ -0,0 +1,142 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Threading;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.DailyChallenge
+{
+    public partial class DailyChallengeTimeRemainingRing : OnlinePlayComposite
+    {
+        private CircularProgress progress = null!;
+        private OsuSpriteText timeText = null!;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
+            {
+                new SectionHeader("Time remaining"),
+                new DrawSizePreservingFillContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = 35 },
+                    TargetDrawSize = new Vector2(200),
+                    Strategy = DrawSizePreservationStrategy.Minimum,
+                    Children = new Drawable[]
+                    {
+                        new CircularProgress
+                        {
+                            Size = new Vector2(180),
+                            InnerRadius = 0.1f,
+                            Progress = 1,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Colour = colourProvider.Background5,
+                        },
+                        progress = new CircularProgress
+                        {
+                            Size = new Vector2(180),
+                            InnerRadius = 0.1f,
+                            Progress = 1,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                        },
+                        new FillFlowContainer
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Direction = FillDirection.Vertical,
+                            Children = new[]
+                            {
+                                timeText = new OsuSpriteText
+                                {
+                                    Text = "00:00:00",
+                                    Font = OsuFont.TorusAlternate.With(size: 40),
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                },
+                                new OsuSpriteText
+                                {
+                                    Text = "remaining",
+                                    Font = OsuFont.Default.With(size: 20),
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            StartDate.BindValueChanged(_ => Scheduler.AddOnce(updateState));
+            EndDate.BindValueChanged(_ => Scheduler.AddOnce(updateState));
+            updateState();
+            FinishTransforms(true);
+        }
+
+        private ScheduledDelegate? scheduledUpdate;
+
+        private void updateState()
+        {
+            scheduledUpdate?.Cancel();
+            scheduledUpdate = null;
+
+            const float transition_duration = 300;
+
+            if (StartDate.Value == null || EndDate.Value == null || EndDate.Value < DateTimeOffset.Now)
+            {
+                timeText.Text = TimeSpan.Zero.ToString(@"hh\:mm\:ss");
+                progress.Progress = 0;
+                timeText.FadeColour(colours.Red2, transition_duration, Easing.OutQuint);
+                progress.FadeColour(colours.Red2, transition_duration, Easing.OutQuint);
+                return;
+            }
+
+            var roomDuration = EndDate.Value.Value - StartDate.Value.Value;
+            var remaining = EndDate.Value.Value - DateTimeOffset.Now;
+
+            timeText.Text = remaining.ToString(@"hh\:mm\:ss");
+            progress.Progress = remaining.TotalSeconds / roomDuration.TotalSeconds;
+
+            if (remaining < TimeSpan.FromMinutes(15))
+            {
+                timeText.Colour = progress.Colour = colours.Red1;
+                timeText
+                    .FadeColour(colours.Red1)
+                    .Then().FlashColour(colours.Red0, transition_duration, Easing.OutQuint);
+                progress
+                    .FadeColour(colours.Red1)
+                    .Then().FlashColour(colours.Red0, transition_duration, Easing.OutQuint);
+            }
+            else
+            {
+                timeText.FadeColour(Colour4.White, transition_duration, Easing.OutQuint);
+                progress.FadeColour(colourProvider.Highlight1, transition_duration, Easing.OutQuint);
+            }
+
+            scheduledUpdate = Scheduler.AddDelayed(updateState, 1000);
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Header.cs b/osu.Game/Screens/OnlinePlay/Header.cs
index 4c4851c3ac..860042fd37 100644
--- a/osu.Game/Screens/OnlinePlay/Header.cs
+++ b/osu.Game/Screens/OnlinePlay/Header.cs
@@ -1,13 +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.
 
-#nullable disable
-
 using Humanizer;
-using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Localisation;
 using osu.Framework.Screens;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
@@ -20,10 +18,10 @@ namespace osu.Game.Screens.OnlinePlay
     {
         public const float HEIGHT = 80;
 
-        private readonly ScreenStack stack;
+        private readonly ScreenStack? stack;
         private readonly MultiHeaderTitle title;
 
-        public Header(string mainTitle, ScreenStack stack)
+        public Header(LocalisableString mainTitle, ScreenStack? stack)
         {
             this.stack = stack;
 
@@ -37,12 +35,15 @@ namespace osu.Game.Screens.OnlinePlay
                 Origin = Anchor.CentreLeft,
             };
 
-            // unnecessary to unbind these as this header has the same lifetime as the screen stack we are attaching to.
-            stack.ScreenPushed += (_, _) => updateSubScreenTitle();
-            stack.ScreenExited += (_, _) => updateSubScreenTitle();
+            if (stack != null)
+            {
+                // unnecessary to unbind these as this header has the same lifetime as the screen stack we are attaching to.
+                stack.ScreenPushed += (_, _) => updateSubScreenTitle();
+                stack.ScreenExited += (_, _) => updateSubScreenTitle();
+            }
         }
 
-        private void updateSubScreenTitle() => title.Screen = stack.CurrentScreen as IOnlinePlaySubScreen;
+        private void updateSubScreenTitle() => title.Screen = stack?.CurrentScreen as IOnlinePlaySubScreen;
 
         private partial class MultiHeaderTitle : CompositeDrawable
         {
@@ -51,13 +52,16 @@ namespace osu.Game.Screens.OnlinePlay
             private readonly OsuSpriteText dot;
             private readonly OsuSpriteText pageTitle;
 
-            [CanBeNull]
-            public IOnlinePlaySubScreen Screen
+            public IOnlinePlaySubScreen? Screen
             {
-                set => pageTitle.Text = value?.ShortTitle.Titleize() ?? string.Empty;
+                set
+                {
+                    pageTitle.Text = value?.ShortTitle.Titleize() ?? default(LocalisableString);
+                    dot.Alpha = pageTitle.Text == default ? 0 : 1;
+                }
             }
 
-            public MultiHeaderTitle(string mainTitle)
+            public MultiHeaderTitle(LocalisableString mainTitle)
             {
                 AutoSizeAxes = Axes.Both;
 
@@ -82,14 +86,14 @@ namespace osu.Game.Screens.OnlinePlay
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
                                 Font = OsuFont.TorusAlternate.With(size: 24),
-                                Text = "·"
+                                Text = "·",
+                                Alpha = 0,
                             },
                             pageTitle = new OsuSpriteText
                             {
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
                                 Font = OsuFont.TorusAlternate.With(size: 24),
-                                Text = "Lounge"
                             }
                         }
                     },
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs b/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs
index 2f6a220c82..fed47e847a 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs
@@ -248,21 +248,21 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
             {
                 base.LoadComplete();
 
-                ScheduleAfterChildren(() => GetContainingFocusManager().ChangeFocus(passwordTextBox));
+                ScheduleAfterChildren(() => GetContainingFocusManager()!.ChangeFocus(passwordTextBox));
                 passwordTextBox.OnCommit += (_, _) => performJoin();
             }
 
             private void performJoin()
             {
                 lounge?.Join(room, passwordTextBox.Text, null, joinFailed);
-                GetContainingFocusManager().TriggerFocusContention(passwordTextBox);
+                GetContainingFocusManager()?.TriggerFocusContention(passwordTextBox);
             }
 
             private void joinFailed(string error) => Schedule(() =>
             {
                 passwordTextBox.Text = string.Empty;
 
-                GetContainingFocusManager().ChangeFocus(passwordTextBox);
+                GetContainingFocusManager()!.ChangeFocus(passwordTextBox);
 
                 errorText.Text = error;
                 errorText
diff --git a/osu.Game/Screens/OnlinePlay/Match/RoomModSelectOverlay.cs b/osu.Game/Screens/OnlinePlay/Match/RoomModSelectOverlay.cs
index 55e077df0f..6a856d8d72 100644
--- a/osu.Game/Screens/OnlinePlay/Match/RoomModSelectOverlay.cs
+++ b/osu.Game/Screens/OnlinePlay/Match/RoomModSelectOverlay.cs
@@ -16,8 +16,7 @@ namespace osu.Game.Screens.OnlinePlay.Match
 {
     public partial class RoomModSelectOverlay : UserModSelectOverlay
     {
-        [Resolved]
-        private IBindable<PlaylistItem> selectedItem { get; set; } = null!;
+        public Bindable<PlaylistItem> SelectedItem { get; } = new Bindable<PlaylistItem>();
 
         [Resolved]
         private RulesetStore rulesets { get; set; } = null!;
@@ -33,7 +32,7 @@ namespace osu.Game.Screens.OnlinePlay.Match
         {
             base.LoadComplete();
 
-            selectedItem.BindValueChanged(v =>
+            SelectedItem.BindValueChanged(v =>
             {
                 roomRequiredMods.Clear();
 
diff --git a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
index 97fbb83992..4eb092d08b 100644
--- a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
@@ -17,12 +17,9 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.Bindings;
-using osu.Framework.Input.Events;
 using osu.Framework.Screens;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
-using osu.Game.Input.Bindings;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
@@ -243,6 +240,7 @@ namespace osu.Game.Screens.OnlinePlay.Match
 
             LoadComponent(UserModsSelectOverlay = new RoomModSelectOverlay
             {
+                SelectedItem = { BindTarget = SelectedItem },
                 SelectedMods = { BindTarget = UserMods },
                 IsValidMod = _ => false
             });
@@ -531,22 +529,6 @@ namespace osu.Game.Screens.OnlinePlay.Match
         /// <param name="room">The room to change the settings of.</param>
         protected abstract RoomSettingsOverlay CreateRoomSettingsOverlay(Room room);
 
-        public partial class UserModSelectButton : PurpleRoundedButton, IKeyBindingHandler<GlobalAction>
-        {
-            public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
-            {
-                if (e.Action == GlobalAction.ToggleModSelection && !e.Repeat)
-                {
-                    TriggerClick();
-                    return true;
-                }
-
-                return false;
-            }
-
-            public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e) { }
-        }
-
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
diff --git a/osu.Game/Screens/OnlinePlay/Match/UserModSelectButton.cs b/osu.Game/Screens/OnlinePlay/Match/UserModSelectButton.cs
new file mode 100644
index 0000000000..f3ea82be99
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Match/UserModSelectButton.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.
+
+#nullable disable
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Input.Bindings;
+using osu.Game.Screens.OnlinePlay.Match.Components;
+
+namespace osu.Game.Screens.OnlinePlay.Match
+{
+    public partial class UserModSelectButton : PurpleRoundedButton, IKeyBindingHandler<GlobalAction>
+    {
+        public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+        {
+            if (e.Action == GlobalAction.ToggleModSelection && !e.Repeat)
+            {
+                TriggerClick();
+                return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e) { }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/OnlinePlayComposite.cs b/osu.Game/Screens/OnlinePlay/OnlinePlayComposite.cs
index ff536a65c4..5be5c4b4f4 100644
--- a/osu.Game/Screens/OnlinePlay/OnlinePlayComposite.cs
+++ b/osu.Game/Screens/OnlinePlay/OnlinePlayComposite.cs
@@ -68,6 +68,9 @@ namespace osu.Game.Screens.OnlinePlay
         [Resolved(typeof(Room))]
         public Bindable<PlaylistAggregateScore> UserScore { get; private set; }
 
+        [Resolved(typeof(Room))]
+        protected Bindable<DateTimeOffset?> StartDate { get; private set; }
+
         [Resolved(typeof(Room))]
         protected Bindable<DateTimeOffset?> EndDate { get; private set; }
 
diff --git a/osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs b/osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs
index 9de458b5c6..9b6284fb89 100644
--- a/osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs
@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Logging;
 using osu.Framework.Screens;
@@ -36,7 +35,7 @@ namespace osu.Game.Screens.OnlinePlay
 
         protected LoungeSubScreen Lounge { get; private set; }
 
-        private MultiplayerWaveContainer waves;
+        private OnlinePlayScreenWaveContainer waves;
         private ScreenStack screenStack;
 
         [Cached(Type = typeof(IRoomManager))]
@@ -63,7 +62,7 @@ namespace osu.Game.Screens.OnlinePlay
         [BackgroundDependencyLoader]
         private void load()
         {
-            InternalChild = waves = new MultiplayerWaveContainer
+            InternalChild = waves = new OnlinePlayScreenWaveContainer
             {
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
@@ -230,19 +229,6 @@ namespace osu.Game.Screens.OnlinePlay
 
         protected abstract LoungeSubScreen CreateLounge();
 
-        private partial class MultiplayerWaveContainer : WaveContainer
-        {
-            protected override bool StartHidden => true;
-
-            public MultiplayerWaveContainer()
-            {
-                FirstWaveColour = Color4Extensions.FromHex(@"654d8c");
-                SecondWaveColour = Color4Extensions.FromHex(@"554075");
-                ThirdWaveColour = Color4Extensions.FromHex(@"44325e");
-                FourthWaveColour = Color4Extensions.FromHex(@"392850");
-            }
-        }
-
         ScreenStack IHasSubScreenStack.SubScreenStack => screenStack;
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/OnlinePlayScreenWaveContainer.cs b/osu.Game/Screens/OnlinePlay/OnlinePlayScreenWaveContainer.cs
new file mode 100644
index 0000000000..bfa68d82cd
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/OnlinePlayScreenWaveContainer.cs
@@ -0,0 +1,22 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable disable
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Game.Graphics.Containers;
+
+namespace osu.Game.Screens.OnlinePlay
+{
+    public partial class OnlinePlayScreenWaveContainer : WaveContainer
+    {
+        protected override bool StartHidden => true;
+
+        public OnlinePlayScreenWaveContainer()
+        {
+            FirstWaveColour = Color4Extensions.FromHex(@"654d8c");
+            SecondWaveColour = Color4Extensions.FromHex(@"554075");
+            ThirdWaveColour = Color4Extensions.FromHex(@"44325e");
+            FourthWaveColour = Color4Extensions.FromHex(@"392850");
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/OnlinePlaySongSelect.cs b/osu.Game/Screens/OnlinePlay/OnlinePlaySongSelect.cs
index 622ffddba6..a8dfece916 100644
--- a/osu.Game/Screens/OnlinePlay/OnlinePlaySongSelect.cs
+++ b/osu.Game/Screens/OnlinePlay/OnlinePlaySongSelect.cs
@@ -173,9 +173,9 @@ namespace osu.Game.Screens.OnlinePlay
             IsValidMod = IsValidMod
         };
 
-        protected override IEnumerable<(FooterButton, OverlayContainer?)> CreateFooterButtons()
+        protected override IEnumerable<(FooterButton, OverlayContainer?)> CreateSongSelectFooterButtons()
         {
-            var baseButtons = base.CreateFooterButtons().ToList();
+            var baseButtons = base.CreateSongSelectFooterButtons().ToList();
             var freeModsButton = new FooterButtonFreeMods(freeModSelectOverlay) { Current = FreeMods };
 
             baseButtons.Insert(baseButtons.FindIndex(b => b.Item1 is FooterButtonMods) + 1, (freeModsButton, freeModSelectOverlay));
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSettingsOverlay.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSettingsOverlay.cs
index 84e419d67a..9166cac9de 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSettingsOverlay.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSettingsOverlay.cs
@@ -24,6 +24,7 @@ using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.Match.Components;
 using osuTK;
 using osu.Game.Localisation;
+using osu.Game.Rulesets;
 
 namespace osu.Game.Screens.OnlinePlay.Playlists
 {
@@ -78,6 +79,9 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             [Resolved]
             private IAPIProvider api { get; set; } = null!;
 
+            [Resolved]
+            private RulesetStore rulesets { get; set; } = null!;
+
             private IBindable<APIUser> localUser = null!;
 
             private readonly Room room;
@@ -366,7 +370,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             public void SelectBeatmap() => editPlaylistButton.TriggerClick();
 
             private void onPlaylistChanged(object? sender, NotifyCollectionChangedEventArgs e) =>
-                playlistLength.Text = $"Length: {Playlist.GetTotalDuration()}";
+                playlistLength.Text = $"Length: {Playlist.GetTotalDuration(rulesets)}";
 
             private bool hasValidSettings => RoomID.Value == null && NameField.Text.Length > 0 && Playlist.Count > 0
                                              && hasValidDuration;
diff --git a/osu.Game/Screens/OsuScreen.cs b/osu.Game/Screens/OsuScreen.cs
index 2e8f85423d..695a074907 100644
--- a/osu.Game/Screens/OsuScreen.cs
+++ b/osu.Game/Screens/OsuScreen.cs
@@ -16,6 +16,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
 using osu.Game.Users;
 
@@ -38,6 +39,8 @@ namespace osu.Game.Screens
 
         public virtual bool AllowBackButton => true;
 
+        public virtual bool ShowFooter => false;
+
         public virtual bool AllowExternalScreenChange => false;
 
         public virtual bool HideOverlaysOnEnter => false;
@@ -141,6 +144,10 @@ namespace osu.Game.Screens
         [Resolved(canBeNull: true)]
         private OsuLogo logo { get; set; }
 
+        [Resolved(canBeNull: true)]
+        [CanBeNull]
+        protected ScreenFooter Footer { get; private set; }
+
         protected OsuScreen()
         {
             Anchor = Anchor.Centre;
@@ -298,6 +305,8 @@ namespace osu.Game.Screens
         /// </summary>
         protected virtual BackgroundScreen CreateBackground() => null;
 
+        public virtual IReadOnlyList<ScreenFooterButton> CreateFooterButtons() => Array.Empty<ScreenFooterButton>();
+
         public virtual bool OnBackButton() => false;
     }
 }
diff --git a/osu.Game/Screens/OsuScreenStack.cs b/osu.Game/Screens/OsuScreenStack.cs
index 7d1f6419ad..7103fd6466 100644
--- a/osu.Game/Screens/OsuScreenStack.cs
+++ b/osu.Game/Screens/OsuScreenStack.cs
@@ -17,6 +17,12 @@ namespace osu.Game.Screens
 
         protected float ParallaxAmount => parallaxContainer.ParallaxAmount;
 
+        public new MarginPadding Padding
+        {
+            get => base.Padding;
+            set => base.Padding = value;
+        }
+
         public OsuScreenStack()
         {
             InternalChild = parallaxContainer = new ParallaxContainer
diff --git a/osu.Game/Screens/Play/GameplayState.cs b/osu.Game/Screens/Play/GameplayState.cs
index 8b0207a340..478acd7229 100644
--- a/osu.Game/Screens/Play/GameplayState.cs
+++ b/osu.Game/Screens/Play/GameplayState.cs
@@ -40,6 +40,7 @@ namespace osu.Game.Screens.Play
         public readonly Score Score;
 
         public readonly ScoreProcessor ScoreProcessor;
+        public readonly HealthProcessor HealthProcessor;
 
         /// <summary>
         /// The storyboard associated with the beatmap.
@@ -68,7 +69,14 @@ namespace osu.Game.Screens.Play
 
         private readonly Bindable<JudgementResult> lastJudgementResult = new Bindable<JudgementResult>();
 
-        public GameplayState(IBeatmap beatmap, Ruleset ruleset, IReadOnlyList<Mod>? mods = null, Score? score = null, ScoreProcessor? scoreProcessor = null, Storyboard? storyboard = null)
+        public GameplayState(
+            IBeatmap beatmap,
+            Ruleset ruleset,
+            IReadOnlyList<Mod>? mods = null,
+            Score? score = null,
+            ScoreProcessor? scoreProcessor = null,
+            HealthProcessor? healthProcessor = null,
+            Storyboard? storyboard = null)
         {
             Beatmap = beatmap;
             Ruleset = ruleset;
@@ -82,6 +90,7 @@ namespace osu.Game.Screens.Play
             };
             Mods = mods ?? Array.Empty<Mod>();
             ScoreProcessor = scoreProcessor ?? ruleset.CreateScoreProcessor();
+            HealthProcessor = healthProcessor ?? ruleset.CreateHealthProcessor(beatmap.HitObjects[0].StartTime);
             Storyboard = storyboard ?? new Storyboard();
         }
 
diff --git a/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs b/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs
index efb4d2108e..bd8f17185b 100644
--- a/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs
@@ -58,6 +58,7 @@ namespace osu.Game.Screens.Play.HUD
                 labelText = new OsuSpriteText
                 {
                     Alpha = 0,
+                    BypassAutoSizeAxes = Axes.X,
                     Text = label.GetValueOrDefault(),
                     Font = OsuFont.Torus.With(size: 12, weight: FontWeight.Bold),
                     Margin = new MarginPadding { Left = 2.5f },
@@ -65,6 +66,8 @@ namespace osu.Game.Screens.Play.HUD
                 NumberContainer = new Container
                 {
                     AutoSizeAxes = Axes.Both,
+                    Anchor = anchor,
+                    Origin = anchor,
                     Children = new[]
                     {
                         wireframesPart = new ArgonCounterSpriteText(wireframesLookup)
diff --git a/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs b/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
new file mode 100644
index 0000000000..09ab7d156c
--- /dev/null
+++ b/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
@@ -0,0 +1,45 @@
+// Copyright (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.Game.Online.Leaderboards;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
+using osuTK;
+
+namespace osu.Game.Screens.Play.HUD
+{
+    public partial class DefaultRankDisplay : Container, ISerialisableDrawable
+    {
+        [Resolved]
+        private ScoreProcessor scoreProcessor { get; set; } = null!;
+
+        public bool UsesFixedAnchor { get; set; }
+
+        private readonly UpdateableRank rank;
+
+        public DefaultRankDisplay()
+        {
+            Size = new Vector2(70, 35);
+
+            InternalChildren = new Drawable[]
+            {
+                rank = new UpdateableRank(Scoring.ScoreRank.X)
+                {
+                    RelativeSizeAxes = Axes.Both
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            rank.Rank = scoreProcessor.Rank.Value;
+
+            scoreProcessor.Rank.BindValueChanged(v => rank.Rank = v.NewValue);
+        }
+    }
+}
\ No newline at end of file
diff --git a/osu.Game/Screens/Play/Player.cs b/osu.Game/Screens/Play/Player.cs
index 42ff1d74f3..3a08d3be24 100644
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@@ -260,7 +260,7 @@ namespace osu.Game.Screens.Play
             Score.ScoreInfo.Ruleset = ruleset.RulesetInfo;
             Score.ScoreInfo.Mods = gameplayMods;
 
-            dependencies.CacheAs(GameplayState = new GameplayState(playableBeatmap, ruleset, gameplayMods, Score, ScoreProcessor, Beatmap.Value.Storyboard));
+            dependencies.CacheAs(GameplayState = new GameplayState(playableBeatmap, ruleset, gameplayMods, Score, ScoreProcessor, HealthProcessor, Beatmap.Value.Storyboard));
 
             var rulesetSkinProvider = new RulesetSkinProvidingContainer(ruleset, playableBeatmap, Beatmap.Value.Skin);
 
diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index 51a0c94ff0..12048ecbbe 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -249,7 +249,7 @@ namespace osu.Game.Screens.Play
         {
             base.LoadComplete();
 
-            inputManager = GetContainingInputManager();
+            inputManager = GetContainingInputManager()!;
 
             showStoryboards.BindValueChanged(val => epilepsyWarning?.FadeTo(val.NewValue ? 1 : 0, 250, Easing.OutQuint), true);
             epilepsyWarning?.FinishTransforms(true);
diff --git a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
index 9039604471..7668d3e635 100644
--- a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
+++ b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
@@ -228,7 +228,8 @@ namespace osu.Game.Screens.Play.PlayerSettings
                 useAverageButton = new SettingsButton
                 {
                     Text = BeatmapOffsetControlStrings.CalibrateUsingLastPlay,
-                    Action = () => Current.Value = lastPlayBeatmapOffset - lastPlayAverage
+                    Action = () => Current.Value = lastPlayBeatmapOffset - lastPlayAverage,
+                    Enabled = { Value = !Precision.AlmostEquals(lastPlayAverage, 0, Current.Precision / 2) }
                 },
                 globalOffsetText = new LinkFlowContainer
                 {
diff --git a/osu.Game/Screens/Ranking/ScorePanel.cs b/osu.Game/Screens/Ranking/ScorePanel.cs
index e283749e32..85da1afe7b 100644
--- a/osu.Game/Screens/Ranking/ScorePanel.cs
+++ b/osu.Game/Screens/Ranking/ScorePanel.cs
@@ -225,7 +225,7 @@ namespace osu.Game.Screens.Ranking
         protected override void Update()
         {
             base.Update();
-            audioContent.Balance.Value = ((ScreenSpaceDrawQuad.Centre.X / game.ScreenSpaceDrawQuad.Width) * 2 - 1) * OsuGameBase.SFX_STEREO_STRENGTH;
+            audioContent.Balance.Value = (Math.Clamp(ScreenSpaceDrawQuad.Centre.X / game.ScreenSpaceDrawQuad.Width, -1, 1) * 2 - 1) * OsuGameBase.SFX_STEREO_STRENGTH;
         }
 
         private void playAppearSample()
diff --git a/osu.Game/Screens/Select/BeatmapCarousel.cs b/osu.Game/Screens/Select/BeatmapCarousel.cs
index 32a1b5cb58..4f2325adbf 100644
--- a/osu.Game/Screens/Select/BeatmapCarousel.cs
+++ b/osu.Game/Screens/Select/BeatmapCarousel.cs
@@ -895,7 +895,6 @@ namespace osu.Game.Screens.Select
                     {
                         var panel = setPool.Get(p => p.Item = item);
 
-                        panel.Depth = item.CarouselYPosition;
                         panel.Y = item.CarouselYPosition;
 
                         Scroll.Add(panel);
@@ -915,6 +914,8 @@ namespace osu.Game.Screens.Select
                 {
                     bool isSelected = item.Item.State.Value == CarouselItemState.Selected;
 
+                    bool hasPassedSelection = item.Item.CarouselYPosition < selectedBeatmapSet?.CarouselYPosition;
+
                     // Cheap way of doing animations when entering / exiting song select.
                     const double half_time = 50;
                     const float panel_x_offset_when_inactive = 200;
@@ -929,6 +930,8 @@ namespace osu.Game.Screens.Select
                         item.Alpha = (float)Interpolation.DampContinuously(item.Alpha, 0, half_time, Clock.ElapsedFrameTime);
                         item.X = (float)Interpolation.DampContinuously(item.X, panel_x_offset_when_inactive, half_time, Clock.ElapsedFrameTime);
                     }
+
+                    Scroll.ChangeChildDepth(item, hasPassedSelection ? -item.Item.CarouselYPosition : item.Item.CarouselYPosition);
                 }
 
                 if (item is DrawableCarouselBeatmapSet set)
@@ -1000,8 +1003,6 @@ namespace osu.Game.Screens.Select
             return set;
         }
 
-        private const float panel_padding = 5;
-
         /// <summary>
         /// Computes the target Y positions for every item in the carousel.
         /// </summary>
@@ -1023,10 +1024,18 @@ namespace osu.Game.Screens.Select
                 {
                     case CarouselBeatmapSet set:
                     {
+                        bool isSelected = item.State.Value == CarouselItemState.Selected;
+
+                        float padding = isSelected ? 5 : -5;
+
+                        if (isSelected)
+                            // double padding because we want to cancel the negative padding from the last item.
+                            currentY += padding * 2;
+
                         visibleItems.Add(set);
                         set.CarouselYPosition = currentY;
 
-                        if (item.State.Value == CarouselItemState.Selected)
+                        if (isSelected)
                         {
                             // scroll position at currentY makes the set panel appear at the very top of the carousel's screen space
                             // move down by half of visible height (height of the carousel's visible extent, including semi-transparent areas)
@@ -1048,7 +1057,7 @@ namespace osu.Game.Screens.Select
                             }
                         }
 
-                        currentY += set.TotalHeight + panel_padding;
+                        currentY += set.TotalHeight + padding;
                         break;
                     }
                 }
@@ -1279,7 +1288,7 @@ namespace osu.Game.Screens.Select
                 {
                     // we need to block right click absolute scrolling when hovering a carousel item so context menus can display.
                     // this can be reconsidered when we have an alternative to right click scrolling.
-                    if (GetContainingInputManager().HoveredDrawables.OfType<DrawableCarouselItem>().Any())
+                    if (GetContainingInputManager()!.HoveredDrawables.OfType<DrawableCarouselItem>().Any())
                     {
                         rightMouseScrollBlocked = true;
                         return false;
diff --git a/osu.Game/Screens/Select/BeatmapInfoWedge.cs b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
index 3cab4b67b6..02682c1851 100644
--- a/osu.Game/Screens/Select/BeatmapInfoWedge.cs
+++ b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
@@ -402,9 +402,7 @@ namespace osu.Game.Screens.Select
                     return;
 
                 // this doesn't consider mods which apply variable rates, yet.
-                double rate = 1;
-                foreach (var mod in mods.Value.OfType<IApplicableToRate>())
-                    rate = mod.ApplyToRate(0, rate);
+                double rate = ModUtils.CalculateRateWithMods(mods.Value);
 
                 int bpmMax = FormatUtils.RoundBPM(beatmap.ControlPointInfo.BPMMaximum, rate);
                 int bpmMin = FormatUtils.RoundBPM(beatmap.ControlPointInfo.BPMMinimum, rate);
diff --git a/osu.Game/Screens/Select/Carousel/DrawableCarouselItem.cs b/osu.Game/Screens/Select/Carousel/DrawableCarouselItem.cs
index 0c3de5848b..4c9ac57d9d 100644
--- a/osu.Game/Screens/Select/Carousel/DrawableCarouselItem.cs
+++ b/osu.Game/Screens/Select/Carousel/DrawableCarouselItem.cs
@@ -144,9 +144,9 @@ namespace osu.Game.Screens.Select.Carousel
             }
 
             if (!Item.Visible)
-                this.FadeOut(300, Easing.OutQuint);
+                this.FadeOut(100, Easing.OutQuint);
             else
-                this.FadeIn(250);
+                this.FadeIn(400, Easing.OutQuint);
         }
 
         protected virtual void Selected()
diff --git a/osu.Game/Screens/Select/Details/AdvancedStats.cs b/osu.Game/Screens/Select/Details/AdvancedStats.cs
index cb820f4da9..1da890100e 100644
--- a/osu.Game/Screens/Select/Details/AdvancedStats.cs
+++ b/osu.Game/Screens/Select/Details/AdvancedStats.cs
@@ -27,6 +27,7 @@ using osu.Game.Configuration;
 using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets;
 using osu.Game.Overlays.Mods;
+using osu.Game.Utils;
 
 namespace osu.Game.Screens.Select.Details
 {
@@ -179,9 +180,7 @@ namespace osu.Game.Screens.Select.Details
 
                 if (Ruleset.Value != null)
                 {
-                    double rate = 1;
-                    foreach (var mod in mods.Value.OfType<IApplicableToRate>())
-                        rate = mod.ApplyToRate(0, rate);
+                    double rate = ModUtils.CalculateRateWithMods(mods.Value);
 
                     adjustedDifficulty = Ruleset.Value.CreateInstance().GetRateAdjustedDisplayDifficulty(originalDifficulty, rate);
 
diff --git a/osu.Game/Screens/Select/FilterControl.cs b/osu.Game/Screens/Select/FilterControl.cs
index 30eb4a8491..877db75317 100644
--- a/osu.Game/Screens/Select/FilterControl.cs
+++ b/osu.Game/Screens/Select/FilterControl.cs
@@ -245,7 +245,7 @@ namespace osu.Game.Screens.Select
             searchTextBox.ReadOnly = true;
             searchTextBox.HoldFocus = false;
             if (searchTextBox.HasFocus)
-                GetContainingFocusManager().ChangeFocus(searchTextBox);
+                GetContainingFocusManager()!.ChangeFocus(searchTextBox);
         }
 
         public void Activate()
diff --git a/osu.Game/Screens/Select/FooterButtonMods.cs b/osu.Game/Screens/Select/FooterButtonMods.cs
index 5685910c0a..a15d315f1b 100644
--- a/osu.Game/Screens/Select/FooterButtonMods.cs
+++ b/osu.Game/Screens/Select/FooterButtonMods.cs
@@ -59,8 +59,8 @@ namespace osu.Game.Screens.Select
         {
             SelectedColour = colours.Yellow;
             DeselectedColour = SelectedColour.Opacity(0.5f);
-            lowMultiplierColour = colours.Red;
-            highMultiplierColour = colours.Green;
+            lowMultiplierColour = colours.Green;
+            highMultiplierColour = colours.Red;
             Text = @"mods";
             Hotkey = GlobalAction.ToggleModSelection;
 
diff --git a/osu.Game/Screens/Select/PlaySongSelect.cs b/osu.Game/Screens/Select/PlaySongSelect.cs
index 52f49ba56a..7b1479f392 100644
--- a/osu.Game/Screens/Select/PlaySongSelect.cs
+++ b/osu.Game/Screens/Select/PlaySongSelect.cs
@@ -95,7 +95,7 @@ namespace osu.Game.Screens.Select
             modsAtGameplayStart = Mods.Value;
 
             // Ctrl+Enter should start map with autoplay enabled.
-            if (GetContainingInputManager().CurrentState?.Keyboard.ControlPressed == true)
+            if (GetContainingInputManager()?.CurrentState?.Keyboard.ControlPressed == true)
             {
                 var autoInstance = getAutoplayMod();
 
diff --git a/osu.Game/Screens/Select/SongSelect.cs b/osu.Game/Screens/Select/SongSelect.cs
index 269ca37ff5..df7eabfd21 100644
--- a/osu.Game/Screens/Select/SongSelect.cs
+++ b/osu.Game/Screens/Select/SongSelect.cs
@@ -61,19 +61,19 @@ namespace osu.Game.Screens.Select
         /// </summary>
         protected virtual bool ControlGlobalMusic => true;
 
-        protected virtual bool ShowFooter => true;
+        protected virtual bool ShowSongSelectFooter => true;
 
         public override bool? ApplyModTrackAdjustments => true;
 
         /// <summary>
-        /// Can be null if <see cref="ShowFooter"/> is false.
+        /// Can be null if <see cref="ShowSongSelectFooter"/> is false.
         /// </summary>
         protected BeatmapOptionsOverlay BeatmapOptions { get; private set; } = null!;
 
         /// <summary>
-        /// Can be null if <see cref="ShowFooter"/> is false.
+        /// Can be null if <see cref="ShowSongSelectFooter"/> is false.
         /// </summary>
-        protected Footer? Footer { get; private set; }
+        protected Footer? SongSelectFooter { get; private set; }
 
         /// <summary>
         /// Contains any panel which is triggered by a footer button.
@@ -168,7 +168,7 @@ namespace osu.Game.Screens.Select
                 Origin = Anchor.CentreRight,
                 RelativeSizeAxes = Axes.Both,
                 BleedTop = FilterControl.HEIGHT,
-                BleedBottom = Footer.HEIGHT,
+                BleedBottom = Select.Footer.HEIGHT,
                 SelectionChanged = updateSelectedBeatmap,
                 BeatmapSetsChanged = carouselBeatmapsLoaded,
                 FilterApplied = () => Scheduler.AddOnce(updateVisibleBeatmapCount),
@@ -215,7 +215,7 @@ namespace osu.Game.Screens.Select
                                         Padding = new MarginPadding
                                         {
                                             Top = FilterControl.HEIGHT,
-                                            Bottom = Footer.HEIGHT
+                                            Bottom = Select.Footer.HEIGHT
                                         },
                                         Child = new LoadingSpinner(true) { State = { Value = Visibility.Visible } }
                                     }
@@ -302,7 +302,7 @@ namespace osu.Game.Screens.Select
                                                 RelativeSizeAxes = Axes.Both,
                                                 Padding = new MarginPadding
                                                 {
-                                                    Bottom = Footer.HEIGHT,
+                                                    Bottom = Select.Footer.HEIGHT,
                                                     Top = WEDGE_HEIGHT + 70,
                                                     Left = left_area_padding,
                                                     Right = left_area_padding * 2,
@@ -327,7 +327,7 @@ namespace osu.Game.Screens.Select
                 modSpeedHotkeyHandler = new ModSpeedHotkeyHandler(),
             });
 
-            if (ShowFooter)
+            if (ShowSongSelectFooter)
             {
                 AddRangeInternal(new Drawable[]
                 {
@@ -336,13 +336,13 @@ namespace osu.Game.Screens.Select
                         Anchor = Anchor.BottomLeft,
                         Origin = Anchor.BottomLeft,
                         RelativeSizeAxes = Axes.Both,
-                        Padding = new MarginPadding { Bottom = Footer.HEIGHT },
+                        Padding = new MarginPadding { Bottom = Select.Footer.HEIGHT },
                         Children = new Drawable[]
                         {
                             BeatmapOptions = new BeatmapOptionsOverlay(),
                         }
                     },
-                    Footer = new Footer()
+                    SongSelectFooter = new Footer()
                 });
             }
 
@@ -350,10 +350,10 @@ namespace osu.Game.Screens.Select
             // therein it will be registered at the `OsuGame` level to properly function as a blocking overlay.
             LoadComponent(ModSelect = CreateModSelectOverlay());
 
-            if (Footer != null)
+            if (SongSelectFooter != null)
             {
-                foreach (var (button, overlay) in CreateFooterButtons())
-                    Footer.AddButton(button, overlay);
+                foreach (var (button, overlay) in CreateSongSelectFooterButtons())
+                    SongSelectFooter.AddButton(button, overlay);
 
                 BeatmapOptions.AddButton(@"Manage", @"collections", FontAwesome.Solid.Book, colours.Green, () => manageCollectionsDialog?.Show());
                 BeatmapOptions.AddButton(@"Delete", @"all difficulties", FontAwesome.Solid.Trash, colours.Pink, () => DeleteBeatmap(Beatmap.Value.BeatmapSetInfo));
@@ -387,7 +387,7 @@ namespace osu.Game.Screens.Select
         /// Creates the buttons to be displayed in the footer.
         /// </summary>
         /// <returns>A set of <see cref="FooterButton"/> and an optional <see cref="OverlayContainer"/> which the button opens when pressed.</returns>
-        protected virtual IEnumerable<(FooterButton, OverlayContainer?)> CreateFooterButtons() => new (FooterButton, OverlayContainer?)[]
+        protected virtual IEnumerable<(FooterButton, OverlayContainer?)> CreateSongSelectFooterButtons() => new (FooterButton, OverlayContainer?)[]
         {
             (new FooterButtonMods { Current = Mods }, ModSelect),
             (new FooterButtonRandom
diff --git a/osu.Game/Screens/SelectV2/Footer/BeatmapOptionsPopover.cs b/osu.Game/Screens/SelectV2/Footer/BeatmapOptionsPopover.cs
index 2827a9cb50..fb2e32dfdc 100644
--- a/osu.Game/Screens/SelectV2/Footer/BeatmapOptionsPopover.cs
+++ b/osu.Game/Screens/SelectV2/Footer/BeatmapOptionsPopover.cs
@@ -20,7 +20,6 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
 using osu.Game.Overlays;
-using osu.Game.Screens.Select;
 using osuTK;
 using osuTK.Graphics;
 using osuTK.Input;
@@ -33,18 +32,22 @@ namespace osu.Game.Screens.SelectV2.Footer
         private FillFlowContainer buttonFlow = null!;
         private readonly ScreenFooterButtonOptions footerButton;
 
+        [Cached]
+        private readonly OverlayColourProvider colourProvider;
+
         private WorkingBeatmap beatmapWhenOpening = null!;
 
         [Resolved]
         private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
 
-        public BeatmapOptionsPopover(ScreenFooterButtonOptions footerButton)
+        public BeatmapOptionsPopover(ScreenFooterButtonOptions footerButton, OverlayColourProvider colourProvider)
         {
             this.footerButton = footerButton;
+            this.colourProvider = colourProvider;
         }
 
         [BackgroundDependencyLoader]
-        private void load(ManageCollectionsDialog? manageCollectionsDialog, SongSelect? songSelect, OsuColour colours, BeatmapManager? beatmapManager)
+        private void load(ManageCollectionsDialog? manageCollectionsDialog, OsuColour colours, BeatmapManager? beatmapManager)
         {
             Content.Padding = new MarginPadding(5);
 
@@ -61,15 +64,15 @@ namespace osu.Game.Screens.SelectV2.Footer
             addButton(SongSelectStrings.ManageCollections, FontAwesome.Solid.Book, () => manageCollectionsDialog?.Show());
 
             addHeader(SongSelectStrings.ForAllDifficulties, beatmapWhenOpening.BeatmapSetInfo.ToString());
-            addButton(SongSelectStrings.DeleteBeatmap, FontAwesome.Solid.Trash, () => songSelect?.DeleteBeatmap(beatmapWhenOpening.BeatmapSetInfo), colours.Red1);
+            addButton(SongSelectStrings.DeleteBeatmap, FontAwesome.Solid.Trash, () => { }, colours.Red1); // songSelect?.DeleteBeatmap(beatmapWhenOpening.BeatmapSetInfo);
 
             addHeader(SongSelectStrings.ForSelectedDifficulty, beatmapWhenOpening.BeatmapInfo.DifficultyName);
             // TODO: make work, and make show "unplayed" or "played" based on status.
             addButton(SongSelectStrings.MarkAsPlayed, FontAwesome.Regular.TimesCircle, null);
-            addButton(SongSelectStrings.ClearAllLocalScores, FontAwesome.Solid.Eraser, () => songSelect?.ClearScores(beatmapWhenOpening.BeatmapInfo), colours.Red1);
+            addButton(SongSelectStrings.ClearAllLocalScores, FontAwesome.Solid.Eraser, () => { }, colours.Red1); // songSelect?.ClearScores(beatmapWhenOpening.BeatmapInfo);
 
-            if (songSelect != null && songSelect.AllowEditing)
-                addButton(SongSelectStrings.EditBeatmap, FontAwesome.Solid.PencilAlt, () => songSelect.Edit(beatmapWhenOpening.BeatmapInfo));
+            // if (songSelect != null && songSelect.AllowEditing)
+            addButton(SongSelectStrings.EditBeatmap, FontAwesome.Solid.PencilAlt, () => { }); // songSelect.Edit(beatmapWhenOpening.BeatmapInfo);
 
             addButton(WebCommonStrings.ButtonsHide.ToSentence(), FontAwesome.Solid.Magic, () => beatmapManager?.Hide(beatmapWhenOpening.BeatmapInfo));
         }
@@ -78,14 +81,11 @@ namespace osu.Game.Screens.SelectV2.Footer
         {
             base.LoadComplete();
 
-            ScheduleAfterChildren(() => GetContainingFocusManager().ChangeFocus(this));
+            ScheduleAfterChildren(() => GetContainingFocusManager()!.ChangeFocus(this));
 
             beatmap.BindValueChanged(_ => Hide());
         }
 
-        [Resolved]
-        private OverlayColourProvider overlayColourProvider { get; set; } = null!;
-
         private void addHeader(LocalisableString text, string? context = null)
         {
             var textFlow = new OsuTextFlowContainer
@@ -102,7 +102,7 @@ namespace osu.Game.Screens.SelectV2.Footer
                 textFlow.NewLine();
                 textFlow.AddText(context, t =>
                 {
-                    t.Colour = overlayColourProvider.Content2;
+                    t.Colour = colourProvider.Content2;
                     t.Font = t.Font.With(size: 13);
                 });
             }
diff --git a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonMods.cs b/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonMods.cs
index f590a19164..841f0297e8 100644
--- a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonMods.cs
+++ b/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonMods.cs
@@ -20,6 +20,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Localisation;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Footer;
 using osu.Game.Screens.Play.HUD;
@@ -59,6 +60,11 @@ namespace osu.Game.Screens.SelectV2.Footer
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
+        public ScreenFooterButtonMods(ModSelectOverlay overlay)
+            : base(overlay)
+        {
+        }
+
         [BackgroundDependencyLoader]
         private void load()
         {
diff --git a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonOptions.cs b/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonOptions.cs
index 74fe3e3d11..72409b5566 100644
--- a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonOptions.cs
+++ b/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonOptions.cs
@@ -8,12 +8,16 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics;
 using osu.Game.Input.Bindings;
+using osu.Game.Overlays;
 using osu.Game.Screens.Footer;
 
 namespace osu.Game.Screens.SelectV2.Footer
 {
     public partial class ScreenFooterButtonOptions : ScreenFooterButton, IHasPopover
     {
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
         [BackgroundDependencyLoader]
         private void load(OsuColour colour)
         {
@@ -25,6 +29,6 @@ namespace osu.Game.Screens.SelectV2.Footer
             Action = this.ShowPopover;
         }
 
-        public Popover GetPopover() => new BeatmapOptionsPopover(this);
+        public Popover GetPopover() => new BeatmapOptionsPopover(this, colourProvider);
     }
 }
diff --git a/osu.Game/Screens/SelectV2/Leaderboards/LeaderboardScoreV2.cs b/osu.Game/Screens/SelectV2/Leaderboards/LeaderboardScoreV2.cs
new file mode 100644
index 0000000000..804a9d24b7
--- /dev/null
+++ b/osu.Game/Screens/SelectV2/Leaderboards/LeaderboardScoreV2.cs
@@ -0,0 +1,754 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Framework.Layout;
+using osu.Framework.Localisation;
+using osu.Game.Configuration;
+using osu.Game.Extensions;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Backgrounds;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Leaderboards;
+using osu.Game.Overlays;
+using osu.Game.Resources.Localisation.Web;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
+using osu.Game.Screens.Select;
+using osu.Game.Users;
+using osu.Game.Users.Drawables;
+using osu.Game.Utils;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.SelectV2.Leaderboards
+{
+    public partial class LeaderboardScoreV2 : OsuClickableContainer, IHasContextMenu, IHasCustomTooltip<ScoreInfo>
+    {
+        private const float expanded_right_content_width = 210;
+        private const float grade_width = 40;
+        private const float username_min_width = 125;
+        private const float statistics_regular_min_width = 175;
+        private const float statistics_compact_min_width = 100;
+        private const float rank_label_width = 65;
+        private const float rank_label_visibility_width_cutoff = rank_label_width + height + username_min_width + statistics_regular_min_width + expanded_right_content_width;
+
+        private readonly ScoreInfo score;
+
+        private const int height = 60;
+        private const int corner_radius = 10;
+        private const int transition_duration = 200;
+
+        private readonly int? rank;
+
+        private readonly bool isPersonalBest;
+
+        private Colour4 foregroundColour;
+        private Colour4 backgroundColour;
+        private ColourInfo totalScoreBackgroundGradient;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        [Resolved]
+        private SongSelect? songSelect { get; set; }
+
+        [Resolved]
+        private IDialogOverlay? dialogOverlay { get; set; }
+
+        [Resolved]
+        private ScoreManager scoreManager { get; set; } = null!;
+
+        private Container content = null!;
+        private Box background = null!;
+        private Box foreground = null!;
+
+        private Drawable avatar = null!;
+        private ClickableAvatar innerAvatar = null!;
+
+        private OsuSpriteText nameLabel = null!;
+        private List<ScoreComponentLabel> statisticsLabels = null!;
+
+        private Container rightContent = null!;
+
+        protected Container RankContainer { get; private set; } = null!;
+        private FillFlowContainer flagBadgeAndDateContainer = null!;
+        private FillFlowContainer modsContainer = null!;
+
+        private OsuSpriteText scoreText = null!;
+        private Drawable scoreRank = null!;
+        private Box totalScoreBackground = null!;
+
+        private FillFlowContainer statisticsContainer = null!;
+        private RankLabel rankLabel = null!;
+        private Container rankLabelOverlay = null!;
+
+        public ITooltip<ScoreInfo> GetCustomTooltip() => new LeaderboardScoreTooltip();
+        public virtual ScoreInfo TooltipContent => score;
+
+        public LeaderboardScoreV2(ScoreInfo score, int? rank, bool isPersonalBest = false)
+        {
+            this.score = score;
+            this.rank = rank;
+            this.isPersonalBest = isPersonalBest;
+
+            Shear = new Vector2(OsuGame.SHEAR, 0);
+            RelativeSizeAxes = Axes.X;
+            Height = height;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var user = score.User;
+
+            foregroundColour = isPersonalBest ? colourProvider.Background1 : colourProvider.Background5;
+            backgroundColour = isPersonalBest ? colourProvider.Background2 : colourProvider.Background4;
+            totalScoreBackgroundGradient = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), backgroundColour);
+
+            statisticsLabels = GetStatistics(score).Select(s => new ScoreComponentLabel(s, score)
+            {
+                // ensure statistics container is the correct width when invalidating
+                AlwaysPresent = true,
+            }).ToList();
+
+            Child = content = new Container
+            {
+                Masking = true,
+                CornerRadius = corner_radius,
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    background = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = backgroundColour
+                    },
+                    new GridContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        ColumnDimensions = new[]
+                        {
+                            new Dimension(GridSizeMode.AutoSize),
+                            new Dimension(),
+                            new Dimension(GridSizeMode.AutoSize),
+                        },
+                        Content = new[]
+                        {
+                            new Drawable[]
+                            {
+                                new Container
+                                {
+                                    AutoSizeAxes = Axes.X,
+                                    RelativeSizeAxes = Axes.Y,
+                                    Child = rankLabel = new RankLabel(rank)
+                                    {
+                                        Width = rank_label_width,
+                                        RelativeSizeAxes = Axes.Y,
+                                    },
+                                },
+                                createCentreContent(user),
+                                createRightContent()
+                            }
+                        }
+                    }
+                }
+            };
+
+            innerAvatar.OnLoadComplete += d => d.FadeInFromZero(200);
+        }
+
+        [Resolved]
+        private OsuConfigManager config { get; set; } = null!;
+
+        private IBindable<ScoringMode> scoringMode { get; set; } = null!;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            scoringMode = config.GetBindable<ScoringMode>(OsuSetting.ScoreDisplayMode);
+            scoringMode.BindValueChanged(s =>
+            {
+                switch (s.NewValue)
+                {
+                    case ScoringMode.Standardised:
+                        rightContent.Width = 180f;
+                        break;
+
+                    case ScoringMode.Classic:
+                        rightContent.Width = expanded_right_content_width;
+                        break;
+                }
+
+                updateModDisplay();
+            }, true);
+        }
+
+        private void updateModDisplay()
+        {
+            int maxMods = scoringMode.Value == ScoringMode.Standardised ? 4 : 5;
+
+            if (score.Mods.Length > 0)
+            {
+                modsContainer.Padding = new MarginPadding { Top = 4f };
+                modsContainer.ChildrenEnumerable = score.Mods.AsOrdered().Take(Math.Min(maxMods, score.Mods.Length)).Select(mod => new ColouredModSwitchTiny(mod)
+                {
+                    Scale = new Vector2(0.375f)
+                });
+
+                if (score.Mods.Length > maxMods)
+                {
+                    modsContainer.Remove(modsContainer[^1], true);
+                    modsContainer.Add(new MoreModSwitchTiny(score.Mods.Length - maxMods + 1)
+                    {
+                        Scale = new Vector2(0.375f),
+                    });
+                }
+            }
+        }
+
+        private Container createCentreContent(APIUser user) => new Container
+        {
+            Name = @"Centre container",
+            Masking = true,
+            CornerRadius = corner_radius,
+            RelativeSizeAxes = Axes.Both,
+            Children = new Drawable[]
+            {
+                foreground = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = foregroundColour
+                },
+                new UserCoverBackground
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    User = score.User,
+                    Shear = new Vector2(-OsuGame.SHEAR, 0),
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                    Colour = ColourInfo.GradientHorizontal(Colour4.White.Opacity(0.5f), Colour4.FromHex(@"222A27").Opacity(1)),
+                },
+                new GridContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    ColumnDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.AutoSize),
+                        new Dimension(),
+                        new Dimension(GridSizeMode.AutoSize),
+                    },
+                    Content = new[]
+                    {
+                        new Drawable[]
+                        {
+                            new Container
+                            {
+                                AutoSizeAxes = Axes.Both,
+                                CornerRadius = corner_radius,
+                                Masking = true,
+                                Children = new[]
+                                {
+                                    avatar = new DelayedLoadWrapper(
+                                        innerAvatar = new ClickableAvatar(user)
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Scale = new Vector2(1.1f),
+                                            Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                            RelativeSizeAxes = Axes.Both,
+                                        })
+                                    {
+                                        RelativeSizeAxes = Axes.None,
+                                        Size = new Vector2(height)
+                                    },
+                                    rankLabelOverlay = new Container
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Alpha = 0,
+                                        Children = new Drawable[]
+                                        {
+                                            new Box
+                                            {
+                                                RelativeSizeAxes = Axes.Both,
+                                                Colour = Colour4.Black.Opacity(0.5f),
+                                            },
+                                            new RankLabel(rank)
+                                            {
+                                                AutoSizeAxes = Axes.Both,
+                                                Anchor = Anchor.Centre,
+                                                Origin = Anchor.Centre,
+                                            },
+                                        }
+                                    }
+                                },
+                            },
+                            new FillFlowContainer
+                            {
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
+                                Direction = FillDirection.Vertical,
+                                Padding = new MarginPadding { Horizontal = corner_radius },
+                                Children = new Drawable[]
+                                {
+                                    flagBadgeAndDateContainer = new FillFlowContainer
+                                    {
+                                        Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                        Direction = FillDirection.Horizontal,
+                                        Spacing = new Vector2(5),
+                                        AutoSizeAxes = Axes.Both,
+                                        Masking = true,
+                                        Children = new Drawable[]
+                                        {
+                                            new UpdateableFlag(user.CountryCode)
+                                            {
+                                                Anchor = Anchor.CentreLeft,
+                                                Origin = Anchor.CentreLeft,
+                                                Size = new Vector2(24, 16),
+                                            },
+                                            new DateLabel(score.Date)
+                                            {
+                                                Anchor = Anchor.CentreLeft,
+                                                Origin = Anchor.CentreLeft,
+                                                UseFullGlyphHeight = false,
+                                            }
+                                        }
+                                    },
+                                    nameLabel = new TruncatingSpriteText
+                                    {
+                                        RelativeSizeAxes = Axes.X,
+                                        Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                        Text = user.Username,
+                                        Font = OsuFont.GetFont(size: 20, weight: FontWeight.SemiBold)
+                                    }
+                                }
+                            },
+                            new Container
+                            {
+                                AutoSizeAxes = Axes.Both,
+                                Anchor = Anchor.CentreRight,
+                                Origin = Anchor.CentreRight,
+                                Child = statisticsContainer = new FillFlowContainer
+                                {
+                                    Name = @"Statistics container",
+                                    Padding = new MarginPadding { Right = 40 },
+                                    Spacing = new Vector2(25, 0),
+                                    Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                    Anchor = Anchor.CentreRight,
+                                    Origin = Anchor.CentreRight,
+                                    AutoSizeAxes = Axes.Both,
+                                    Direction = FillDirection.Horizontal,
+                                    Children = statisticsLabels,
+                                    Alpha = 0,
+                                    LayoutEasing = Easing.OutQuint,
+                                    LayoutDuration = transition_duration,
+                                }
+                            }
+                        }
+                    },
+                },
+            },
+        };
+
+        private Container createRightContent() => rightContent = new Container
+        {
+            Name = @"Right content",
+            RelativeSizeAxes = Axes.Y,
+            Child = new Container
+            {
+                AutoSizeAxes = Axes.X,
+                RelativeSizeAxes = Axes.Y,
+                Anchor = Anchor.TopRight,
+                Origin = Anchor.TopRight,
+                Children = new Drawable[]
+                {
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding { Right = grade_width },
+                        Child = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), OsuColour.ForRank(score.Rank)),
+                        },
+                    },
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Y,
+                        Width = grade_width,
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                        Colour = OsuColour.ForRank(score.Rank),
+                    },
+                    new TrianglesV2
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                        SpawnRatio = 2,
+                        Velocity = 0.7f,
+                        Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), OsuColour.ForRank(score.Rank).Darken(0.2f)),
+                    },
+                    RankContainer = new Container
+                    {
+                        Shear = new Vector2(-OsuGame.SHEAR, 0),
+                        Anchor = Anchor.CentreRight,
+                        Origin = Anchor.CentreRight,
+                        RelativeSizeAxes = Axes.Y,
+                        Width = grade_width,
+                        Child = scoreRank = new OsuSpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Spacing = new Vector2(-2),
+                            Colour = DrawableRank.GetRankNameColour(score.Rank),
+                            Font = OsuFont.Numeric.With(size: 16),
+                            Text = DrawableRank.GetRankName(score.Rank),
+                            ShadowColour = Color4.Black.Opacity(0.3f),
+                            ShadowOffset = new Vector2(0, 0.08f),
+                            Shadow = true,
+                            UseFullGlyphHeight = false,
+                        },
+                    },
+                    new Container
+                    {
+                        AutoSizeAxes = Axes.X,
+                        RelativeSizeAxes = Axes.Y,
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                        Padding = new MarginPadding { Right = grade_width },
+                        Child = new Container
+                        {
+                            AutoSizeAxes = Axes.X,
+                            RelativeSizeAxes = Axes.Y,
+                            Masking = true,
+                            CornerRadius = corner_radius,
+                            Children = new Drawable[]
+                            {
+                                totalScoreBackground = new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = totalScoreBackgroundGradient,
+                                },
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0), OsuColour.ForRank(score.Rank).Opacity(0.5f)),
+                                },
+                                new FillFlowContainer
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    Direction = FillDirection.Vertical,
+                                    Padding = new MarginPadding { Horizontal = corner_radius },
+                                    Children = new Drawable[]
+                                    {
+                                        scoreText = new OsuSpriteText
+                                        {
+                                            Anchor = Anchor.TopRight,
+                                            Origin = Anchor.TopRight,
+                                            UseFullGlyphHeight = false,
+                                            Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                            Current = scoreManager.GetBindableTotalScoreString(score),
+                                            Font = OsuFont.GetFont(size: 30, weight: FontWeight.Light),
+                                        },
+                                        modsContainer = new FillFlowContainer
+                                        {
+                                            Anchor = Anchor.TopRight,
+                                            Origin = Anchor.TopRight,
+                                            Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                            AutoSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Spacing = new Vector2(2f, 0f),
+                                        },
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        };
+
+        protected (CaseTransformableString, LocalisableString DisplayAccuracy)[] GetStatistics(ScoreInfo model) => new[]
+        {
+            (BeatmapsetsStrings.ShowScoreboardHeadersCombo.ToUpper(), model.MaxCombo.ToString().Insert(model.MaxCombo.ToString().Length, "x")),
+            (BeatmapsetsStrings.ShowScoreboardHeadersAccuracy.ToUpper(), model.DisplayAccuracy),
+        };
+
+        public override void Show()
+        {
+            foreach (var d in new[] { avatar, nameLabel, scoreText, scoreRank, flagBadgeAndDateContainer, modsContainer }.Concat(statisticsLabels))
+                d.FadeOut();
+
+            Alpha = 0;
+
+            content.MoveToY(75);
+            avatar.MoveToX(75);
+            nameLabel.MoveToX(150);
+
+            this.FadeIn(200);
+            content.MoveToY(0, 800, Easing.OutQuint);
+
+            using (BeginDelayedSequence(100))
+            {
+                avatar.FadeIn(300, Easing.OutQuint);
+                nameLabel.FadeIn(350, Easing.OutQuint);
+
+                avatar.MoveToX(0, 300, Easing.OutQuint);
+                nameLabel.MoveToX(0, 350, Easing.OutQuint);
+
+                using (BeginDelayedSequence(250))
+                {
+                    scoreText.FadeIn(200);
+                    scoreRank.FadeIn(200);
+
+                    using (BeginDelayedSequence(50))
+                    {
+                        var drawables = new Drawable[] { flagBadgeAndDateContainer, modsContainer }.Concat(statisticsLabels).ToArray();
+                        for (int i = 0; i < drawables.Length; i++)
+                            drawables[i].FadeIn(100 + i * 50);
+                    }
+                }
+            }
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateState();
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            updateState();
+            base.OnHoverLost(e);
+        }
+
+        private void updateState()
+        {
+            var lightenedGradient = ColourInfo.GradientHorizontal(backgroundColour.Opacity(0).Lighten(0.2f), backgroundColour.Lighten(0.2f));
+
+            foreground.FadeColour(IsHovered ? foregroundColour.Lighten(0.2f) : foregroundColour, transition_duration, Easing.OutQuint);
+            background.FadeColour(IsHovered ? backgroundColour.Lighten(0.2f) : backgroundColour, transition_duration, Easing.OutQuint);
+            totalScoreBackground.FadeColour(IsHovered ? lightenedGradient : totalScoreBackgroundGradient, transition_duration, Easing.OutQuint);
+
+            if (DrawWidth < rank_label_visibility_width_cutoff && IsHovered)
+                rankLabelOverlay.FadeIn(transition_duration, Easing.OutQuint);
+            else
+                rankLabelOverlay.FadeOut(transition_duration, Easing.OutQuint);
+        }
+
+        protected override bool OnInvalidate(Invalidation invalidation, InvalidationSource source)
+        {
+            Scheduler.AddOnce(() =>
+            {
+                // when width decreases
+                // - hide rank and show rank overlay on avatar when hovered, then
+                // - compact statistics, then
+                // - hide statistics
+
+                if (DrawWidth >= rank_label_visibility_width_cutoff)
+                    rankLabel.FadeIn(transition_duration, Easing.OutQuint).MoveToX(0, transition_duration, Easing.OutQuint);
+                else
+                    rankLabel.FadeOut(transition_duration, Easing.OutQuint).MoveToX(-rankLabel.DrawWidth, transition_duration, Easing.OutQuint);
+
+                if (DrawWidth >= height + username_min_width + statistics_regular_min_width + expanded_right_content_width)
+                {
+                    statisticsContainer.FadeIn(transition_duration, Easing.OutQuint).MoveToX(0, transition_duration, Easing.OutQuint);
+                    statisticsContainer.Direction = FillDirection.Horizontal;
+                    statisticsContainer.ScaleTo(1, transition_duration, Easing.OutQuint);
+                }
+                else if (DrawWidth >= height + username_min_width + statistics_compact_min_width + expanded_right_content_width)
+                {
+                    statisticsContainer.FadeIn(transition_duration, Easing.OutQuint).MoveToX(0, transition_duration, Easing.OutQuint);
+                    statisticsContainer.Direction = FillDirection.Vertical;
+                    statisticsContainer.ScaleTo(0.8f, transition_duration, Easing.OutQuint);
+                }
+                else
+                    statisticsContainer.FadeOut(transition_duration, Easing.OutQuint).MoveToX(statisticsContainer.DrawWidth, transition_duration, Easing.OutQuint);
+            });
+
+            return base.OnInvalidate(invalidation, source);
+        }
+
+        #region Subclasses
+
+        private partial class DateLabel : DrawableDate
+        {
+            public DateLabel(DateTimeOffset date)
+                : base(date)
+            {
+                Font = OsuFont.GetFont(size: 16, weight: FontWeight.Medium, italics: true);
+            }
+
+            protected override string Format() => Date.ToShortRelativeTime(TimeSpan.FromSeconds(30));
+        }
+
+        private partial class ScoreComponentLabel : Container
+        {
+            private readonly (LocalisableString Name, LocalisableString Value) statisticInfo;
+            private readonly ScoreInfo score;
+
+            private FillFlowContainer content = null!;
+            public override bool Contains(Vector2 screenSpacePos) => content.Contains(screenSpacePos);
+
+            public ScoreComponentLabel((LocalisableString Name, LocalisableString Value) statisticInfo, ScoreInfo score)
+            {
+                this.statisticInfo = statisticInfo;
+                this.score = score;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours, OverlayColourProvider colourProvider)
+            {
+                AutoSizeAxes = Axes.Both;
+                OsuSpriteText value;
+                Child = content = new FillFlowContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        new OsuSpriteText
+                        {
+                            Colour = colourProvider.Content2,
+                            Text = statisticInfo.Name,
+                            Font = OsuFont.GetFont(size: 12, weight: FontWeight.Bold),
+                        },
+                        value = new OsuSpriteText
+                        {
+                            // We don't want the value setting the horizontal size, since it leads to wonky accuracy container length,
+                            // since the accuracy is sometimes longer than its name.
+                            BypassAutoSizeAxes = Axes.X,
+                            Text = statisticInfo.Value,
+                            Font = OsuFont.GetFont(size: 19, weight: FontWeight.Medium),
+                        }
+                    }
+                };
+
+                if (score.Combo != score.MaxCombo && statisticInfo.Name == BeatmapsetsStrings.ShowScoreboardHeadersCombo)
+                    value.Colour = colours.Lime1;
+            }
+        }
+
+        private partial class RankLabel : Container, IHasTooltip
+        {
+            public RankLabel(int? rank)
+            {
+                if (rank >= 1000)
+                    TooltipText = $"#{rank:N0}";
+
+                Child = new OsuSpriteText
+                {
+                    Shear = new Vector2(-OsuGame.SHEAR, 0),
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Font = OsuFont.GetFont(size: 20, weight: FontWeight.SemiBold, italics: true),
+                    Text = rank == null ? "-" : rank.Value.FormatRank().Insert(0, "#")
+                };
+            }
+
+            public LocalisableString TooltipText { get; }
+        }
+
+        private sealed partial class ColouredModSwitchTiny : ModSwitchTiny, IHasTooltip
+        {
+            private readonly IMod mod;
+
+            public ColouredModSwitchTiny(IMod mod)
+                : base(mod)
+            {
+                this.mod = mod;
+                Active.Value = true;
+            }
+
+            public LocalisableString TooltipText => (mod as Mod)?.IconTooltip ?? mod.Name;
+        }
+
+        private sealed partial class MoreModSwitchTiny : CompositeDrawable
+        {
+            private readonly int count;
+
+            public MoreModSwitchTiny(int count)
+            {
+                this.count = count;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                Size = new Vector2(ModSwitchTiny.WIDTH, ModSwitchTiny.DEFAULT_HEIGHT);
+
+                InternalChild = new CircularContainer
+                {
+                    Masking = true,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = OsuColour.Gray(0.2f),
+                        },
+                        new OsuSpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Shadow = false,
+                            Font = OsuFont.Numeric.With(size: 24, weight: FontWeight.Black),
+                            Text = $"+{count}",
+                            Colour = colours.Yellow,
+                            Margin = new MarginPadding
+                            {
+                                Top = 4
+                            }
+                        }
+                    }
+                };
+            }
+        }
+
+        #endregion
+
+        public MenuItem[] ContextMenuItems
+        {
+            get
+            {
+                List<MenuItem> items = new List<MenuItem>();
+
+                if (score.Mods.Length > 0 && songSelect != null)
+                    items.Add(new OsuMenuItem("Use these mods", MenuItemType.Highlighted, () => songSelect.Mods.Value = score.Mods));
+
+                if (score.Files.Count <= 0) return items.ToArray();
+
+                items.Add(new OsuMenuItem(Localisation.CommonStrings.Export, MenuItemType.Standard, () => scoreManager.Export(score)));
+                items.Add(new OsuMenuItem(CommonStrings.ButtonsDelete, MenuItemType.Destructive, () => dialogOverlay?.Push(new LocalScoreDeleteDialog(score))));
+
+                return items.ToArray();
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/SelectV2/SongSelectV2.cs b/osu.Game/Screens/SelectV2/SongSelectV2.cs
new file mode 100644
index 0000000000..10ed7783c4
--- /dev/null
+++ b/osu.Game/Screens/SelectV2/SongSelectV2.cs
@@ -0,0 +1,145 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Screens;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
+using osu.Game.Screens.Footer;
+using osu.Game.Screens.Menu;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.SelectV2.Footer;
+
+namespace osu.Game.Screens.SelectV2
+{
+    /// <summary>
+    /// This screen is intended to house all components introduced in the new song select design to add transitions and examine the overall look.
+    /// This will be gradually built upon and ultimately replace <see cref="Select.SongSelect"/> once everything is in place.
+    /// </summary>
+    public partial class SongSelectV2 : OsuScreen
+    {
+        private readonly ModSelectOverlay modSelectOverlay = new SoloModSelectOverlay();
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
+        public override bool ShowFooter => true;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddRangeInternal(new Drawable[]
+            {
+                new PopoverContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                modSelectOverlay,
+            });
+        }
+
+        public override IReadOnlyList<ScreenFooterButton> CreateFooterButtons() => new ScreenFooterButton[]
+        {
+            new ScreenFooterButtonMods(modSelectOverlay) { Current = Mods },
+            new ScreenFooterButtonRandom(),
+            new ScreenFooterButtonOptions(),
+        };
+
+        public override void OnEntering(ScreenTransitionEvent e)
+        {
+            this.FadeIn();
+            base.OnEntering(e);
+        }
+
+        public override void OnResuming(ScreenTransitionEvent e)
+        {
+            this.FadeIn();
+            base.OnResuming(e);
+        }
+
+        public override void OnSuspending(ScreenTransitionEvent e)
+        {
+            this.Delay(400).FadeOut();
+            base.OnSuspending(e);
+        }
+
+        public override bool OnExiting(ScreenExitEvent e)
+        {
+            this.Delay(400).FadeOut();
+            return base.OnExiting(e);
+        }
+
+        public override bool OnBackButton()
+        {
+            if (modSelectOverlay.State.Value == Visibility.Visible)
+            {
+                modSelectOverlay.Hide();
+                return true;
+            }
+
+            return false;
+        }
+
+        protected override void LogoArriving(OsuLogo logo, bool resuming)
+        {
+            base.LogoArriving(logo, resuming);
+
+            if (logo.Alpha > 0.8f)
+                Footer?.StartTrackingLogo(logo, 400, Easing.OutQuint);
+            else
+            {
+                logo.Hide();
+                logo.ScaleTo(0.2f);
+                Footer?.StartTrackingLogo(logo);
+            }
+
+            logo.FadeIn(240, Easing.OutQuint);
+            logo.ScaleTo(0.4f, 240, Easing.OutQuint);
+
+            logo.Action = () =>
+            {
+                this.Push(new PlayerLoaderV2(() => new SoloPlayer()));
+                return false;
+            };
+        }
+
+        protected override void LogoSuspending(OsuLogo logo)
+        {
+            base.LogoSuspending(logo);
+            Footer?.StopTrackingLogo();
+        }
+
+        protected override void LogoExiting(OsuLogo logo)
+        {
+            base.LogoExiting(logo);
+            Scheduler.AddDelayed(() => Footer?.StopTrackingLogo(), 120);
+            logo.ScaleTo(0.2f, 120, Easing.Out);
+            logo.FadeOut(120, Easing.Out);
+        }
+
+        private partial class SoloModSelectOverlay : ModSelectOverlay
+        {
+            protected override bool ShowPresets => true;
+
+            public SoloModSelectOverlay()
+                : base(OverlayColourScheme.Aquamarine)
+            {
+            }
+        }
+
+        private partial class PlayerLoaderV2 : PlayerLoader
+        {
+            public override bool ShowFooter => true;
+
+            public PlayerLoaderV2(Func<Player> createPlayer)
+                : base(createPlayer)
+            {
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Utility/SampleComponents/LatencySampleComponent.cs b/osu.Game/Screens/Utility/SampleComponents/LatencySampleComponent.cs
index 690376cf52..922935f520 100644
--- a/osu.Game/Screens/Utility/SampleComponents/LatencySampleComponent.cs
+++ b/osu.Game/Screens/Utility/SampleComponents/LatencySampleComponent.cs
@@ -38,7 +38,7 @@ namespace osu.Game.Screens.Utility.SampleComponents
         {
             base.LoadComplete();
 
-            inputManager = GetContainingInputManager();
+            inputManager = GetContainingInputManager()!;
             IsActive.BindTo(latencyArea.IsActiveArea);
         }
 
diff --git a/osu.Game/Skinning/LegacyRankDisplay.cs b/osu.Game/Skinning/LegacyRankDisplay.cs
new file mode 100644
index 0000000000..70b5ed0278
--- /dev/null
+++ b/osu.Game/Skinning/LegacyRankDisplay.cs
@@ -0,0 +1,63 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Scoring;
+using osuTK;
+
+namespace osu.Game.Skinning
+{
+    public partial class LegacyRankDisplay : CompositeDrawable, ISerialisableDrawable
+    {
+        public bool UsesFixedAnchor { get; set; }
+
+        [Resolved]
+        private ScoreProcessor scoreProcessor { get; set; } = null!;
+
+        [Resolved]
+        private ISkinSource source { get; set; } = null!;
+
+        private readonly Sprite rank;
+
+        public LegacyRankDisplay()
+        {
+            AutoSizeAxes = Axes.Both;
+
+            AddInternal(rank = new Sprite
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+        }
+
+        protected override void LoadComplete()
+        {
+            scoreProcessor.Rank.BindValueChanged(v =>
+            {
+                var texture = source.GetTexture($"ranking-{v.NewValue}-small");
+
+                rank.Texture = texture;
+
+                if (texture != null)
+                {
+                    var transientRank = new Sprite
+                    {
+                        Texture = texture,
+                        Blending = BlendingParameters.Additive,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        BypassAutoSizeAxes = Axes.Both,
+                    };
+                    AddInternal(transientRank);
+                    transientRank.FadeOutFromOne(500, Easing.Out)
+                                 .ScaleTo(new Vector2(1.625f), 500, Easing.Out)
+                                 .Expire();
+                }
+            }, true);
+            FinishTransforms(true);
+        }
+    }
+}
diff --git a/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs b/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs
index fc5ef12fb8..8e7b3feacf 100644
--- a/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs
+++ b/osu.Game/Storyboards/Drawables/DrawableStoryboard.cs
@@ -37,20 +37,6 @@ namespace osu.Game.Storyboards.Drawables
 
         protected override Vector2 DrawScale => new Vector2(Parent!.DrawHeight / 480);
 
-        private bool passing = true;
-
-        public bool Passing
-        {
-            get => passing;
-            set
-            {
-                if (passing == value) return;
-
-                passing = value;
-                updateLayerVisibility();
-            }
-        }
-
         public override bool RemoveCompletedTransforms => false;
 
         private double? lastEventEndTime;
@@ -66,6 +52,9 @@ namespace osu.Game.Storyboards.Drawables
 
         private DependencyContainer dependencies = null!;
 
+        private BindableNumber<double> health = null!;
+        private readonly BindableBool passing = new BindableBool(true);
+
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
             dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
@@ -91,8 +80,8 @@ namespace osu.Game.Storyboards.Drawables
             });
         }
 
-        [BackgroundDependencyLoader(true)]
-        private void load(IGameplayClock? clock, CancellationToken? cancellationToken)
+        [BackgroundDependencyLoader]
+        private void load(IGameplayClock? clock, CancellationToken? cancellationToken, GameplayState? gameplayState)
         {
             if (clock != null)
                 Clock = clock;
@@ -110,6 +99,16 @@ namespace osu.Game.Storyboards.Drawables
             }
 
             lastEventEndTime = Storyboard.LatestEventTime;
+
+            health = gameplayState?.HealthProcessor.Health.GetBoundCopy() ?? new BindableDouble(1);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            health.BindValueChanged(val => passing.Value = val.NewValue >= 0.5, true);
+            passing.BindValueChanged(_ => updateLayerVisibility(), true);
         }
 
         protected virtual IResourceStore<byte[]> CreateResourceLookupStore() => new StoryboardResourceLookupStore(Storyboard, realm, host);
@@ -125,7 +124,7 @@ namespace osu.Game.Storyboards.Drawables
         private void updateLayerVisibility()
         {
             foreach (var layer in Children)
-                layer.Enabled = passing ? layer.Layer.VisibleWhenPassing : layer.Layer.VisibleWhenFailing;
+                layer.Enabled = passing.Value ? layer.Layer.VisibleWhenPassing : layer.Layer.VisibleWhenFailing;
         }
 
         private class StoryboardResourceLookupStore : IResourceStore<byte[]>
diff --git a/osu.Game/Tests/Beatmaps/TestBeatmap.cs b/osu.Game/Tests/Beatmaps/TestBeatmap.cs
index de7bcfcfaa..31ad2de62e 100644
--- a/osu.Game/Tests/Beatmaps/TestBeatmap.cs
+++ b/osu.Game/Tests/Beatmaps/TestBeatmap.cs
@@ -26,11 +26,13 @@ namespace osu.Game.Tests.Beatmaps
 
             BeatmapInfo = baseBeatmap.BeatmapInfo;
             ControlPointInfo = baseBeatmap.ControlPointInfo;
-            Breaks = baseBeatmap.Breaks;
             UnhandledEventLines = baseBeatmap.UnhandledEventLines;
 
             if (withHitObjects)
+            {
                 HitObjects = baseBeatmap.HitObjects;
+                Breaks = baseBeatmap.Breaks;
+            }
 
             BeatmapInfo.Ruleset = ruleset;
             BeatmapInfo.Length = 75000;
diff --git a/osu.Game/Tests/Gameplay/TestGameplayState.cs b/osu.Game/Tests/Gameplay/TestGameplayState.cs
index bb82335543..8fad6d1e23 100644
--- a/osu.Game/Tests/Gameplay/TestGameplayState.cs
+++ b/osu.Game/Tests/Gameplay/TestGameplayState.cs
@@ -27,7 +27,9 @@ namespace osu.Game.Tests.Gameplay
             var scoreProcessor = ruleset.CreateScoreProcessor();
             scoreProcessor.ApplyBeatmap(playableBeatmap);
 
-            return new GameplayState(playableBeatmap, ruleset, mods, score, scoreProcessor);
+            var healthProcessor = ruleset.CreateHealthProcessor(beatmap.HitObjects[0].StartTime);
+
+            return new GameplayState(playableBeatmap, ruleset, mods, score, scoreProcessor, healthProcessor);
         }
     }
 }
diff --git a/osu.Game/Tests/Visual/Metadata/TestMetadataClient.cs b/osu.Game/Tests/Visual/Metadata/TestMetadataClient.cs
index b589e66d8b..fa64a83352 100644
--- a/osu.Game/Tests/Visual/Metadata/TestMetadataClient.cs
+++ b/osu.Game/Tests/Visual/Metadata/TestMetadataClient.cs
@@ -86,5 +86,10 @@ namespace osu.Game.Tests.Visual.Metadata
             dailyChallengeInfo.Value = info;
             return Task.CompletedTask;
         }
+
+        public override Task<MultiplayerPlaylistItemStats[]> BeginWatchingMultiplayerRoom(long id)
+            => Task.FromResult(new MultiplayerPlaylistItemStats[MultiplayerPlaylistItemStats.TOTAL_SCORE_DISTRIBUTION_BINS]);
+
+        public override Task EndWatchingMultiplayerRoom(long id) => Task.CompletedTask;
     }
 }
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index 5ddffbef12..3738d8a7a1 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -26,9 +26,7 @@ namespace osu.Game.Utils
             point.X -= origin.X;
             point.Y -= origin.Y;
 
-            Vector2 ret;
-            ret.X = point.X * MathF.Cos(float.DegreesToRadians(angle)) + point.Y * MathF.Sin(float.DegreesToRadians(angle));
-            ret.Y = point.X * -MathF.Sin(float.DegreesToRadians(angle)) + point.Y * MathF.Cos(float.DegreesToRadians(angle));
+            Vector2 ret = RotateVector(point, angle);
 
             ret.X += origin.X;
             ret.Y += origin.Y;
@@ -36,6 +34,19 @@ namespace osu.Game.Utils
             return ret;
         }
 
+        /// <summary>
+        /// Rotate a vector around the origin.
+        /// </summary>
+        /// <param name="vector">The vector.</param>
+        /// <param name="angle">The angle to rotate (in degrees).</param>
+        public static Vector2 RotateVector(Vector2 vector, float angle)
+        {
+            return new Vector2(
+                vector.X * MathF.Cos(float.DegreesToRadians(angle)) + vector.Y * MathF.Sin(float.DegreesToRadians(angle)),
+                vector.X * -MathF.Sin(float.DegreesToRadians(angle)) + vector.Y * MathF.Cos(float.DegreesToRadians(angle))
+            );
+        }
+
         /// <summary>
         /// Given a flip direction, a surrounding quad for all selected objects, and a position,
         /// will return the flipped position in screen space coordinates.
diff --git a/osu.Game/Utils/ModUtils.cs b/osu.Game/Utils/ModUtils.cs
index 2c9eef41e3..f901f15388 100644
--- a/osu.Game/Utils/ModUtils.cs
+++ b/osu.Game/Utils/ModUtils.cs
@@ -276,5 +276,20 @@ namespace osu.Game.Utils
 
             return scoreMultiplier.ToLocalisableString("0.00x");
         }
+
+        /// <summary>
+        /// Calculate the rate for the song with the selected mods.
+        /// </summary>
+        /// <param name="mods">The list of selected mods.</param>
+        /// <returns>The rate with mods.</returns>
+        public static double CalculateRateWithMods(IEnumerable<Mod> mods)
+        {
+            double rate = 1;
+
+            foreach (var mod in mods.OfType<IApplicableToRate>())
+                rate = mod.ApplyToRate(0, rate);
+
+            return rate;
+        }
     }
 }
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index c5b9bfaf12..ca21dff894 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -35,8 +35,8 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="11.5.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2024.528.1" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2024.517.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2024.627.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2024.622.0" />
     <PackageReference Include="Sentry" Version="4.3.0" />
     <!-- Held back due to 0.34.0 failing AOT compilation on ZstdSharp.dll dependency. -->
     <PackageReference Include="SharpCompress" Version="0.36.0" />
diff --git a/osu.iOS.props b/osu.iOS.props
index 2f64fcefa5..8e8bac53b9 100644
--- a/osu.iOS.props
+++ b/osu.iOS.props
@@ -23,6 +23,6 @@
     <RuntimeIdentifier>iossimulator-x64</RuntimeIdentifier>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2024.528.1" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2024.627.0" />
   </ItemGroup>
 </Project>
diff --git a/osu.sln.DotSettings b/osu.sln.DotSettings
index 08eb264aab..25bbc4beb5 100644
--- a/osu.sln.DotSettings
+++ b/osu.sln.DotSettings
@@ -82,7 +82,7 @@
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertToConstant_002ELocal/@EntryIndexedValue">WARNING</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertToLambdaExpression/@EntryIndexedValue">WARNING</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertToLocalFunction/@EntryIndexedValue">HINT</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertToPrimaryConstructor/@EntryIndexedValue">HINT</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertToPrimaryConstructor/@EntryIndexedValue">DO_NOT_SHOW</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertToStaticClass/@EntryIndexedValue">WARNING</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertToUsingDeclaration/@EntryIndexedValue">HINT</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertTypeCheckPatternToNullCheck/@EntryIndexedValue">DO_NOT_SHOW</s:String>
@@ -254,7 +254,7 @@
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=UnusedType_002EGlobal/@EntryIndexedValue">HINT</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=UseAwaitUsing/@EntryIndexedValue">DO_NOT_SHOW</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=UseCollectionCountProperty/@EntryIndexedValue">WARNING</s:String>
-	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=UseCollectionExpression/@EntryIndexedValue">HINT</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=UseCollectionExpression/@EntryIndexedValue">DO_NOT_SHOW</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=UseConfigureAwaitFalseForAsyncDisposable/@EntryIndexedValue">WARNING</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=UseFormatSpecifierInFormatString/@EntryIndexedValue">WARNING</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=UseFormatSpecifierInInterpolation/@EntryIndexedValue">WARNING</s:String>