diff --git a/osu.Android.props b/osu.Android.props
index 2d15bce85a..2bfdce5ab8 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="2023.823.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2023.904.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.
diff --git a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
index 2426f8c886..d010bb02ad 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamPlacementBlueprint.cs
@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             AddAssert("end time is correct", () => Precision.AlmostEquals(lastObject.EndTime, times[1]));
             AddAssert("start position is correct", () => Precision.AlmostEquals(lastObject.OriginalX, positions[0]));
             AddAssert("end position is correct", () => Precision.AlmostEquals(lastObject.EndX, positions[1]));
-            AddAssert("default slider velocity", () => lastObject.SliderVelocityBindable.IsDefault);
+            AddAssert("default slider velocity", () => lastObject.SliderVelocityMultiplierBindable.IsDefault);
         }
 
         [Test]
@@ -76,7 +76,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             addPlacementSteps(times, positions);
             addPathCheckStep(times, positions);
 
-            AddAssert("slider velocity changed", () => !lastObject.SliderVelocityBindable.IsDefault);
+            AddAssert("slider velocity changed", () => !lastObject.SliderVelocityMultiplierBindable.IsDefault);
         }
 
         [Test]
diff --git a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamSelectionBlueprint.cs b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamSelectionBlueprint.cs
index beba5811fe..05d7a38a95 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamSelectionBlueprint.cs
@@ -108,11 +108,11 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
             double[] times = { 100, 300 };
             float[] positions = { 200, 300 };
             addBlueprintStep(times, positions);
-            AddAssert("default slider velocity", () => hitObject.SliderVelocityBindable.IsDefault);
+            AddAssert("default slider velocity", () => hitObject.SliderVelocityMultiplierBindable.IsDefault);
 
             addDragStartStep(times[1], positions[1]);
             AddMouseMoveStep(times[1], 400);
-            AddAssert("slider velocity changed", () => !hitObject.SliderVelocityBindable.IsDefault);
+            AddAssert("slider velocity changed", () => !hitObject.SliderVelocityMultiplierBindable.IsDefault);
         }
 
         [Test]
diff --git a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs
index 2c8ef9eae0..5e8a0b1216 100644
--- a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs
@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         ComboOffset = comboData?.ComboOffset ?? 0,
                         LegacyLastTickOffset = (obj as IHasLegacyLastTickOffset)?.LegacyLastTickOffset ?? 0,
                         LegacyConvertedY = yPositionData?.Y ?? CatchHitObject.DEFAULT_LEGACY_CONVERT_Y,
-                        SliderVelocity = sliderVelocityData?.SliderVelocity ?? 1
+                        SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1
                     }.Yield();
 
                 case IHasDuration endTime:
diff --git a/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/EditablePath.cs b/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/EditablePath.cs
index 7a577f8a83..df76bf0a8c 100644
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/EditablePath.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/EditablePath.cs
@@ -91,7 +91,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
         public void UpdateHitObjectFromPath(JuiceStream hitObject)
         {
             // The SV setting may need to be changed for the current path.
-            var svBindable = hitObject.SliderVelocityBindable;
+            var svBindable = hitObject.SliderVelocityMultiplierBindable;
             double svToVelocityFactor = hitObject.Velocity / svBindable.Value;
             double requiredVelocity = path.ComputeRequiredVelocity();
 
diff --git a/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs b/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs
index 169e99c90c..724bdc3401 100644
--- a/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs
+++ b/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs
@@ -28,17 +28,17 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int RepeatCount { get; set; }
 
-        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1)
+        public BindableNumber<double> SliderVelocityMultiplierBindable { get; } = new BindableDouble(1)
         {
             Precision = 0.01,
             MinValue = 0.1,
             MaxValue = 10
         };
 
-        public double SliderVelocity
+        public double SliderVelocityMultiplier
         {
-            get => SliderVelocityBindable.Value;
-            set => SliderVelocityBindable.Value = value;
+            get => SliderVelocityMultiplierBindable.Value;
+            set => SliderVelocityMultiplierBindable.Value = value;
         }
 
         [JsonIgnore]
@@ -48,10 +48,10 @@ namespace osu.Game.Rulesets.Catch.Objects
         private double tickDistanceFactor;
 
         [JsonIgnore]
-        public double Velocity => velocityFactor * SliderVelocity;
+        public double Velocity => velocityFactor * SliderVelocityMultiplier;
 
         [JsonIgnore]
-        public double TickDistance => tickDistanceFactor * SliderVelocity;
+        public double TickDistance => tickDistanceFactor * SliderVelocityMultiplier;
 
         /// <summary>
         /// The length of one span of this <see cref="JuiceStream"/>.
diff --git a/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModDoubleTime.cs b/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModDoubleTime.cs
new file mode 100644
index 0000000000..00b79529a9
--- /dev/null
+++ b/osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModDoubleTime.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 System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests.Mods
+{
+    public partial class TestSceneManiaModDoubleTime : ModTestScene
+    {
+        private const double offset = 18;
+
+        protected override Ruleset CreatePlayerRuleset() => new ManiaRuleset();
+
+        [Test]
+        public void TestHitWindowWithoutDoubleTime() => CreateModTest(new ModTestData
+        {
+            PassCondition = () => Player.ScoreProcessor.JudgedHits > 0 && Player.ScoreProcessor.Accuracy.Value != 1,
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
+                Difficulty = { OverallDifficulty = 10 },
+                HitObjects = new List<HitObject>
+                {
+                    new Note { StartTime = 1000 }
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1000 + offset, ManiaAction.Key1)
+            }
+        });
+
+        [Test]
+        public void TestHitWindowWithDoubleTime() => CreateModTest(new ModTestData
+        {
+            Mod = new ManiaModDoubleTime(),
+            PassCondition = () => Player.ScoreProcessor.JudgedHits > 0 && Player.ScoreProcessor.Accuracy.Value == 1,
+            Autoplay = false,
+            Beatmap = new Beatmap
+            {
+                BeatmapInfo = { Ruleset = new ManiaRuleset().RulesetInfo },
+                Difficulty = { OverallDifficulty = 10 },
+                HitObjects = new List<HitObject>
+                {
+                    new Note { StartTime = 1000 }
+                },
+            },
+            ReplayFrames = new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(1000 + offset, ManiaAction.Key1)
+            }
+        });
+    }
+}
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs
index 91b7be6e8f..49c1a055a6 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs
@@ -53,7 +53,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             if (hitObject.LegacyBpmMultiplier.HasValue)
                 beatLength = timingPoint.BeatLength * hitObject.LegacyBpmMultiplier.Value;
             else if (hitObject is IHasSliderVelocity hasSliderVelocity)
-                beatLength = timingPoint.BeatLength / hasSliderVelocity.SliderVelocity;
+                beatLength = timingPoint.BeatLength / hasSliderVelocity.SliderVelocityMultiplier;
             else
                 beatLength = timingPoint.BeatLength;
 
diff --git a/osu.Game.Rulesets.Mania/Mods/IManiaRateAdjustmentMod.cs b/osu.Game.Rulesets.Mania/Mods/IManiaRateAdjustmentMod.cs
new file mode 100644
index 0000000000..ea01bd4436
--- /dev/null
+++ b/osu.Game.Rulesets.Mania/Mods/IManiaRateAdjustmentMod.cs
@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Mania.Mods
+{
+    /// <summary>
+    /// May be attached to rate-adjustment mods to adjust hit windows adjust relative to gameplay rate.
+    /// </summary>
+    /// <remarks>
+    /// Historically, in osu!mania, hit windows are expected to adjust relative to the gameplay rate such that the real-world hit window remains the same.
+    /// </remarks>
+    public interface IManiaRateAdjustmentMod : IApplicableToDifficulty, IApplicableToHitObject
+    {
+        BindableNumber<double> SpeedChange { get; }
+
+        HitWindows HitWindows { get; set; }
+
+        void IApplicableToDifficulty.ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            HitWindows = new ManiaHitWindows(SpeedChange.Value);
+            HitWindows.SetDifficulty(difficulty.OverallDifficulty);
+        }
+
+        void IApplicableToHitObject.ApplyToHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Note:
+                    hitObject.HitWindows = HitWindows;
+                    break;
+
+                case HoldNote hold:
+                    hold.Head.HitWindows = HitWindows;
+                    hold.Tail.HitWindows = HitWindows;
+                    break;
+            }
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModDaycore.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModDaycore.cs
index 309393b664..dbe2a9a9fc 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModDaycore.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModDaycore.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 osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModDaycore : ModDaycore
+    public class ManiaModDaycore : ModDaycore, IManiaRateAdjustmentMod
     {
+        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModDoubleTime.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModDoubleTime.cs
index f4b9cf3b88..a841a8ab37 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModDoubleTime.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModDoubleTime.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 osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModDoubleTime : ModDoubleTime
+    public class ManiaModDoubleTime : ModDoubleTime, IManiaRateAdjustmentMod
     {
+        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModHalfTime.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModHalfTime.cs
index 8d48e3acde..b0fbb11396 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModHalfTime.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModHalfTime.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 osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModHalfTime : ModHalfTime
+    public class ManiaModHalfTime : ModHalfTime, IManiaRateAdjustmentMod
     {
+        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Mods/ManiaModNightcore.cs b/osu.Game.Rulesets.Mania/Mods/ManiaModNightcore.cs
index 748725af9f..f64f7ae31a 100644
--- a/osu.Game.Rulesets.Mania/Mods/ManiaModNightcore.cs
+++ b/osu.Game.Rulesets.Mania/Mods/ManiaModNightcore.cs
@@ -2,11 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModNightcore : ModNightcore<ManiaHitObject>
+    public class ManiaModNightcore : ModNightcore<ManiaHitObject>, IManiaRateAdjustmentMod
     {
+        public HitWindows HitWindows { get; set; } = new ManiaHitWindows();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs b/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
index 289f8a00ef..627f48f391 100644
--- a/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
+++ b/osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs
@@ -1,12 +1,25 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Scoring
 {
     public class ManiaHitWindows : HitWindows
     {
+        private readonly double multiplier;
+
+        public ManiaHitWindows()
+            : this(1)
+        {
+        }
+
+        public ManiaHitWindows(double multiplier)
+        {
+            this.multiplier = multiplier;
+        }
+
         public override bool IsHitResultAllowed(HitResult result)
         {
             switch (result)
@@ -22,5 +35,12 @@ namespace osu.Game.Rulesets.Mania.Scoring
 
             return false;
         }
+
+        protected override DifficultyRange[] GetRanges() => base.GetRanges().Select(r =>
+            new DifficultyRange(
+                r.Result,
+                r.Min * multiplier,
+                r.Average * multiplier,
+                r.Max * multiplier)).ToArray();
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Skinning/ManiaSkinConfigurationLookup.cs b/osu.Game.Rulesets.Mania/Skinning/ManiaSkinConfigurationLookup.cs
index 6c39ffdcc3..aa50aeb130 100644
--- a/osu.Game.Rulesets.Mania/Skinning/ManiaSkinConfigurationLookup.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/ManiaSkinConfigurationLookup.cs
@@ -30,5 +30,7 @@ namespace osu.Game.Rulesets.Mania.Skinning
             Lookup = lookup;
             ColumnIndex = columnIndex;
         }
+
+        public override string ToString() => $"[{nameof(ManiaSkinConfigurationLookup)} lookup:{Lookup} col:{ColumnIndex}]";
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAutoplay.cs b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAutoplay.cs
index 32028823ae..6980438b59 100644
--- a/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAutoplay.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModAutoplay.cs
@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                                 new PathControlPoint(new Vector2(0, 6.25f))
                             }),
                             RepeatCount = 1,
-                            SliderVelocity = 10
+                            SliderVelocityMultiplier = 10
                         }
                     }
                 },
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircle.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircle.cs
index 0314afc1ac..af02087d1a 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircle.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircle.cs
@@ -131,7 +131,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             protected override void CheckForResult(bool userTriggered, double timeOffset)
             {
-                if (auto && !userTriggered && timeOffset > hitOffset && CheckHittable?.Invoke(this, Time.Current) != false)
+                if (auto && !userTriggered && timeOffset > hitOffset && CheckHittable?.Invoke(this, Time.Current, HitResult.Great) == ClickAction.Hit)
                 {
                     // force success
                     ApplyResult(r => r.Type = HitResult.Great);
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircleLateFade.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircleLateFade.cs
index 3c32b4fa65..483155e646 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircleLateFade.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneHitCircleLateFade.cs
@@ -13,6 +13,7 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Tests.Visual;
 using osuTK;
 
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private float? alphaAtMiss;
 
         [Test]
-        public void TestHitCircleClassicMod()
+        public void TestHitCircleClassicModMiss()
         {
             AddStep("Create hit circle", () =>
             {
@@ -61,8 +62,27 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("Transparent when missed", () => alphaAtMiss == 0);
         }
 
+        /// <summary>
+        /// No early fade is expected to be applied if the hit circle has been hit.
+        /// </summary>
         [Test]
-        public void TestHitCircleNoMod()
+        public void TestHitCircleClassicModHit()
+        {
+            TestDrawableHitCircle circle = null!;
+
+            AddStep("Create hit circle", () =>
+            {
+                SelectedMods.Value = new Mod[] { new OsuModClassic() };
+                circle = createCircle(true);
+            });
+
+            AddUntilStep("Wait until circle is hit", () => circle.Result?.Type == HitResult.Great);
+            AddUntilStep("Wait for miss window", () => Clock.CurrentTime, () => Is.GreaterThanOrEqualTo(circle.HitObject.StartTime + circle.HitObject.HitWindows.WindowFor(HitResult.Miss)));
+            AddAssert("Check circle is still visible", () => circle.Alpha, () => Is.GreaterThan(0));
+        }
+
+        [Test]
+        public void TestHitCircleNoModMiss()
         {
             AddStep("Create hit circle", () =>
             {
@@ -74,6 +94,16 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("Opaque when missed", () => alphaAtMiss == 1);
         }
 
+        [Test]
+        public void TestHitCircleNoModHit()
+        {
+            AddStep("Create hit circle", () =>
+            {
+                SelectedMods.Value = Array.Empty<Mod>();
+                createCircle(true);
+            });
+        }
+
         [Test]
         public void TestSliderClassicMod()
         {
@@ -100,27 +130,33 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("Head circle opaque when missed", () => alphaAtMiss == 1);
         }
 
-        private void createCircle()
+        private TestDrawableHitCircle createCircle(bool shouldHit = false)
         {
             alphaAtMiss = null;
 
-            DrawableHitCircle drawableHitCircle = new DrawableHitCircle(new HitCircle
+            TestDrawableHitCircle drawableHitCircle = new TestDrawableHitCircle(new HitCircle
             {
                 StartTime = Time.Current + 500,
-                Position = new Vector2(250)
-            });
+                Position = new Vector2(250),
+            }, shouldHit);
 
+            drawableHitCircle.Scale = new Vector2(2f);
+
+            LoadComponent(drawableHitCircle);
             foreach (var mod in SelectedMods.Value.OfType<IApplicableToDrawableHitObject>())
                 mod.ApplyToDrawableHitObject(drawableHitCircle);
 
             drawableHitCircle.HitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
-            drawableHitCircle.OnNewResult += (_, _) =>
+            drawableHitCircle.OnNewResult += (_, result) =>
             {
-                alphaAtMiss = drawableHitCircle.Alpha;
+                if (!result.IsHit)
+                    alphaAtMiss = drawableHitCircle.Alpha;
             };
 
             Child = drawableHitCircle;
+
+            return drawableHitCircle;
         }
 
         private void createSlider()
@@ -138,6 +174,8 @@ namespace osu.Game.Rulesets.Osu.Tests
                 })
             });
 
+            drawableSlider.Scale = new Vector2(2f);
+
             drawableSlider.HitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
             drawableSlider.OnLoadComplete += _ =>
@@ -145,12 +183,36 @@ namespace osu.Game.Rulesets.Osu.Tests
                 foreach (var mod in SelectedMods.Value.OfType<IApplicableToDrawableHitObject>())
                     mod.ApplyToDrawableHitObject(drawableSlider.HeadCircle);
 
-                drawableSlider.HeadCircle.OnNewResult += (_, _) =>
+                drawableSlider.HeadCircle.OnNewResult += (_, result) =>
                 {
-                    alphaAtMiss = drawableSlider.HeadCircle.Alpha;
+                    if (!result.IsHit)
+                        alphaAtMiss = drawableSlider.HeadCircle.Alpha;
                 };
             };
+
             Child = drawableSlider;
         }
+
+        protected partial class TestDrawableHitCircle : DrawableHitCircle
+        {
+            private readonly bool shouldHit;
+
+            public TestDrawableHitCircle(HitCircle h, bool shouldHit)
+                : base(h)
+            {
+                this.shouldHit = shouldHit;
+            }
+
+            protected override void CheckForResult(bool userTriggered, double timeOffset)
+            {
+                if (shouldHit && !userTriggered && timeOffset >= 0)
+                {
+                    // force success
+                    ApplyResult(r => r.Type = HitResult.Great);
+                }
+                else
+                    base.CheckForResult(userTriggered, timeOffset);
+            }
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneObjectOrderedHitPolicy.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyHitPolicy.cs
similarity index 65%
rename from osu.Game.Rulesets.Osu.Tests/TestSceneObjectOrderedHitPolicy.cs
rename to osu.Game.Rulesets.Osu.Tests/TestSceneLegacyHitPolicy.cs
index f52c23d7e2..8c311cce91 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneObjectOrderedHitPolicy.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyHitPolicy.cs
@@ -11,17 +11,21 @@ using NUnit.Framework;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Screens;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
@@ -32,7 +36,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public partial class TestSceneObjectOrderedHitPolicy : RateAdjustedBeatmapTestScene
+    public partial class TestSceneLegacyHitPolicy : RateAdjustedBeatmapTestScene
     {
         private readonly OsuHitWindows referenceHitWindows;
 
@@ -43,7 +47,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         /// </summary>
         private readonly string? exportLocation = null;
 
-        public TestSceneObjectOrderedHitPolicy()
+        public TestSceneLegacyHitPolicy()
         {
             referenceHitWindows = new OsuHitWindows();
             referenceHitWindows.SetDifficulty(0);
@@ -83,6 +87,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementAssert(hitObjects[1], HitResult.Miss);
             // note lock prevented the object from being hit, so the judgement offset should be very late.
             addJudgementOffsetAssert(hitObjects[0], referenceHitWindows.WindowFor(HitResult.Meh));
+            addClickActionAssert(0, ClickAction.Shake);
         }
 
         /// <summary>
@@ -119,6 +124,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementAssert(hitObjects[1], HitResult.Miss);
             // note lock prevented the object from being hit, so the judgement offset should be very late.
             addJudgementOffsetAssert(hitObjects[0], referenceHitWindows.WindowFor(HitResult.Meh));
+            addClickActionAssert(0, ClickAction.Shake);
         }
 
         /// <summary>
@@ -155,6 +161,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementAssert(hitObjects[1], HitResult.Miss);
             // note lock prevented the object from being hit, so the judgement offset should be very late.
             addJudgementOffsetAssert(hitObjects[0], referenceHitWindows.WindowFor(HitResult.Meh));
+            addClickActionAssert(0, ClickAction.Shake);
         }
 
         /// <summary>
@@ -191,7 +198,9 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementAssert(hitObjects[0], HitResult.Meh);
             addJudgementAssert(hitObjects[1], HitResult.Meh);
             addJudgementOffsetAssert(hitObjects[0], -190); // time_first_circle - 190
-            addJudgementOffsetAssert(hitObjects[0], -90); // time_second_circle - first_circle_time - 90
+            addJudgementOffsetAssert(hitObjects[1], -190); // time_second_circle - first_circle_time - 90
+            addClickActionAssert(0, ClickAction.Hit);
+            addClickActionAssert(1, ClickAction.Hit);
         }
 
         /// <summary>
@@ -229,13 +238,15 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementAssert(hitObjects[1], HitResult.Ok);
             addJudgementOffsetAssert(hitObjects[0], -190); // time_first_circle - 190
             addJudgementOffsetAssert(hitObjects[1], -100); // time_second_circle - first_circle_time
+            addClickActionAssert(0, ClickAction.Hit);
+            addClickActionAssert(1, ClickAction.Hit);
         }
 
         /// <summary>
-        /// Tests clicking a future circle after a slider's start time, but hitting all slider ticks.
+        /// Tests clicking a future circle after a slider's start time, but hitting the slider head and all slider ticks.
         /// </summary>
         [Test]
-        public void TestMissSliderHeadAndHitAllSliderTicks()
+        public void TestHitCircleBeforeSliderHead()
         {
             const double time_slider = 1500;
             const double time_circle = 1510;
@@ -267,10 +278,12 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Time = time_slider + 10, Position = positionSlider, Actions = { OsuAction.RightButton } }
             });
 
-            addJudgementAssert(hitObjects[0], HitResult.Miss);
+            addJudgementAssert(hitObjects[0], HitResult.Great);
             addJudgementAssert(hitObjects[1], HitResult.Great);
             addJudgementAssert("slider head", () => ((Slider)hitObjects[1]).HeadCircle, HitResult.LargeTickHit);
             addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.LargeTickHit);
+            addClickActionAssert(0, ClickAction.Hit);
+            addClickActionAssert(1, ClickAction.Hit);
         }
 
         /// <summary>
@@ -314,6 +327,8 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementAssert(hitObjects[1], HitResult.Great);
             addJudgementAssert("slider head", () => ((Slider)hitObjects[1]).HeadCircle, HitResult.LargeTickHit);
             addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.LargeTickHit);
+            addClickActionAssert(0, ClickAction.Hit);
+            addClickActionAssert(1, ClickAction.Hit);
         }
 
         /// <summary>
@@ -353,6 +368,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             addJudgementAssert(hitObjects[0], HitResult.Great);
             addJudgementAssert(hitObjects[1], HitResult.Meh);
+            addClickActionAssert(0, ClickAction.Hit);
         }
 
         [Test]
@@ -391,6 +407,199 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             addJudgementAssert(hitObjects[0], HitResult.Great);
             addJudgementAssert(hitObjects[1], HitResult.Great);
+            addClickActionAssert(0, ClickAction.Shake);
+            addClickActionAssert(1, ClickAction.Hit);
+            addClickActionAssert(2, ClickAction.Hit);
+        }
+
+        [Test]
+        public void TestOverlappingSliders()
+        {
+            const double time_first_slider = 1000;
+            const double time_second_slider = 1200;
+            Vector2 positionFirstSlider = new Vector2(100, 50);
+            Vector2 positionSecondSlider = new Vector2(100, 80);
+            var midpoint = (positionFirstSlider + positionSecondSlider) / 2;
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new Slider
+                {
+                    StartTime = time_first_slider,
+                    Position = positionFirstSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                },
+                new Slider
+                {
+                    StartTime = time_second_slider,
+                    Position = positionSecondSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_slider, Position = midpoint, Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_first_slider + 25, Position = midpoint, Actions = { OsuAction.LeftButton, OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_first_slider + 50, Position = midpoint },
+                new OsuReplayFrame { Time = time_second_slider, Position = positionSecondSlider + new Vector2(0, 10), Actions = { OsuAction.LeftButton } },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Ok);
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addClickActionAssert(0, ClickAction.Hit);
+            addClickActionAssert(1, ClickAction.Hit);
+        }
+
+        [Test]
+        public void TestStacksDoNotShake()
+        {
+            const double time_stack_start = 1000;
+            Vector2 position = new Vector2(80);
+
+            var hitObjects = Enumerable.Range(0, 20).Select(i => new HitCircle
+            {
+                StartTime = time_stack_start + i * 100,
+                Position = position
+            }).Cast<OsuHitObject>().ToList();
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_stack_start - 450, Position = new Vector2(55), Actions = { OsuAction.LeftButton } },
+            });
+
+            addClickActionAssert(0, ClickAction.Ignore);
+        }
+
+        [Test]
+        public void TestAutopilotReducesHittableRange()
+        {
+            const double time_circle = 1500;
+            Vector2 positionCircle = Vector2.Zero;
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new HitCircle
+                {
+                    StartTime = time_circle,
+                    Position = positionCircle
+                },
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_circle - 250, Position = positionCircle, Actions = { OsuAction.LeftButton } }
+            }, new Mod[] { new OsuModAutopilot() });
+
+            addJudgementAssert(hitObjects[0], HitResult.Miss);
+            // note lock prevented the object from being hit, so the judgement offset should be very late.
+            addJudgementOffsetAssert(hitObjects[0], referenceHitWindows.WindowFor(HitResult.Meh));
+            addClickActionAssert(0, ClickAction.Shake);
+        }
+
+        [Test]
+        [Ignore("Currently broken, first attempt at fixing broke even harder. See https://github.com/ppy/osu/issues/24743.")]
+        public void TestInputDoesNotFallThroughOverlappingSliders()
+        {
+            const double time_first_slider = 1000;
+            const double time_second_slider = 1250;
+            Vector2 positionFirstSlider = new Vector2(100, 50);
+            Vector2 positionSecondSlider = new Vector2(100, 80);
+            var midpoint = (positionFirstSlider + positionSecondSlider) / 2;
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new Slider
+                {
+                    StartTime = time_first_slider,
+                    Position = positionFirstSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                },
+                new Slider
+                {
+                    StartTime = time_second_slider,
+                    Position = positionSecondSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_slider, Position = midpoint, Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_first_slider + 25, Position = midpoint, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_first_slider + 50, Position = midpoint },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Ok);
+            addJudgementOffsetAssert("first slider head", () => ((Slider)hitObjects[0]).HeadCircle, 0);
+            addJudgementAssert(hitObjects[1], HitResult.Miss);
+            // the slider head of the first slider prevents the second slider's head from being hit, so the judgement offset should be very late.
+            addJudgementOffsetAssert("second slider head", () => ((Slider)hitObjects[1]).HeadCircle, referenceHitWindows.WindowFor(HitResult.Meh));
+            addClickActionAssert(0, ClickAction.Hit);
+        }
+
+        [Test]
+        public void TestOverlappingObjectsDontBlockEachOtherWhenFullyFadedOut()
+        {
+            const double time_first_circle = 1000;
+            const double time_second_circle = 1200;
+            const double time_third_circle = 1400;
+            Vector2 positionFirstCircle = new Vector2(100);
+            Vector2 positionSecondCircle = new Vector2(200);
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new HitCircle
+                {
+                    StartTime = time_first_circle,
+                    Position = positionFirstCircle,
+                },
+                new HitCircle
+                {
+                    StartTime = time_second_circle,
+                    Position = positionSecondCircle,
+                },
+                new HitCircle
+                {
+                    StartTime = time_third_circle,
+                    Position = positionFirstCircle,
+                },
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_circle, Position = positionFirstCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_first_circle + 50, Position = positionFirstCircle },
+                new OsuReplayFrame { Time = time_second_circle, Position = positionSecondCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_second_circle + 50, Position = positionSecondCircle },
+                new OsuReplayFrame { Time = time_third_circle, Position = positionFirstCircle, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_third_circle + 50, Position = positionFirstCircle },
+            });
+
+            addJudgementAssert(hitObjects[0], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[0], 0);
+
+            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[1], 0);
+
+            addJudgementAssert(hitObjects[2], HitResult.Great);
+            addJudgementOffsetAssert(hitObjects[2], 0);
         }
 
         private void addJudgementAssert(OsuHitObject hitObject, HitResult result)
@@ -408,17 +617,36 @@ namespace osu.Game.Rulesets.Osu.Tests
         private void addJudgementOffsetAssert(OsuHitObject hitObject, double offset)
         {
             AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judged at {offset}",
-                () => judgementResults.Single(r => r.HitObject == hitObject).TimeOffset, () => Is.EqualTo(offset).Within(100));
+                () => judgementResults.Single(r => r.HitObject == hitObject).TimeOffset, () => Is.EqualTo(offset).Within(50));
         }
 
+        private void addJudgementOffsetAssert(string name, Func<OsuHitObject?> hitObject, double offset)
+        {
+            AddAssert($"{name} @ judged at {offset}",
+                () => judgementResults.Single(r => r.HitObject == hitObject()).TimeOffset, () => Is.EqualTo(offset).Within(50));
+        }
+
+        private void addClickActionAssert(int inputIndex, ClickAction action)
+            => AddAssert($"input #{inputIndex} resulted in {action}", () => testPolicy.ClickActions[inputIndex], () => Is.EqualTo(action));
+
         private ScoreAccessibleReplayPlayer currentPlayer = null!;
         private List<JudgementResult> judgementResults = null!;
+        private TestLegacyHitPolicy testPolicy = null!;
 
-        private void performTest(List<OsuHitObject> hitObjects, List<ReplayFrame> frames, [CallerMemberName] string testCaseName = "")
+        private void performTest(List<OsuHitObject> hitObjects, List<ReplayFrame> frames, IEnumerable<Mod>? extraMods = null, [CallerMemberName] string testCaseName = "")
         {
+            List<Mod> mods = null!;
             IBeatmap playableBeatmap = null!;
             Score score = null!;
 
+            AddStep("set up mods", () =>
+            {
+                mods = new List<Mod> { new OsuModClassic() };
+
+                if (extraMods != null)
+                    mods.AddRange(extraMods);
+            });
+
             AddStep("create beatmap", () =>
             {
                 var cpi = new ControlPointInfo();
@@ -461,7 +689,8 @@ namespace osu.Game.Rulesets.Osu.Tests
                     ScoreInfo =
                     {
                         Ruleset = new OsuRuleset().RulesetInfo,
-                        BeatmapInfo = playableBeatmap.BeatmapInfo
+                        BeatmapInfo = playableBeatmap.BeatmapInfo,
+                        Mods = mods.ToArray()
                     }
                 };
             });
@@ -495,7 +724,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             AddStep("load player", () =>
             {
-                SelectedMods.Value = new[] { new OsuModClassic() };
+                SelectedMods.Value = mods.ToArray();
 
                 var p = new ScoreAccessibleReplayPlayer(score);
 
@@ -513,6 +742,12 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
             AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddStep("Substitute hit policy", () =>
+            {
+                var playfield = currentPlayer.ChildrenOfType<OsuPlayfield>().Single();
+                var currentPolicy = playfield.HitPolicy;
+                playfield.HitPolicy = testPolicy = new TestLegacyHitPolicy(currentPolicy);
+            });
             AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor.HasCompleted.Value);
         }
 
@@ -540,5 +775,24 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
             }
         }
+
+        private class TestLegacyHitPolicy : LegacyHitPolicy
+        {
+            private readonly IHitPolicy currentPolicy;
+
+            public TestLegacyHitPolicy(IHitPolicy currentPolicy)
+            {
+                this.currentPolicy = currentPolicy;
+            }
+
+            public List<ClickAction> ClickActions { get; } = new List<ClickAction>();
+
+            public override ClickAction CheckHittable(DrawableHitObject hitObject, double time, HitResult result)
+            {
+                var action = currentPolicy.CheckHittable(hitObject, time, result);
+                ClickActions.Add(action);
+                return action;
+            }
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderFollowCircleInput.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderFollowCircleInput.cs
index fc2e6d1f72..5adc50859f 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderFollowCircleInput.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderFollowCircleInput.cs
@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                     {
                         StartTime = time_slider_start,
                         Position = new Vector2(0, 0),
-                        SliderVelocity = velocity,
+                        SliderVelocityMultiplier = velocity,
                         Path = new SliderPath(PathType.Linear, new[]
                         {
                             Vector2.Zero,
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderInput.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderInput.cs
index d83926ab9b..644524f532 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderInput.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderInput.cs
@@ -349,7 +349,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                         {
                             StartTime = time_slider_start,
                             Position = new Vector2(0, 0),
-                            SliderVelocity = 0.1f,
+                            SliderVelocityMultiplier = 0.1f,
                             Path = new SliderPath(PathType.PerfectCurve, new[]
                             {
                                 Vector2.Zero,
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneStartTimeOrderedHitPolicy.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneStartTimeOrderedHitPolicy.cs
index f4257a9ee7..f0af3f0c39 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneStartTimeOrderedHitPolicy.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneStartTimeOrderedHitPolicy.cs
@@ -336,6 +336,52 @@ namespace osu.Game.Rulesets.Osu.Tests
             addJudgementAssert(hitObjects[1], HitResult.IgnoreHit);
         }
 
+        [Test]
+        public void TestInputFallsThroughJudgedSliders()
+        {
+            const double time_first_slider = 1000;
+            const double time_second_slider = 1250;
+            Vector2 positionFirstSlider = new Vector2(100, 50);
+            Vector2 positionSecondSlider = new Vector2(100, 80);
+            var midpoint = (positionFirstSlider + positionSecondSlider) / 2;
+
+            var hitObjects = new List<OsuHitObject>
+            {
+                new TestSlider
+                {
+                    StartTime = time_first_slider,
+                    Position = positionFirstSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                },
+                new TestSlider
+                {
+                    StartTime = time_second_slider,
+                    Position = positionSecondSlider,
+                    Path = new SliderPath(PathType.Linear, new[]
+                    {
+                        Vector2.Zero,
+                        new Vector2(25, 0),
+                    })
+                }
+            };
+
+            performTest(hitObjects, new List<ReplayFrame>
+            {
+                new OsuReplayFrame { Time = time_first_slider, Position = midpoint, Actions = { OsuAction.RightButton } },
+                new OsuReplayFrame { Time = time_first_slider + 25, Position = midpoint, Actions = { OsuAction.LeftButton } },
+                new OsuReplayFrame { Time = time_first_slider + 50, Position = midpoint },
+            });
+
+            addJudgementAssert("first slider head", () => ((Slider)hitObjects[0]).HeadCircle, HitResult.Great);
+            addJudgementOffsetAssert("first slider head", () => ((Slider)hitObjects[0]).HeadCircle, 0);
+            addJudgementAssert("second slider head", () => ((Slider)hitObjects[1]).HeadCircle, HitResult.Great);
+            addJudgementOffsetAssert("second slider head", () => ((Slider)hitObjects[1]).HeadCircle, -200);
+        }
+
         private void addJudgementAssert(OsuHitObject hitObject, HitResult result)
         {
             AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judgement is {result}",
@@ -354,6 +400,12 @@ namespace osu.Game.Rulesets.Osu.Tests
                 () => Precision.AlmostEquals(judgementResults.Single(r => r.HitObject == hitObject).TimeOffset, offset, 100));
         }
 
+        private void addJudgementOffsetAssert(string name, Func<OsuHitObject> hitObject, double offset)
+        {
+            AddAssert($"{name} @ judged at {offset}",
+                () => judgementResults.Single(r => r.HitObject == hitObject()).TimeOffset, () => Is.EqualTo(offset).Within(50));
+        }
+
         private ScoreAccessibleReplayPlayer currentPlayer;
         private List<JudgementResult> judgementResults;
 
@@ -399,7 +451,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             public TestSlider()
             {
-                SliderVelocity = 0.1f;
+                SliderVelocityMultiplier = 0.1f;
 
                 DefaultsApplied += _ =>
                 {
diff --git a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs
index 9e786caf0c..f3aaf831d3 100644
--- a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs
@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         // this results in more (or less) ticks being generated in <v8 maps for the same time duration.
                         TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / ((LegacyControlPointInfo)beatmap.ControlPointInfo).DifficultyPointAt(original.StartTime).SliderVelocity : 1,
                         GenerateTicks = generateTicksData?.GenerateTicks ?? true,
-                        SliderVelocity = sliderVelocityData?.SliderVelocity ?? 1,
+                        SliderVelocityMultiplier = sliderVelocityData?.SliderVelocityMultiplier ?? 1,
                     }.Yield();
 
                 case IHasDuration endTimeData:
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
index 966092c6fe..ba7b855511 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
@@ -85,9 +85,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                     BeginPlacement();
 
                     double? nearestSliderVelocity = (editorBeatmap.HitObjects
-                                                                  .LastOrDefault(h => h is Slider && h.GetEndTime() < HitObject.StartTime) as Slider)?.SliderVelocity;
+                                                                  .LastOrDefault(h => h is Slider && h.GetEndTime() < HitObject.StartTime) as Slider)?.SliderVelocityMultiplier;
 
-                    HitObject.SliderVelocity = nearestSliderVelocity ?? 1;
+                    HitObject.SliderVelocityMultiplier = nearestSliderVelocity ?? 1;
                     HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
 
                     // Replacing the DifficultyControlPoint above doesn't trigger any kind of invalidation.
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModClassic.cs b/osu.Game.Rulesets.Osu/Mods/OsuModClassic.cs
index 250d97c537..5dbf23f7ea 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModClassic.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModClassic.cs
@@ -11,6 +11,7 @@ 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.Scoring;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
@@ -57,7 +58,10 @@ namespace osu.Game.Rulesets.Osu.Mods
             var osuRuleset = (DrawableOsuRuleset)drawableRuleset;
 
             if (ClassicNoteLock.Value)
-                osuRuleset.Playfield.HitPolicy = new ObjectOrderedHitPolicy();
+            {
+                double hittableRange = OsuHitWindows.MISS_WINDOW - (drawableRuleset.Mods.OfType<OsuModAutopilot>().Any() ? 200 : 0);
+                osuRuleset.Playfield.HitPolicy = new LegacyHitPolicy(hittableRange);
+            }
 
             usingHiddenFading = drawableRuleset.Mods.OfType<OsuModHidden>().SingleOrDefault()?.OnlyFadeApproachCircles.Value == false;
         }
@@ -85,13 +89,16 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         private void applyEarlyFading(DrawableHitCircle circle)
         {
-            circle.ApplyCustomUpdateState += (o, _) =>
+            circle.ApplyCustomUpdateState += (dho, state) =>
             {
-                using (o.BeginAbsoluteSequence(o.StateUpdateTime))
+                using (dho.BeginAbsoluteSequence(dho.StateUpdateTime))
                 {
-                    double okWindow = o.HitObject.HitWindows.WindowFor(HitResult.Ok);
-                    double lateMissFadeTime = o.HitObject.HitWindows.WindowFor(HitResult.Meh) - okWindow;
-                    o.Delay(okWindow).FadeOut(lateMissFadeTime);
+                    if (state != ArmedState.Hit)
+                    {
+                        double okWindow = dho.HitObject.HitWindows.WindowFor(HitResult.Ok);
+                        double lateMissFadeTime = dho.HitObject.HitWindows.WindowFor(HitResult.Meh) - okWindow;
+                        dho.Delay(okWindow).FadeOut(lateMissFadeTime);
+                    }
                 }
             };
         }
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs b/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs
index 3a6b232f9f..f35b1abc42 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs
@@ -2,13 +2,19 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModDifficultyAdjust : ModDifficultyAdjust
+    public partial class OsuModDifficultyAdjust : ModDifficultyAdjust
     {
         [SettingSource("Circle Size", "Override a beatmap's set CS.", FIRST_SETTING_ORDER - 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
         public DifficultyBindable CircleSize { get; } = new DifficultyBindable
@@ -20,12 +26,13 @@ namespace osu.Game.Rulesets.Osu.Mods
             ReadCurrentFromDifficulty = diff => diff.CircleSize,
         };
 
-        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1, SettingControlType = typeof(DifficultyAdjustSettingsControl))]
+        [SettingSource("Approach Rate", "Override a beatmap's set AR.", LAST_SETTING_ORDER + 1, SettingControlType = typeof(ApproachRateSettingsControl))]
         public DifficultyBindable ApproachRate { get; } = new DifficultyBindable
         {
             Precision = 0.1f,
             MinValue = 0,
             MaxValue = 10,
+            ExtendedMinValue = -10,
             ExtendedMaxValue = 11,
             ReadCurrentFromDifficulty = diff => diff.ApproachRate,
         };
@@ -53,5 +60,34 @@ namespace osu.Game.Rulesets.Osu.Mods
             if (CircleSize.Value != null) difficulty.CircleSize = CircleSize.Value.Value;
             if (ApproachRate.Value != null) difficulty.ApproachRate = ApproachRate.Value.Value;
         }
+
+        private partial class ApproachRateSettingsControl : DifficultyAdjustSettingsControl
+        {
+            protected override RoundedSliderBar<float> CreateSlider(BindableNumber<float> current) =>
+                new ApproachRateSlider
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Current = current,
+                    KeyboardStep = 0.1f,
+                };
+
+            /// <summary>
+            /// A slider bar with more detailed approach rate info for its given value
+            /// </summary>
+            public partial class ApproachRateSlider : RoundedSliderBar<float>
+            {
+                public override LocalisableString TooltipText =>
+                    (Current as BindableNumber<float>)?.MinValue < 0
+                        ? $"{base.TooltipText} ({getPreemptTime(Current.Value):0} ms)"
+                        : base.TooltipText;
+
+                private double getPreemptTime(float approachRate)
+                {
+                    var hitCircle = new HitCircle();
+                    hitCircle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { ApproachRate = approachRate });
+                    return hitCircle.TimePreempt;
+                }
+            }
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModFlashlight.cs b/osu.Game.Rulesets.Osu/Mods/OsuModFlashlight.cs
index efeac9a180..252d7e2762 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModFlashlight.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModFlashlight.cs
@@ -68,8 +68,8 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             public void OnSliderTrackingChange(ValueChangedEvent<bool> e)
             {
-                // If a slider is in a tracking state, a further dim should be applied to the (remaining) visible portion of the playfield over a brief duration.
-                this.TransformTo(nameof(FlashlightDim), e.NewValue ? 0.8f : 0.0f, 50);
+                // If a slider is in a tracking state, a further dim should be applied to the (remaining) visible portion of the playfield.
+                FlashlightDim = e.NewValue ? 0.8f : 0.0f;
             }
 
             protected override bool OnMouseMove(MouseMoveEvent e)
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs b/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs
index 72031b4958..9b5d405025 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModStrictTracking.cs
@@ -98,7 +98,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 ComboOffset = original.ComboOffset;
                 LegacyLastTickOffset = original.LegacyLastTickOffset;
                 TickDistanceMultiplier = original.TickDistanceMultiplier;
-                SliderVelocity = original.SliderVelocity;
+                SliderVelocityMultiplier = original.SliderVelocityMultiplier;
             }
 
             protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
index 3458069dd1..932f6d3fff 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
@@ -18,6 +18,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Osu.Skinning.Default;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osuTK;
@@ -154,12 +155,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
 
             var result = ResultFor(timeOffset);
+            var clickAction = CheckHittable?.Invoke(this, Time.Current, result);
 
-            if (result == HitResult.None || CheckHittable?.Invoke(this, Time.Current) == false)
-            {
+            if (clickAction == ClickAction.Shake)
                 Shake();
+
+            if (result == HitResult.None || clickAction != ClickAction.Hit)
                 return;
-            }
 
             ApplyResult(r =>
             {
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
index df0ba344d8..920dfcab03 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
@@ -12,6 +12,8 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Scoring;
 using osuTK;
 using osuTK.Graphics;
 
@@ -30,10 +32,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected override float SamplePlaybackPosition => CalculateDrawableRelativePosition(this);
 
         /// <summary>
-        /// Whether this <see cref="DrawableOsuHitObject"/> can be hit, given a time value.
-        /// If non-null, judgements will be ignored (resulting in a shake) whilst the function returns false.
+        /// What action this <see cref="DrawableOsuHitObject"/> should take in response to a
+        /// click at the given time value.
+        /// If non-null, judgements will be ignored for return values of <see cref="ClickAction.Ignore"/>
+        /// and <see cref="ClickAction.Shake"/>, and this hit object will be shaken for return values of
+        /// <see cref="ClickAction.Shake"/>.
         /// </summary>
-        public Func<DrawableHitObject, double, bool> CheckHittable;
+        public Func<DrawableHitObject, double, HitResult, ClickAction> CheckHittable;
 
         protected DrawableOsuHitObject(OsuHitObject hitObject)
             : base(hitObject)
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs
index b8a1efabe0..41f6a40c0a 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs
@@ -8,6 +8,7 @@ using System.Diagnostics;
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
@@ -60,7 +61,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             pathVersion.BindTo(DrawableSlider.PathVersion);
 
-            CheckHittable = (d, t) => DrawableSlider.CheckHittable?.Invoke(d, t) ?? true;
+            CheckHittable = (d, t, r) => DrawableSlider.CheckHittable?.Invoke(d, t, r) ?? ClickAction.Hit;
         }
 
         protected override void Update()
diff --git a/osu.Game.Rulesets.Osu/Objects/Slider.cs b/osu.Game.Rulesets.Osu/Objects/Slider.cs
index 4189f8ba1e..1e7e8e2981 100644
--- a/osu.Game.Rulesets.Osu/Objects/Slider.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Slider.cs
@@ -113,7 +113,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         public double SpanDuration => Duration / this.SpanCount();
 
         /// <summary>
-        /// Velocity of this <see cref="Slider"/>.
+        /// The computed velocity of this <see cref="Slider"/>. This is the amount of path distance travelled in 1 ms.
         /// </summary>
         public double Velocity { get; private set; }
 
@@ -134,17 +134,17 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public bool OnlyJudgeNestedObjects = true;
 
-        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1)
+        public BindableNumber<double> SliderVelocityMultiplierBindable { get; } = new BindableDouble(1)
         {
             Precision = 0.01,
             MinValue = 0.1,
             MaxValue = 10
         };
 
-        public double SliderVelocity
+        public double SliderVelocityMultiplier
         {
-            get => SliderVelocityBindable.Value;
-            set => SliderVelocityBindable.Value = value;
+            get => SliderVelocityMultiplierBindable.Value;
+            set => SliderVelocityMultiplierBindable.Value = value;
         }
 
         public bool GenerateTicks { get; set; } = true;
@@ -167,7 +167,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
 
-            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * SliderVelocity;
+            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * SliderVelocityMultiplier;
 
             Velocity = scoringDistance / timingPoint.BeatLength;
             TickDistance = GenerateTicks ? (scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier) : double.PositiveInfinity;
diff --git a/osu.Game.Rulesets.Osu/UI/AnyOrderHitPolicy.cs b/osu.Game.Rulesets.Osu/UI/AnyOrderHitPolicy.cs
index afa54c2dfb..2c6895d7ec 100644
--- a/osu.Game.Rulesets.Osu/UI/AnyOrderHitPolicy.cs
+++ b/osu.Game.Rulesets.Osu/UI/AnyOrderHitPolicy.cs
@@ -1,9 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu.UI
@@ -13,9 +12,9 @@ namespace osu.Game.Rulesets.Osu.UI
     /// </summary>
     public class AnyOrderHitPolicy : IHitPolicy
     {
-        public IHitObjectContainer HitObjectContainer { get; set; }
+        public IHitObjectContainer HitObjectContainer { get; set; } = null!;
 
-        public bool IsHittable(DrawableHitObject hitObject, double time) => true;
+        public ClickAction CheckHittable(DrawableHitObject hitObject, double time, HitResult result) => ClickAction.Hit;
 
         public void HandleHit(DrawableHitObject hitObject)
         {
diff --git a/osu.Game.Rulesets.Osu/UI/ClickAction.cs b/osu.Game.Rulesets.Osu/UI/ClickAction.cs
new file mode 100644
index 0000000000..2b00f5acce
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/ClickAction.cs
@@ -0,0 +1,18 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    /// <summary>
+    /// An action that an <see cref="IHitPolicy"/> recommends be taken in response to a click
+    /// on a <see cref="DrawableOsuHitObject"/>.
+    /// </summary>
+    public enum ClickAction
+    {
+        Ignore,
+        Shake,
+        Hit
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/IHitPolicy.cs b/osu.Game.Rulesets.Osu/UI/IHitPolicy.cs
index b509796742..44d3b37408 100644
--- a/osu.Game.Rulesets.Osu/UI/IHitPolicy.cs
+++ b/osu.Game.Rulesets.Osu/UI/IHitPolicy.cs
@@ -3,6 +3,7 @@
 
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu.UI
@@ -19,8 +20,9 @@ namespace osu.Game.Rulesets.Osu.UI
         /// </summary>
         /// <param name="hitObject">The <see cref="DrawableHitObject"/> to check.</param>
         /// <param name="time">The time to check.</param>
+        /// <param name="result">The result that the object would be judged with if hit.</param>
         /// <returns>Whether <paramref name="hitObject"/> can be hit at the given <paramref name="time"/>.</returns>
-        bool IsHittable(DrawableHitObject hitObject, double time);
+        ClickAction CheckHittable(DrawableHitObject hitObject, double time, HitResult result);
 
         /// <summary>
         /// Handles a <see cref="HitObject"/> being hit.
diff --git a/osu.Game.Rulesets.Osu/UI/LegacyHitPolicy.cs b/osu.Game.Rulesets.Osu/UI/LegacyHitPolicy.cs
new file mode 100644
index 0000000000..daf498581e
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/UI/LegacyHitPolicy.cs
@@ -0,0 +1,72 @@
+// Copyright (c) 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.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    /// <summary>
+    /// Ensures that <see cref="HitObject"/>s are hit in order of appearance. The classic note lock.
+    /// <remarks>
+    /// Hits will be blocked until the previous <see cref="HitObject"/>s have been judged.
+    /// </remarks>
+    /// </summary>
+    public class LegacyHitPolicy : IHitPolicy
+    {
+        public IHitObjectContainer? HitObjectContainer { get; set; }
+
+        private readonly double hittableRange;
+
+        public LegacyHitPolicy(double hittableRange = OsuHitWindows.MISS_WINDOW)
+        {
+            this.hittableRange = hittableRange;
+        }
+
+        public void HandleHit(DrawableHitObject hitObject)
+        {
+        }
+
+        public virtual ClickAction CheckHittable(DrawableHitObject hitObject, double time, HitResult result)
+        {
+            if (HitObjectContainer == null)
+                throw new InvalidOperationException($"{nameof(HitObjectContainer)} should be set before {nameof(CheckHittable)} is called.");
+
+            var aliveObjects = HitObjectContainer.AliveObjects.ToList();
+            int index = aliveObjects.IndexOf(hitObject);
+
+            if (index > 0)
+            {
+                var previousHitObject = (DrawableOsuHitObject)aliveObjects[index - 1];
+                if (previousHitObject.HitObject.StackHeight > 0 && !previousHitObject.AllJudged)
+                    return ClickAction.Ignore;
+            }
+
+            if (result == HitResult.None)
+                return ClickAction.Shake;
+
+            foreach (DrawableHitObject testObject in aliveObjects)
+            {
+                if (testObject.AllJudged)
+                    continue;
+
+                // if we found the object being checked, we can move on to the final timing test.
+                if (testObject == hitObject)
+                    break;
+
+                // for all other objects, we check for validity and block the hit if any are still valid.
+                // 3ms of extra leniency to account for slightly unsnapped objects.
+                if (testObject.HitObject.GetEndTime() + 3 < hitObject.HitObject.StartTime)
+                    return ClickAction.Shake;
+            }
+
+            return Math.Abs(hitObject.HitObject.StartTime - time) < hittableRange ? ClickAction.Hit : ClickAction.Shake;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/UI/ObjectOrderedHitPolicy.cs b/osu.Game.Rulesets.Osu/UI/ObjectOrderedHitPolicy.cs
deleted file mode 100644
index 6330208d37..0000000000
--- a/osu.Game.Rulesets.Osu/UI/ObjectOrderedHitPolicy.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-#nullable disable
-
-using System.Collections.Generic;
-using System.Linq;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.UI;
-
-namespace osu.Game.Rulesets.Osu.UI
-{
-    /// <summary>
-    /// Ensures that <see cref="HitObject"/>s are hit in order of appearance. The classic note lock.
-    /// <remarks>
-    /// Hits will be blocked until the previous <see cref="HitObject"/>s have been judged.
-    /// </remarks>
-    /// </summary>
-    public class ObjectOrderedHitPolicy : IHitPolicy
-    {
-        public IHitObjectContainer HitObjectContainer { get; set; }
-
-        public bool IsHittable(DrawableHitObject hitObject, double time) => enumerateHitObjectsUpTo(hitObject.HitObject.StartTime).All(obj => obj.AllJudged);
-
-        public void HandleHit(DrawableHitObject hitObject)
-        {
-        }
-
-        private IEnumerable<DrawableHitObject> enumerateHitObjectsUpTo(double targetTime)
-        {
-            foreach (var obj in HitObjectContainer.AliveObjects)
-            {
-                if (obj.HitObject.StartTime >= targetTime)
-                    yield break;
-
-                switch (obj)
-                {
-                    case DrawableSpinner:
-                        continue;
-
-                    case DrawableSlider slider:
-                        yield return slider.HeadCircle;
-
-                        break;
-
-                    default:
-                        yield return obj;
-
-                        break;
-                }
-            }
-        }
-    }
-}
diff --git a/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs b/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
index ed02284a4b..15ca0a90de 100644
--- a/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
+++ b/osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
@@ -89,7 +89,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         protected override void OnNewDrawableHitObject(DrawableHitObject drawable)
         {
-            ((DrawableOsuHitObject)drawable).CheckHittable = hitPolicy.IsHittable;
+            ((DrawableOsuHitObject)drawable).CheckHittable = hitPolicy.CheckHittable;
 
             Debug.Assert(!drawable.IsLoaded, $"Already loaded {nameof(DrawableHitObject)} is added to {nameof(OsuPlayfield)}");
             drawable.OnLoadComplete += onDrawableHitObjectLoaded;
diff --git a/osu.Game.Rulesets.Osu/UI/StartTimeOrderedHitPolicy.cs b/osu.Game.Rulesets.Osu/UI/StartTimeOrderedHitPolicy.cs
index edc3ba0818..2b24fb9398 100644
--- a/osu.Game.Rulesets.Osu/UI/StartTimeOrderedHitPolicy.cs
+++ b/osu.Game.Rulesets.Osu/UI/StartTimeOrderedHitPolicy.cs
@@ -1,13 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu.UI
@@ -22,11 +21,14 @@ namespace osu.Game.Rulesets.Osu.UI
     /// </summary>
     public class StartTimeOrderedHitPolicy : IHitPolicy
     {
-        public IHitObjectContainer HitObjectContainer { get; set; }
+        public IHitObjectContainer? HitObjectContainer { get; set; }
 
-        public bool IsHittable(DrawableHitObject hitObject, double time)
+        public ClickAction CheckHittable(DrawableHitObject hitObject, double time, HitResult _)
         {
-            DrawableHitObject blockingObject = null;
+            if (HitObjectContainer == null)
+                throw new InvalidOperationException($"{nameof(HitObjectContainer)} should be set before {nameof(CheckHittable)} is called.");
+
+            DrawableHitObject? blockingObject = null;
 
             foreach (var obj in enumerateHitObjectsUpTo(hitObject.HitObject.StartTime))
             {
@@ -36,22 +38,25 @@ namespace osu.Game.Rulesets.Osu.UI
 
             // If there is no previous hitobject, allow the hit.
             if (blockingObject == null)
-                return true;
+                return ClickAction.Hit;
 
             // A hit is allowed if:
             // 1. The last blocking hitobject has been judged.
             // 2. The current time is after the last hitobject's start time.
             // Hits at exactly the same time as the blocking hitobject are allowed for maps that contain simultaneous hitobjects (e.g. /b/372245).
-            return blockingObject.Judged || time >= blockingObject.HitObject.StartTime;
+            return (blockingObject.Judged || time >= blockingObject.HitObject.StartTime) ? ClickAction.Hit : ClickAction.Shake;
         }
 
         public void HandleHit(DrawableHitObject hitObject)
         {
+            if (HitObjectContainer == null)
+                throw new InvalidOperationException($"{nameof(HitObjectContainer)} should be set before {nameof(HandleHit)} is called.");
+
             // Hitobjects which themselves don't block future hitobjects don't cause misses (e.g. slider ticks, spinners).
             if (!hitObjectCanBlockFutureHits(hitObject))
                 return;
 
-            if (!IsHittable(hitObject, hitObject.HitObject.StartTime + hitObject.Result.TimeOffset))
+            if (CheckHittable(hitObject, hitObject.HitObject.StartTime + hitObject.Result.TimeOffset, hitObject.Result.Type) != ClickAction.Hit)
                 throw new InvalidOperationException($"A {hitObject} was hit before it became hittable!");
 
             // Miss all hitobjects prior to the hit one.
@@ -74,7 +79,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         private IEnumerable<DrawableHitObject> enumerateHitObjectsUpTo(double targetTime)
         {
-            foreach (var obj in HitObjectContainer.AliveObjects)
+            foreach (var obj in HitObjectContainer!.AliveObjects)
             {
                 if (obj.HitObject.StartTime >= targetTime)
                     yield break;
diff --git a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
index 5f3d0f898e..3e9252e1fd 100644
--- a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
@@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 {
                     if (hitObject is not IHasSliderVelocity hasSliderVelocity) continue;
 
-                    double nextScrollSpeed = hasSliderVelocity.SliderVelocity;
+                    double nextScrollSpeed = hasSliderVelocity.SliderVelocityMultiplier;
                     EffectControlPoint currentEffectPoint = converted.ControlPointInfo.EffectPointAt(hitObject.StartTime);
 
                     if (!Precision.AlmostEquals(lastScrollSpeed, nextScrollSpeed, acceptableDifference: currentEffectPoint.ScrollSpeedBindable.Precision))
@@ -189,7 +189,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             if (obj.LegacyBpmMultiplier.HasValue)
                 beatLength = timingPoint.BeatLength * obj.LegacyBpmMultiplier.Value;
             else if (obj is IHasSliderVelocity hasSliderVelocity)
-                beatLength = timingPoint.BeatLength / hasSliderVelocity.SliderVelocity;
+                beatLength = timingPoint.BeatLength / hasSliderVelocity.SliderVelocityMultiplier;
             else
                 beatLength = timingPoint.BeatLength;
 
diff --git a/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs b/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
index e30caac95e..6b78eea009 100644
--- a/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
+++ b/osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs
@@ -78,7 +78,7 @@ namespace osu.Game.Tests.Editing
         {
             assertSnapDistance(100, new Slider
             {
-                SliderVelocity = multiplier
+                SliderVelocityMultiplier = multiplier
             }, false);
         }
 
@@ -88,7 +88,7 @@ namespace osu.Game.Tests.Editing
         {
             assertSnapDistance(100 * multiplier, new Slider
             {
-                SliderVelocity = multiplier
+                SliderVelocityMultiplier = multiplier
             }, true);
         }
 
@@ -112,7 +112,7 @@ namespace osu.Game.Tests.Editing
 
             var referenceObject = new Slider
             {
-                SliderVelocity = slider_velocity
+                SliderVelocityMultiplier = slider_velocity
             };
 
             assertSnapDistance(base_distance * slider_velocity, referenceObject, true);
diff --git a/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs b/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs
index 88e47ea560..dcc4654437 100644
--- a/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs
+++ b/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs
@@ -47,7 +47,35 @@ namespace osu.Game.Tests.Visual.Beatmaps
                 pill.AutoSizeAxes = Axes.Y;
                 pill.Width = 90;
             }));
+
             AddStep("unset fixed width", () => statusPills.ForEach(pill => pill.AutoSizeAxes = Axes.Both));
         }
+
+        [Test]
+        public void TestChangeLabels()
+        {
+            AddStep("Change labels", () =>
+            {
+                foreach (var pill in this.ChildrenOfType<BeatmapSetOnlineStatusPill>())
+                {
+                    switch (pill.Status)
+                    {
+                        // cycle at end
+                        case BeatmapOnlineStatus.Loved:
+                            pill.Status = BeatmapOnlineStatus.LocallyModified;
+                            break;
+
+                        // skip none
+                        case BeatmapOnlineStatus.LocallyModified:
+                            pill.Status = BeatmapOnlineStatus.Graveyard;
+                            break;
+
+                        default:
+                            pill.Status = (pill.Status + 1);
+                            break;
+                    }
+                }
+            });
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectDifficultyPointAdjustments.cs b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectDifficultyPointAdjustments.cs
index c78f50c821..530b3db208 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectDifficultyPointAdjustments.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectDifficultyPointAdjustments.cs
@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Visual.Editing
                             new PathControlPoint(new Vector2(100, 0))
                         }
                     },
-                    SliderVelocity = 2
+                    SliderVelocityMultiplier = 2
                 });
             });
         }
@@ -110,7 +110,7 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("unify slider velocity", () =>
             {
                 foreach (var h in EditorBeatmap.HitObjects.OfType<IHasSliderVelocity>())
-                    h.SliderVelocity = 1.5;
+                    h.SliderVelocityMultiplier = 1.5;
             });
 
             AddStep("select both objects", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
@@ -194,7 +194,7 @@ namespace osu.Game.Tests.Visual.Editing
         private void hitObjectHasVelocity(int objectIndex, double velocity) => AddAssert($"{objectIndex.ToOrdinalWords()} has velocity {velocity}", () =>
         {
             var h = EditorBeatmap.HitObjects.ElementAt(objectIndex);
-            return h is IHasSliderVelocity hasSliderVelocity && hasSliderVelocity.SliderVelocity == velocity;
+            return h is IHasSliderVelocity hasSliderVelocity && hasSliderVelocity.SliderVelocityMultiplier == velocity;
         });
     }
 }
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs
index 54ee1659e1..d0fa5fc737 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneBeatmapEditorNavigation.cs
@@ -9,6 +9,7 @@ using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Database;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Osu;
@@ -16,6 +17,7 @@ using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.GameplayTest;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
 using osu.Game.Tests.Resources;
 using osuTK.Input;
 
@@ -203,6 +205,33 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("wait for music stopped", () => !Game.MusicController.IsPlaying);
         }
 
+        [TestCase(SortMode.Title)]
+        [TestCase(SortMode.Difficulty)]
+        public void TestSelectionRetainedOnExit(SortMode sortMode)
+        {
+            BeatmapSetInfo beatmapSet = null!;
+
+            AddStep("import test beatmap", () => Game.BeatmapManager.Import(TestResources.GetTestBeatmapForImport()).WaitSafely());
+            AddStep("retrieve beatmap", () => beatmapSet = Game.BeatmapManager.QueryBeatmapSet(set => !set.Protected).AsNonNull().Value.Detach());
+
+            AddStep($"set sort mode to {sortMode}", () => Game.LocalConfig.SetValue(OsuSetting.SongSelectSortingMode, sortMode));
+            AddStep("present beatmap", () => Game.PresentBeatmap(beatmapSet));
+            AddUntilStep("wait for song select",
+                () => Game.Beatmap.Value.BeatmapSetInfo.Equals(beatmapSet)
+                      && Game.ScreenStack.CurrentScreen is PlaySongSelect songSelect
+                      && songSelect.IsLoaded);
+
+            AddStep("open editor", () => ((PlaySongSelect)Game.ScreenStack.CurrentScreen).Edit(beatmapSet.Beatmaps.First(beatmap => beatmap.Ruleset.OnlineID == 0)));
+            AddUntilStep("wait for editor open", () => Game.ScreenStack.CurrentScreen is Editor editor && editor.ReadyForUse);
+
+            AddStep("exit editor", () => InputManager.Key(Key.Escape));
+            AddUntilStep("wait for editor exit", () => Game.ScreenStack.CurrentScreen is not Editor);
+
+            AddUntilStep("selection retained on song select",
+                () => Game.Beatmap.Value.BeatmapInfo.ID,
+                () => Is.EqualTo(beatmapSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0).ID));
+        }
+
         private EditorBeatmap getEditorBeatmap() => getEditor().ChildrenOfType<EditorBeatmap>().Single();
 
         private Editor getEditor() => (Editor)Game.ScreenStack.CurrentScreen;
diff --git a/osu.Game.Tests/Visual/Online/TestSceneUserProfileOverlay.cs b/osu.Game.Tests/Visual/Online/TestSceneUserProfileOverlay.cs
index 4278c46d6a..b57b0b7312 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneUserProfileOverlay.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneUserProfileOverlay.cs
@@ -134,14 +134,16 @@ namespace osu.Game.Tests.Visual.Online
                 {
                     AwardedAt = DateTimeOffset.FromUnixTimeSeconds(1505741569),
                     Description = "Outstanding help by being a voluntary test subject.",
-                    ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.jpg",
+                    ImageUrl = "https://assets.ppy.sh/profile-badges/contributor-new@2x.png",
+                    ImageUrlLowRes = "https://assets.ppy.sh/profile-badges/contributor-new.png",
                     Url = "https://osu.ppy.sh/wiki/en/People/Community_Contributors",
                 },
                 new Badge
                 {
                     AwardedAt = DateTimeOffset.FromUnixTimeSeconds(1505741569),
                     Description = "Badge without a url.",
-                    ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.jpg",
+                    ImageUrl = "https://assets.ppy.sh/profile-badges/contributor@2x.png",
+                    ImageUrlLowRes = "https://assets.ppy.sh/profile-badges/contributor.png",
                 },
             },
             Title = "osu!volunteer",
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs
index 61f95dc628..c509d40e07 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarousel.cs
@@ -39,6 +39,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         private BeatmapInfo currentSelection => carousel.SelectedBeatmapInfo;
 
         private const int set_count = 5;
+        private const int diff_count = 3;
 
         [BackgroundDependencyLoader]
         private void load(RulesetStore rulesets)
@@ -111,7 +112,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         [Test]
         public void TestScrollPositionMaintainedOnAdd()
         {
-            loadBeatmaps(count: 1, randomDifficulties: false);
+            loadBeatmaps(setCount: 1);
 
             for (int i = 0; i < 10; i++)
             {
@@ -124,7 +125,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         [Test]
         public void TestDeletion()
         {
-            loadBeatmaps(count: 5, randomDifficulties: true);
+            loadBeatmaps(setCount: 5, randomDifficulties: true);
 
             AddStep("remove first set", () => carousel.RemoveBeatmapSet(carousel.Items.Select(item => item.Item).OfType<CarouselBeatmapSet>().First().BeatmapSet));
             AddUntilStep("4 beatmap sets visible", () => this.ChildrenOfType<DrawableCarouselBeatmapSet>().Count(set => set.Alpha > 0) == 4);
@@ -133,7 +134,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         [Test]
         public void TestScrollPositionMaintainedOnDelete()
         {
-            loadBeatmaps(count: 50, randomDifficulties: false);
+            loadBeatmaps(setCount: 50);
 
             for (int i = 0; i < 10; i++)
             {
@@ -150,7 +151,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         [Test]
         public void TestManyPanels()
         {
-            loadBeatmaps(count: 5000, randomDifficulties: true);
+            loadBeatmaps(setCount: 5000, randomDifficulties: true);
         }
 
         [Test]
@@ -501,6 +502,34 @@ namespace osu.Game.Tests.Visual.SongSelect
             waitForSelection(set_count);
         }
 
+        [Test]
+        public void TestAddRemoveDifficultySort()
+        {
+            const int local_set_count = 2;
+            const int local_diff_count = 2;
+
+            loadBeatmaps(setCount: local_set_count, diffCount: local_diff_count);
+
+            AddStep("Sort by difficulty", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty }, false));
+
+            checkVisibleItemCount(false, local_set_count * local_diff_count);
+
+            var firstAdded = TestResources.CreateTestBeatmapSetInfo(local_diff_count);
+            firstAdded.Status = BeatmapOnlineStatus.Loved;
+
+            AddStep("Add new set", () => carousel.UpdateBeatmapSet(firstAdded));
+
+            checkVisibleItemCount(false, (local_set_count + 1) * local_diff_count);
+
+            AddStep("Remove set", () => carousel.RemoveBeatmapSet(firstAdded));
+
+            checkVisibleItemCount(false, (local_set_count) * local_diff_count);
+
+            setSelected(local_set_count, 1);
+
+            waitForSelection(local_set_count);
+        }
+
         [Test]
         public void TestSelectionEnteringFromEmptyRuleset()
         {
@@ -662,7 +691,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
                 for (int i = 0; i < 3; i++)
                 {
-                    var set = TestResources.CreateTestBeatmapSetInfo(3);
+                    var set = TestResources.CreateTestBeatmapSetInfo(diff_count);
 
                     // only need to set the first as they are a shared reference.
                     var beatmap = set.Beatmaps.First();
@@ -709,7 +738,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
                 for (int i = 0; i < 3; i++)
                 {
-                    var set = TestResources.CreateTestBeatmapSetInfo(3);
+                    var set = TestResources.CreateTestBeatmapSetInfo(diff_count);
 
                     // only need to set the first as they are a shared reference.
                     var beatmap = set.Beatmaps.First();
@@ -758,32 +787,54 @@ namespace osu.Game.Tests.Visual.SongSelect
         }
 
         [Test]
-        public void TestSortingWithFiltered()
+        public void TestSortingWithDifficultyFiltered()
         {
+            const int local_diff_count = 3;
+            const int local_set_count = 2;
+
             List<BeatmapSetInfo> sets = new List<BeatmapSetInfo>();
 
             AddStep("Populuate beatmap sets", () =>
             {
                 sets.Clear();
 
-                for (int i = 0; i < 3; i++)
+                for (int i = 0; i < local_set_count; i++)
                 {
-                    var set = TestResources.CreateTestBeatmapSetInfo(3);
+                    var set = TestResources.CreateTestBeatmapSetInfo(local_diff_count);
                     set.Beatmaps[0].StarRating = 3 - i;
-                    set.Beatmaps[2].StarRating = 6 + i;
+                    set.Beatmaps[1].StarRating = 6 + i;
                     sets.Add(set);
                 }
             });
 
             loadBeatmaps(sets);
 
+            AddStep("Sort by difficulty", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty }, false));
+
+            checkVisibleItemCount(false, local_set_count * local_diff_count);
+            checkVisibleItemCount(true, 1);
+
             AddStep("Filter to normal", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty, SearchText = "Normal" }, false));
-            AddAssert("Check first set at end", () => carousel.BeatmapSets.First().Equals(sets.Last()));
-            AddAssert("Check last set at start", () => carousel.BeatmapSets.Last().Equals(sets.First()));
+            checkVisibleItemCount(false, local_set_count);
+            checkVisibleItemCount(true, 1);
+
+            AddUntilStep("Check all visible sets have one normal", () =>
+            {
+                return carousel.Items.OfType<DrawableCarouselBeatmapSet>()
+                               .Where(p => p.IsPresent)
+                               .Count(p => ((CarouselBeatmapSet)p.Item)!.Beatmaps.Single().BeatmapInfo.DifficultyName.StartsWith("Normal", StringComparison.Ordinal)) == local_set_count;
+            });
 
             AddStep("Filter to insane", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty, SearchText = "Insane" }, false));
-            AddAssert("Check first set at start", () => carousel.BeatmapSets.First().Equals(sets.First()));
-            AddAssert("Check last set at end", () => carousel.BeatmapSets.Last().Equals(sets.Last()));
+            checkVisibleItemCount(false, local_set_count);
+            checkVisibleItemCount(true, 1);
+
+            AddUntilStep("Check all visible sets have one insane", () =>
+            {
+                return carousel.Items.OfType<DrawableCarouselBeatmapSet>()
+                               .Where(p => p.IsPresent)
+                               .Count(p => ((CarouselBeatmapSet)p.Item)!.Beatmaps.Single().BeatmapInfo.DifficultyName.StartsWith("Insane", StringComparison.Ordinal)) == local_set_count;
+            });
         }
 
         [Test]
@@ -838,7 +889,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddStep("create hidden set", () =>
             {
-                hidingSet = TestResources.CreateTestBeatmapSetInfo(3);
+                hidingSet = TestResources.CreateTestBeatmapSetInfo(diff_count);
                 hidingSet.Beatmaps[1].Hidden = true;
 
                 hiddenList.Clear();
@@ -885,7 +936,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddStep("add mixed ruleset beatmapset", () =>
             {
-                testMixed = TestResources.CreateTestBeatmapSetInfo(3);
+                testMixed = TestResources.CreateTestBeatmapSetInfo(diff_count);
 
                 for (int i = 0; i <= 2; i++)
                 {
@@ -907,7 +958,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             BeatmapSetInfo testSingle = null;
             AddStep("add single ruleset beatmapset", () =>
             {
-                testSingle = TestResources.CreateTestBeatmapSetInfo(3);
+                testSingle = TestResources.CreateTestBeatmapSetInfo(diff_count);
                 testSingle.Beatmaps.ForEach(b =>
                 {
                     b.Ruleset = rulesets.AvailableRulesets.ElementAt(1);
@@ -930,7 +981,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 manySets.Clear();
 
                 for (int i = 1; i <= 50; i++)
-                    manySets.Add(TestResources.CreateTestBeatmapSetInfo(3));
+                    manySets.Add(TestResources.CreateTestBeatmapSetInfo(diff_count));
             });
 
             loadBeatmaps(manySets);
@@ -955,6 +1006,43 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("Selection was remembered", () => eagerSelectedIDs.Count == 1);
         }
 
+        [Test]
+        public void TestCarouselRemembersSelectionDifficultySort()
+        {
+            List<BeatmapSetInfo> manySets = new List<BeatmapSetInfo>();
+
+            AddStep("Populate beatmap sets", () =>
+            {
+                manySets.Clear();
+
+                for (int i = 1; i <= 50; i++)
+                    manySets.Add(TestResources.CreateTestBeatmapSetInfo(diff_count));
+            });
+
+            loadBeatmaps(manySets);
+
+            AddStep("Sort by difficulty", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty }, false));
+
+            advanceSelection(direction: 1, diff: false);
+
+            for (int i = 0; i < 5; i++)
+            {
+                AddStep("Toggle non-matching filter", () =>
+                {
+                    carousel.Filter(new FilterCriteria { SearchText = Guid.NewGuid().ToString() }, false);
+                });
+
+                AddStep("Restore no filter", () =>
+                {
+                    carousel.Filter(new FilterCriteria(), false);
+                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet!.ID);
+                });
+            }
+
+            // always returns to same selection as long as it's available.
+            AddAssert("Selection was remembered", () => eagerSelectedIDs.Count == 1);
+        }
+
         [Test]
         public void TestFilteringByUserStarDifficulty()
         {
@@ -1081,20 +1169,26 @@ namespace osu.Game.Tests.Visual.SongSelect
             }
         }
 
-        private void loadBeatmaps(List<BeatmapSetInfo> beatmapSets = null, Func<FilterCriteria> initialCriteria = null, Action<BeatmapCarousel> carouselAdjust = null, int? count = null,
-                                  bool randomDifficulties = false)
+        private void loadBeatmaps(List<BeatmapSetInfo> beatmapSets = null, Func<FilterCriteria> initialCriteria = null, Action<BeatmapCarousel> carouselAdjust = null,
+                                  int? setCount = null, int? diffCount = null, bool randomDifficulties = false)
         {
             bool changed = false;
 
             if (beatmapSets == null)
             {
                 beatmapSets = new List<BeatmapSetInfo>();
+                var statuses = Enum.GetValues<BeatmapOnlineStatus>()
+                                   .Except(new[] { BeatmapOnlineStatus.None }) // make sure a badge is always shown.
+                                   .ToArray();
 
-                for (int i = 1; i <= (count ?? set_count); i++)
+                for (int i = 1; i <= (setCount ?? set_count); i++)
                 {
-                    beatmapSets.Add(randomDifficulties
+                    var set = randomDifficulties
                         ? TestResources.CreateTestBeatmapSetInfo()
-                        : TestResources.CreateTestBeatmapSetInfo(3));
+                        : TestResources.CreateTestBeatmapSetInfo(diffCount ?? diff_count);
+                    set.Status = statuses[RNG.Next(statuses.Length)];
+
+                    beatmapSets.Add(set);
                 }
             }
 
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs
index a470ed47d4..7cd4f06bce 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs
@@ -15,6 +15,7 @@ using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mania;
@@ -188,7 +189,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             AddUntilStep($"displayed bpm is {target}", () =>
             {
-                var label = infoWedge.DisplayedContent.ChildrenOfType<BeatmapInfoWedge.WedgeInfoText.InfoLabel>().Single(l => l.Statistic.Name == "BPM");
+                var label = infoWedge.DisplayedContent.ChildrenOfType<BeatmapInfoWedge.WedgeInfoText.InfoLabel>().Single(l => l.Statistic.Name == BeatmapsetsStrings.ShowStatsBpm);
                 return label.Statistic.Content == target;
             });
         }
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedgeV2.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedgeV2.cs
new file mode 100644
index 0000000000..2a3269ea0a
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedgeV2.cs
@@ -0,0 +1,219 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Legacy;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Screens.Select;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.SongSelect
+{
+    [TestFixture]
+    public partial class TestSceneBeatmapInfoWedgeV2 : OsuTestScene
+    {
+        private RulesetStore rulesets = null!;
+        private TestBeatmapInfoWedgeV2 infoWedge = null!;
+        private readonly List<IBeatmap> beatmaps = new List<IBeatmap>();
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
+        {
+            this.rulesets = rulesets;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AddRange(new Drawable[]
+            {
+                // This exists only to make the wedge more visible in the test scene
+                new Box
+                {
+                    Y = -20,
+                    Colour = Colour4.Cornsilk.Darken(0.2f),
+                    Height = BeatmapInfoWedgeV2.WEDGE_HEIGHT + 40,
+                    Width = 0.65f,
+                    RelativeSizeAxes = Axes.X,
+                    Margin = new MarginPadding { Top = 20, Left = -10 }
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Top = 20 },
+                    Child = infoWedge = new TestBeatmapInfoWedgeV2
+                    {
+                        Width = 0.6f,
+                        RelativeSizeAxes = Axes.X,
+                    },
+                }
+            });
+
+            AddSliderStep("change star difficulty", 0, 11.9, 5.55, v =>
+            {
+                foreach (var hasCurrentValue in infoWedge.ChildrenOfType<IHasCurrentValue<StarDifficulty>>())
+                    hasCurrentValue.Current.Value = new StarDifficulty(v, 0);
+            });
+        }
+
+        [Test]
+        public void TestRulesetChange()
+        {
+            selectBeatmap(Beatmap.Value.Beatmap);
+
+            AddWaitStep("wait for select", 3);
+
+            foreach (var rulesetInfo in rulesets.AvailableRulesets)
+            {
+                var instance = rulesetInfo.CreateInstance();
+                var testBeatmap = createTestBeatmap(rulesetInfo);
+
+                beatmaps.Add(testBeatmap);
+
+                setRuleset(rulesetInfo);
+
+                selectBeatmap(testBeatmap);
+
+                testBeatmapLabels(instance);
+            }
+        }
+
+        [Test]
+        public void TestWedgeVisibility()
+        {
+            AddStep("hide", () => { infoWedge.Hide(); });
+            AddWaitStep("wait for hide", 3);
+            AddAssert("check visibility", () => infoWedge.Alpha == 0);
+            AddStep("show", () => { infoWedge.Show(); });
+            AddWaitStep("wait for show", 1);
+            AddAssert("check visibility", () => infoWedge.Alpha > 0);
+        }
+
+        private void testBeatmapLabels(Ruleset ruleset)
+        {
+            AddAssert("check title", () => infoWedge.Info!.TitleLabel.Current.Value == $"{ruleset.ShortName}Title");
+            AddAssert("check artist", () => infoWedge.Info!.ArtistLabel.Current.Value == $"{ruleset.ShortName}Artist");
+        }
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("reset mods", () => SelectedMods.SetDefault());
+        }
+
+        [Test]
+        public void TestTruncation()
+        {
+            selectBeatmap(createLongMetadata());
+        }
+
+        [Test]
+        public void TestNullBeatmapWithBackground()
+        {
+            selectBeatmap(null);
+            AddAssert("check default title", () => infoWedge.Info!.TitleLabel.Current.Value == Beatmap.Default.BeatmapInfo.Metadata.Title);
+            AddAssert("check default artist", () => infoWedge.Info!.ArtistLabel.Current.Value == Beatmap.Default.BeatmapInfo.Metadata.Artist);
+            AddAssert("check no info labels", () => !infoWedge.Info.ChildrenOfType<BeatmapInfoWedge.WedgeInfoText.InfoLabel>().Any());
+        }
+
+        private void setRuleset(RulesetInfo rulesetInfo)
+        {
+            Container? containerBefore = null;
+
+            AddStep("set ruleset", () =>
+            {
+                // wedge content is only refreshed if the ruleset changes, so only wait for load in that case.
+                if (!rulesetInfo.Equals(Ruleset.Value))
+                    containerBefore = infoWedge.DisplayedContent;
+
+                Ruleset.Value = rulesetInfo;
+            });
+
+            AddUntilStep("wait for async load", () => infoWedge.DisplayedContent != containerBefore);
+        }
+
+        private void selectBeatmap(IBeatmap? b)
+        {
+            Container? containerBefore = null;
+
+            AddStep($"select {b?.Metadata.Title ?? "null"} beatmap", () =>
+            {
+                containerBefore = infoWedge.DisplayedContent;
+                infoWedge.Beatmap = Beatmap.Value = b == null ? Beatmap.Default : CreateWorkingBeatmap(b);
+                infoWedge.Show();
+            });
+
+            AddUntilStep("wait for async load", () => infoWedge.DisplayedContent != containerBefore);
+        }
+
+        private IBeatmap createTestBeatmap(RulesetInfo ruleset)
+        {
+            List<HitObject> objects = new List<HitObject>();
+            for (double i = 0; i < 50000; i += 1000)
+                objects.Add(new TestHitObject { StartTime = i });
+
+            return new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        Author = { Username = $"{ruleset.ShortName}Author" },
+                        Artist = $"{ruleset.ShortName}Artist",
+                        Source = $"{ruleset.ShortName}Source",
+                        Title = $"{ruleset.ShortName}Title"
+                    },
+                    Ruleset = ruleset,
+                    StarRating = 6,
+                    DifficultyName = $"{ruleset.ShortName}Version",
+                    Difficulty = new BeatmapDifficulty()
+                },
+                HitObjects = objects
+            };
+        }
+
+        private IBeatmap createLongMetadata()
+        {
+            return new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        Author = { Username = "WWWWWWWWWWWWWWW" },
+                        Artist = "Verrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrry long Artist",
+                        Source = "Verrrrry long Source",
+                        Title = "Verrrrry long Title"
+                    },
+                    DifficultyName = "Verrrrrrrrrrrrrrrrrrrrrrrrrrrrry long Version",
+                    Status = BeatmapOnlineStatus.Graveyard,
+                },
+            };
+        }
+
+        private partial class TestBeatmapInfoWedgeV2 : BeatmapInfoWedgeV2
+        {
+            public new Container? DisplayedContent => base.DisplayedContent;
+            public new WedgeInfoText? Info => base.Info;
+        }
+
+        private class TestHitObject : ConvertHitObject, IHasPosition
+        {
+            public float X => 0;
+            public float Y => 0;
+            public Vector2 Position { get; } = Vector2.Zero;
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectFooterV2.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectFooterV2.cs
index 72adbfc104..013bad55bc 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectFooterV2.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneSongSelectFooterV2.cs
@@ -6,9 +6,11 @@ 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.Osu;
 using osu.Game.Screens.Select.FooterV2;
 using osuTK.Input;
 
@@ -37,10 +39,10 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             Children = new Drawable[]
             {
-                footer = new FooterV2
+                new PopoverContainer
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre
+                    RelativeSizeAxes = Axes.Both,
+                    Child = footer = new FooterV2(),
                 },
                 overlay = new DummyOverlay()
             };
@@ -56,6 +58,24 @@ namespace osu.Game.Tests.Visual.SongSelect
             overlay.Hide();
         });
 
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("set beatmap", () => Beatmap.Value = CreateWorkingBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo)));
+        }
+
+        [Test]
+        public void TestShowOptions()
+        {
+            AddStep("enable options", () =>
+            {
+                var optionsButton = this.ChildrenOfType<FooterButtonV2>().Last();
+
+                optionsButton.Enabled.Value = true;
+                optionsButton.TriggerClick();
+            });
+        }
+
         [Test]
         public void TestState()
         {
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneUpdateBeatmapSetButton.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneUpdateBeatmapSetButton.cs
index 11d55bc0bd..6d97be730b 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneUpdateBeatmapSetButton.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneUpdateBeatmapSetButton.cs
@@ -15,6 +15,7 @@ using osu.Game.Overlays;
 using osu.Game.Overlays.Dialog;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Carousel;
+using osu.Game.Screens.Select.Filter;
 using osu.Game.Tests.Online;
 using osu.Game.Tests.Resources;
 using osuTK.Input;
@@ -192,6 +193,57 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("release mouse button", () => InputManager.ReleaseButton(MouseButton.Left));
         }
 
+        [Test]
+        public void TestSplitDisplay()
+        {
+            ArchiveDownloadRequest<IBeatmapSetInfo>? downloadRequest = null;
+
+            AddStep("set difficulty sort mode", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Difficulty }));
+            AddStep("update online hash", () =>
+            {
+                testBeatmapSetInfo.Beatmaps.First().OnlineMD5Hash = "different hash";
+                testBeatmapSetInfo.Beatmaps.First().LastOnlineUpdate = DateTimeOffset.Now;
+
+                carousel.UpdateBeatmapSet(testBeatmapSetInfo);
+            });
+
+            AddUntilStep("multiple \"sets\" visible", () => carousel.ChildrenOfType<DrawableCarouselBeatmapSet>().Count(), () => Is.GreaterThan(1));
+            AddUntilStep("update button visible", getUpdateButton, () => Is.Not.Null);
+
+            AddStep("click button", () => getUpdateButton()?.TriggerClick());
+
+            AddUntilStep("wait for download started", () =>
+            {
+                downloadRequest = beatmapDownloader.GetExistingDownload(testBeatmapSetInfo);
+                return downloadRequest != null;
+            });
+
+            AddUntilStep("wait for button disabled", () => getUpdateButton()?.Enabled.Value == false);
+
+            AddUntilStep("progress download to completion", () =>
+            {
+                if (downloadRequest is TestSceneOnlinePlayBeatmapAvailabilityTracker.TestDownloadRequest testRequest)
+                {
+                    testRequest.SetProgress(testRequest.Progress + 0.1f);
+
+                    if (testRequest.Progress >= 1)
+                    {
+                        testRequest.TriggerSuccess();
+
+                        // usually this would be done by the import process.
+                        testBeatmapSetInfo.Beatmaps.First().MD5Hash = "different hash";
+                        testBeatmapSetInfo.Beatmaps.First().LastOnlineUpdate = DateTimeOffset.Now;
+
+                        // usually this would be done by a realm subscription.
+                        carousel.UpdateBeatmapSet(testBeatmapSetInfo);
+                        return true;
+                    }
+                }
+
+                return false;
+            });
+        }
+
         private BeatmapCarousel createCarousel()
         {
             return carousel = new BeatmapCarousel
@@ -199,7 +251,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                 RelativeSizeAxes = Axes.Both,
                 BeatmapSets = new List<BeatmapSetInfo>
                 {
-                    (testBeatmapSetInfo = TestResources.CreateTestBeatmapSetInfo()),
+                    (testBeatmapSetInfo = TestResources.CreateTestBeatmapSetInfo(5)),
                 }
             };
         }
diff --git a/osu.Game.Tournament.Tests/Components/TestSceneSongBar.cs b/osu.Game.Tournament.Tests/Components/TestSceneSongBar.cs
index e0444b6126..95d6b6d107 100644
--- a/osu.Game.Tournament.Tests/Components/TestSceneSongBar.cs
+++ b/osu.Game.Tournament.Tests/Components/TestSceneSongBar.cs
@@ -58,9 +58,14 @@ namespace osu.Game.Tournament.Tests.Components
 
                 songBar.Beatmap = new TournamentBeatmap(beatmap);
             });
+
             AddStep("set mods to HR", () => songBar.Mods = LegacyMods.HardRock);
             AddStep("set mods to DT", () => songBar.Mods = LegacyMods.DoubleTime);
             AddStep("unset mods", () => songBar.Mods = LegacyMods.None);
+
+            AddToggleStep("toggle expanded", expanded => songBar.Expanded = expanded);
+
+            AddStep("set null beatmap", () => songBar.Beatmap = null);
         }
     }
 }
diff --git a/osu.Game.Tournament.Tests/Screens/TestSceneScheduleScreen.cs b/osu.Game.Tournament.Tests/Screens/TestSceneScheduleScreen.cs
index f3c3fdec97..a58f09d13a 100644
--- a/osu.Game.Tournament.Tests/Screens/TestSceneScheduleScreen.cs
+++ b/osu.Game.Tournament.Tests/Screens/TestSceneScheduleScreen.cs
@@ -12,6 +12,13 @@ namespace osu.Game.Tournament.Tests.Screens
 {
     public partial class TestSceneScheduleScreen : TournamentScreenTestScene
     {
+        public override void SetUpSteps()
+        {
+            AddStep("clear matches", () => Ladder.Matches.Clear());
+
+            base.SetUpSteps();
+        }
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -34,6 +41,36 @@ namespace osu.Game.Tournament.Tests.Screens
             AddStep("Set null current match", () => Ladder.CurrentMatch.Value = null);
         }
 
+        [Test]
+        public void TestUpcomingMatches()
+        {
+            AddStep("Add upcoming match", () =>
+            {
+                var tournamentMatch = CreateSampleMatch();
+
+                tournamentMatch.Date.Value = DateTimeOffset.UtcNow.AddMinutes(5);
+                tournamentMatch.Completed.Value = false;
+
+                Ladder.Matches.Add(tournamentMatch);
+            });
+        }
+
+        [Test]
+        public void TestRecentMatches()
+        {
+            AddStep("Add recent match", () =>
+            {
+                var tournamentMatch = CreateSampleMatch();
+
+                tournamentMatch.Date.Value = DateTimeOffset.UtcNow;
+                tournamentMatch.Completed.Value = true;
+                tournamentMatch.Team1Score.Value = tournamentMatch.PointsToWin;
+                tournamentMatch.Team2Score.Value = tournamentMatch.PointsToWin / 2;
+
+                Ladder.Matches.Add(tournamentMatch);
+            });
+        }
+
         private void setMatchDate(TimeSpan relativeTime)
             // Humanizer cannot handle negative timespans.
             => AddStep($"start time is {relativeTime}", () =>
diff --git a/osu.Game.Tournament.Tests/TournamentScreenTestScene.cs b/osu.Game.Tournament.Tests/TournamentScreenTestScene.cs
index 8adffe1468..e8cca00c92 100644
--- a/osu.Game.Tournament.Tests/TournamentScreenTestScene.cs
+++ b/osu.Game.Tournament.Tests/TournamentScreenTestScene.cs
@@ -23,7 +23,7 @@ namespace osu.Game.Tournament.Tests
         {
             public TournamentScalingContainer()
             {
-                TargetDrawSize = new Vector2(1920, 1080);
+                TargetDrawSize = new Vector2(1024, 768);
                 RelativeSizeAxes = Axes.Both;
             }
 
diff --git a/osu.Game.Tournament/IPC/FileBasedIPC.cs b/osu.Game.Tournament/IPC/FileBasedIPC.cs
index bf835122cc..5407c21079 100644
--- a/osu.Game.Tournament/IPC/FileBasedIPC.cs
+++ b/osu.Game.Tournament/IPC/FileBasedIPC.cs
@@ -92,8 +92,16 @@ namespace osu.Game.Tournament.IPC
                                     else
                                     {
                                         beatmapLookupRequest = new GetBeatmapRequest(new APIBeatmap { OnlineID = beatmapId });
-                                        beatmapLookupRequest.Success += b => Beatmap.Value = new TournamentBeatmap(b);
-                                        beatmapLookupRequest.Failure += _ => Beatmap.Value = null;
+                                        beatmapLookupRequest.Success += b =>
+                                        {
+                                            if (lastBeatmapId == beatmapId)
+                                                Beatmap.Value = new TournamentBeatmap(b);
+                                        };
+                                        beatmapLookupRequest.Failure += _ =>
+                                        {
+                                            if (lastBeatmapId == beatmapId)
+                                                Beatmap.Value = null;
+                                        };
                                         API.Queue(beatmapLookupRequest);
                                     }
                                 }
diff --git a/osu.Game.Tournament/SaveChangesOverlay.cs b/osu.Game.Tournament/SaveChangesOverlay.cs
index 7838d4ba48..0b5194a51f 100644
--- a/osu.Game.Tournament/SaveChangesOverlay.cs
+++ b/osu.Game.Tournament/SaveChangesOverlay.cs
@@ -7,13 +7,16 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Online.Multiplayer;
 using osuTK;
 
 namespace osu.Game.Tournament
 {
-    internal partial class SaveChangesOverlay : CompositeDrawable
+    internal partial class SaveChangesOverlay : CompositeDrawable, IKeyBindingHandler<PlatformAction>
     {
         [Resolved]
         private TournamentGame tournamentGame { get; set; } = null!;
@@ -78,6 +81,21 @@ namespace osu.Game.Tournament
             scheduleNextCheck();
         }
 
+        public bool OnPressed(KeyBindingPressEvent<PlatformAction> e)
+        {
+            if (e.Action == PlatformAction.Save && !e.Repeat)
+            {
+                saveChangesButton.TriggerClick();
+                return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(KeyBindingReleaseEvent<PlatformAction> e)
+        {
+        }
+
         private void scheduleNextCheck() => Scheduler.AddDelayed(() => checkForChanges().FireAndForget(), 1000);
 
         private void saveChanges()
diff --git a/osu.Game.Tournament/Screens/Schedule/ScheduleScreen.cs b/osu.Game.Tournament/Screens/Schedule/ScheduleScreen.cs
index 063c231add..d02559d6b7 100644
--- a/osu.Game.Tournament/Screens/Schedule/ScheduleScreen.cs
+++ b/osu.Game.Tournament/Screens/Schedule/ScheduleScreen.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.Allocation;
 using osu.Framework.Bindables;
@@ -19,6 +20,7 @@ namespace osu.Game.Tournament.Screens.Schedule
 {
     public partial class ScheduleScreen : TournamentScreen
     {
+        private readonly BindableList<TournamentMatch> allMatches = new BindableList<TournamentMatch>();
         private readonly Bindable<TournamentMatch?> currentMatch = new Bindable<TournamentMatch?>();
         private Container mainContainer = null!;
         private LadderInfo ladder = null!;
@@ -101,19 +103,34 @@ namespace osu.Game.Tournament.Screens.Schedule
         {
             base.LoadComplete();
 
+            allMatches.BindTo(ladder.Matches);
+            allMatches.BindCollectionChanged((_, _) => refresh());
+
             currentMatch.BindTo(ladder.CurrentMatch);
-            currentMatch.BindValueChanged(matchChanged, true);
+            currentMatch.BindValueChanged(_ => refresh(), true);
         }
 
-        private void matchChanged(ValueChangedEvent<TournamentMatch?> match)
+        private void refresh()
         {
-            var upcoming = ladder.Matches.Where(p => !p.Completed.Value && p.Team1.Value != null && p.Team2.Value != null && Math.Abs(p.Date.Value.DayOfYear - DateTimeOffset.UtcNow.DayOfYear) < 4);
-            var conditionals = ladder
-                               .Matches.Where(p => !p.Completed.Value && (p.Team1.Value == null || p.Team2.Value == null) && Math.Abs(p.Date.Value.DayOfYear - DateTimeOffset.UtcNow.DayOfYear) < 4)
-                               .SelectMany(m => m.ConditionalMatches.Where(cp => m.Acronyms.TrueForAll(a => cp.Acronyms.Contains(a))));
+            const int days_for_displays = 4;
 
-            upcoming = upcoming.Concat(conditionals);
-            upcoming = upcoming.OrderBy(p => p.Date.Value).Take(8);
+            IEnumerable<ConditionalTournamentMatch> conditionals =
+                allMatches
+                    .Where(m => !m.Completed.Value && (m.Team1.Value == null || m.Team2.Value == null) && Math.Abs(m.Date.Value.DayOfYear - DateTimeOffset.UtcNow.DayOfYear) < days_for_displays)
+                    .SelectMany(m => m.ConditionalMatches.Where(cp => m.Acronyms.TrueForAll(a => cp.Acronyms.Contains(a))));
+
+            IEnumerable<TournamentMatch> upcoming =
+                allMatches
+                    .Where(m => !m.Completed.Value && m.Team1.Value != null && m.Team2.Value != null && Math.Abs(m.Date.Value.DayOfYear - DateTimeOffset.UtcNow.DayOfYear) < days_for_displays)
+                    .Concat(conditionals)
+                    .OrderBy(m => m.Date.Value)
+                    .Take(8);
+
+            var recent =
+                allMatches
+                    .Where(m => m.Completed.Value && m.Team1.Value != null && m.Team2.Value != null && Math.Abs(m.Date.Value.DayOfYear - DateTimeOffset.UtcNow.DayOfYear) < days_for_displays)
+                    .OrderByDescending(m => m.Date.Value)
+                    .Take(8);
 
             ScheduleContainer comingUpNext;
 
@@ -137,12 +154,7 @@ namespace osu.Game.Tournament.Screens.Schedule
                                 {
                                     RelativeSizeAxes = Axes.Both,
                                     Width = 0.4f,
-                                    ChildrenEnumerable = ladder.Matches
-                                                               .Where(p => p.Completed.Value && p.Team1.Value != null && p.Team2.Value != null
-                                                                           && Math.Abs(p.Date.Value.DayOfYear - DateTimeOffset.UtcNow.DayOfYear) < 4)
-                                                               .OrderByDescending(p => p.Date.Value)
-                                                               .Take(8)
-                                                               .Select(p => new ScheduleMatch(p))
+                                    ChildrenEnumerable = recent.Select(p => new ScheduleMatch(p))
                                 },
                                 new ScheduleContainer("upcoming matches")
                                 {
@@ -161,7 +173,7 @@ namespace osu.Game.Tournament.Screens.Schedule
                 }
             };
 
-            if (match.NewValue != null)
+            if (currentMatch.Value != null)
             {
                 comingUpNext.Child = new FillFlowContainer
                 {
@@ -170,12 +182,12 @@ namespace osu.Game.Tournament.Screens.Schedule
                     Spacing = new Vector2(30),
                     Children = new Drawable[]
                     {
-                        new ScheduleMatch(match.NewValue, false)
+                        new ScheduleMatch(currentMatch.Value, false)
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
                         },
-                        new TournamentSpriteTextWithBackground(match.NewValue.Round.Value?.Name.Value ?? string.Empty)
+                        new TournamentSpriteTextWithBackground(currentMatch.Value.Round.Value?.Name.Value ?? string.Empty)
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
@@ -185,7 +197,7 @@ namespace osu.Game.Tournament.Screens.Schedule
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
-                            Text = match.NewValue.Team1.Value?.FullName + " vs " + match.NewValue.Team2.Value?.FullName,
+                            Text = currentMatch.Value.Team1.Value?.FullName + " vs " + currentMatch.Value.Team2.Value?.FullName,
                             Font = OsuFont.Torus.With(size: 24, weight: FontWeight.SemiBold)
                         },
                         new FillFlowContainer
@@ -196,7 +208,7 @@ namespace osu.Game.Tournament.Screens.Schedule
                             Origin = Anchor.CentreLeft,
                             Children = new Drawable[]
                             {
-                                new ScheduleMatchDate(match.NewValue.Date.Value)
+                                new ScheduleMatchDate(currentMatch.Value.Date.Value)
                                 {
                                     Font = OsuFont.Torus.With(size: 24, weight: FontWeight.Regular)
                                 }
@@ -282,6 +294,7 @@ namespace osu.Game.Tournament.Screens.Schedule
                             {
                                 Direction = FillDirection.Vertical,
                                 RelativeSizeAxes = Axes.Both,
+                                Spacing = new Vector2(0, -6),
                                 Margin = new MarginPadding(10)
                             },
                         }
diff --git a/osu.Game.Tournament/TournamentGame.cs b/osu.Game.Tournament/TournamentGame.cs
index ba3b17b513..25dc8ae1e5 100644
--- a/osu.Game.Tournament/TournamentGame.cs
+++ b/osu.Game.Tournament/TournamentGame.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.Drawing;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -48,8 +47,6 @@ namespace osu.Game.Tournament
         {
             frameworkConfig.BindWith(FrameworkSetting.WindowedSize, windowSize);
 
-            windowSize.MinValue = new Size(TournamentSceneManager.REQUIRED_WIDTH, TournamentSceneManager.STREAM_AREA_HEIGHT);
-
             windowMode = frameworkConfig.GetBindable<WindowMode>(FrameworkSetting.WindowMode);
 
             Add(loadingSpinner = new LoadingSpinner(true, true)
diff --git a/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs b/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs
index c353b9e904..f18355505a 100644
--- a/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs
+++ b/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs
@@ -19,6 +19,8 @@ namespace osu.Game.Beatmaps.Drawables
 {
     public partial class BeatmapSetOnlineStatusPill : CircularContainer, IHasTooltip
     {
+        private const double animation_duration = 400;
+
         private BeatmapOnlineStatus status;
 
         public BeatmapOnlineStatus Status
@@ -32,7 +34,12 @@ namespace osu.Game.Beatmaps.Drawables
                 status = value;
 
                 if (IsLoaded)
+                {
+                    AutoSizeDuration = (float)animation_duration;
+                    AutoSizeEasing = Easing.OutQuint;
+
                     updateState();
+                }
             }
         }
 
@@ -61,6 +68,8 @@ namespace osu.Game.Beatmaps.Drawables
         {
             Masking = true;
 
+            Alpha = 0;
+
             Children = new Drawable[]
             {
                 background = new Box
@@ -83,21 +92,32 @@ namespace osu.Game.Beatmaps.Drawables
         protected override void LoadComplete()
         {
             base.LoadComplete();
+
             updateState();
+            FinishTransforms(true);
         }
 
         private void updateState()
         {
-            Alpha = Status == BeatmapOnlineStatus.None ? 0 : 1;
+            if (Status == BeatmapOnlineStatus.None)
+            {
+                this.FadeOut(animation_duration, Easing.OutQuint);
+                return;
+            }
 
-            statusText.Text = Status.GetLocalisableDescription().ToUpper();
+            this.FadeIn(animation_duration, Easing.OutQuint);
+
+            Color4 statusTextColour;
 
             if (colourProvider != null)
-                statusText.Colour = status == BeatmapOnlineStatus.Graveyard ? colourProvider.Background1 : colourProvider.Background3;
+                statusTextColour = status == BeatmapOnlineStatus.Graveyard ? colourProvider.Background1 : colourProvider.Background3;
             else
-                statusText.Colour = status == BeatmapOnlineStatus.Graveyard ? colours.GreySeaFoamLight : Color4.Black;
+                statusTextColour = status == BeatmapOnlineStatus.Graveyard ? colours.GreySeaFoamLight : Color4.Black;
 
-            background.Colour = OsuColour.ForBeatmapSetOnlineStatus(Status) ?? colourProvider?.Light1 ?? colours.GreySeaFoamLighter;
+            statusText.FadeColour(statusTextColour, animation_duration, Easing.OutQuint);
+            background.FadeColour(OsuColour.ForBeatmapSetOnlineStatus(Status) ?? colourProvider?.Light1 ?? colours.GreySeaFoamLighter, animation_duration, Easing.OutQuint);
+
+            statusText.Text = Status.GetLocalisableDescription().ToUpper();
         }
 
         public LocalisableString TooltipText
diff --git a/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs b/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs
index 5da51f6c8e..7c375b7604 100644
--- a/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs
@@ -111,7 +111,7 @@ namespace osu.Game.Beatmaps.Formats
             }
 
             if (hitObject is IHasSliderVelocity hasSliderVelocity)
-                hasSliderVelocity.SliderVelocity = difficultyControlPoint.SliderVelocity;
+                hasSliderVelocity.SliderVelocityMultiplier = difficultyControlPoint.SliderVelocity;
 
             hitObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.Difficulty);
         }
diff --git a/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs b/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
index fc9de13c89..4f8e935ee4 100644
--- a/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
@@ -269,7 +269,7 @@ namespace osu.Game.Beatmaps.Formats
                 foreach (var hitObject in hitObjects)
                 {
                     if (hitObject is IHasSliderVelocity hasSliderVelocity)
-                        yield return new DifficultyControlPoint { Time = hitObject.StartTime, SliderVelocity = hasSliderVelocity.SliderVelocity };
+                        yield return new DifficultyControlPoint { Time = hitObject.StartTime, SliderVelocity = hasSliderVelocity.SliderVelocityMultiplier };
                 }
             }
 
diff --git a/osu.Game/Graphics/Containers/LinkFlowContainer.cs b/osu.Game/Graphics/Containers/LinkFlowContainer.cs
index 2d27ce906b..40e883f8ac 100644
--- a/osu.Game/Graphics/Containers/LinkFlowContainer.cs
+++ b/osu.Game/Graphics/Containers/LinkFlowContainer.cs
@@ -15,6 +15,7 @@ using osu.Framework.Localisation;
 using osu.Framework.Platform;
 using osu.Game.Online;
 using osu.Game.Users;
+using osu.Game.Localisation;
 
 namespace osu.Game.Graphics.Containers
 {
@@ -74,7 +75,7 @@ namespace osu.Game.Graphics.Containers
         }
 
         public void AddUserLink(IUser user, Action<SpriteText> creationParameters = null)
-            => createLink(CreateChunkFor(user.Username, true, CreateSpriteText, creationParameters), new LinkDetails(LinkAction.OpenUserProfile, user), "view profile");
+            => createLink(CreateChunkFor(user.Username, true, CreateSpriteText, creationParameters), new LinkDetails(LinkAction.OpenUserProfile, user), ContextMenuStrings.ViewProfile);
 
         private void createLink(ITextPart textPart, LinkDetails link, LocalisableString tooltipText, Action action = null)
         {
diff --git a/osu.Game/Graphics/UserInterface/StarCounter.cs b/osu.Game/Graphics/UserInterface/StarCounter.cs
index 82f6f8e0a4..fe986b275e 100644
--- a/osu.Game/Graphics/UserInterface/StarCounter.cs
+++ b/osu.Game/Graphics/UserInterface/StarCounter.cs
@@ -30,6 +30,11 @@ namespace osu.Game.Graphics.UserInterface
 
         private const float star_spacing = 4;
 
+        public virtual FillDirection Direction
+        {
+            set => stars.Direction = value;
+        }
+
         private float current;
 
         /// <summary>
@@ -64,7 +69,6 @@ namespace osu.Game.Graphics.UserInterface
                 stars = new FillFlowContainer<Star>
                 {
                     AutoSizeAxes = Axes.Both,
-                    Direction = FillDirection.Horizontal,
                     Spacing = new Vector2(star_spacing),
                     ChildrenEnumerable = Enumerable.Range(0, StarCount).Select(_ => CreateStar())
                 }
diff --git a/osu.Game/Localisation/CommonStrings.cs b/osu.Game/Localisation/CommonStrings.cs
index 480d68619d..2c377a81d9 100644
--- a/osu.Game/Localisation/CommonStrings.cs
+++ b/osu.Game/Localisation/CommonStrings.cs
@@ -169,6 +169,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString RevertToDefault => new TranslatableString(getKey(@"revert_to_default"), @"Revert to default");
 
+        /// <summary>
+        /// "General"
+        /// </summary>
+        public static LocalisableString General => new TranslatableString(getKey(@"general"), @"General");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/DebugSettingsStrings.cs b/osu.Game/Localisation/DebugSettingsStrings.cs
index dd21739096..18fd3e83da 100644
--- a/osu.Game/Localisation/DebugSettingsStrings.cs
+++ b/osu.Game/Localisation/DebugSettingsStrings.cs
@@ -14,11 +14,6 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString DebugSectionHeader => new TranslatableString(getKey(@"debug_section_header"), @"Debug");
 
-        /// <summary>
-        /// "General"
-        /// </summary>
-        public static LocalisableString GeneralHeader => new TranslatableString(getKey(@"general_header"), @"General");
-
         /// <summary>
         /// "Show log overlay"
         /// </summary>
diff --git a/osu.Game/Localisation/GameplaySettingsStrings.cs b/osu.Game/Localisation/GameplaySettingsStrings.cs
index f52f6abb89..8ee76fdd55 100644
--- a/osu.Game/Localisation/GameplaySettingsStrings.cs
+++ b/osu.Game/Localisation/GameplaySettingsStrings.cs
@@ -19,11 +19,6 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString BeatmapHeader => new TranslatableString(getKey(@"beatmap_header"), @"Beatmap");
 
-        /// <summary>
-        /// "General"
-        /// </summary>
-        public static LocalisableString GeneralHeader => new TranslatableString(getKey(@"general_header"), @"General");
-
         /// <summary>
         /// "Audio"
         /// </summary>
diff --git a/osu.Game/Localisation/GeneralSettingsStrings.cs b/osu.Game/Localisation/GeneralSettingsStrings.cs
index a525af508b..ebf57d8109 100644
--- a/osu.Game/Localisation/GeneralSettingsStrings.cs
+++ b/osu.Game/Localisation/GeneralSettingsStrings.cs
@@ -9,11 +9,6 @@ namespace osu.Game.Localisation
     {
         private const string prefix = @"osu.Game.Resources.Localisation.GeneralSettings";
 
-        /// <summary>
-        /// "General"
-        /// </summary>
-        public static LocalisableString GeneralSectionHeader => new TranslatableString(getKey(@"general_section_header"), @"General");
-
         /// <summary>
         /// "Language"
         /// </summary>
diff --git a/osu.Game/Localisation/SongSelectStrings.cs b/osu.Game/Localisation/SongSelectStrings.cs
index e1ac328420..e715ba8880 100644
--- a/osu.Game/Localisation/SongSelectStrings.cs
+++ b/osu.Game/Localisation/SongSelectStrings.cs
@@ -19,6 +19,41 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString LocallyModifiedTooltip => new TranslatableString(getKey(@"locally_modified_tooltip"), @"Has been locally modified");
 
+        /// <summary>
+        /// "Manage collections"
+        /// </summary>
+        public static LocalisableString ManageCollections => new TranslatableString(getKey(@"manage_collections"), @"Manage collections");
+
+        /// <summary>
+        /// "For all difficulties"
+        /// </summary>
+        public static LocalisableString ForAllDifficulties => new TranslatableString(getKey(@"for_all_difficulties"), @"For all difficulties");
+
+        /// <summary>
+        /// "Delete beatmap"
+        /// </summary>
+        public static LocalisableString DeleteBeatmap => new TranslatableString(getKey(@"delete_beatmap"), @"Delete beatmap");
+
+        /// <summary>
+        /// "For selected difficulty"
+        /// </summary>
+        public static LocalisableString ForSelectedDifficulty => new TranslatableString(getKey(@"for_selected_difficulty"), @"For selected difficulty");
+
+        /// <summary>
+        /// "Mark as played"
+        /// </summary>
+        public static LocalisableString MarkAsPlayed => new TranslatableString(getKey(@"mark_as_played"), @"Mark as played");
+
+        /// <summary>
+        /// "Clear all local scores"
+        /// </summary>
+        public static LocalisableString ClearAllLocalScores => new TranslatableString(getKey(@"clear_all_local_scores"), @"Clear all local scores");
+
+        /// <summary>
+        /// "Edit beatmap"
+        /// </summary>
+        public static LocalisableString EditBeatmap => new TranslatableString(getKey(@"edit_beatmap"), @"Edit beatmap");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/UserInterfaceStrings.cs b/osu.Game/Localisation/UserInterfaceStrings.cs
index ea664d7b50..612668171c 100644
--- a/osu.Game/Localisation/UserInterfaceStrings.cs
+++ b/osu.Game/Localisation/UserInterfaceStrings.cs
@@ -14,11 +14,6 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString UserInterfaceSectionHeader => new TranslatableString(getKey(@"user_interface_section_header"), @"User Interface");
 
-        /// <summary>
-        /// "General"
-        /// </summary>
-        public static LocalisableString GeneralHeader => new TranslatableString(getKey(@"general_header"), @"General");
-
         /// <summary>
         /// "Rotate cursor when dragging"
         /// </summary>
diff --git a/osu.Game/Online/API/Requests/DownloadReplayRequest.cs b/osu.Game/Online/API/Requests/DownloadReplayRequest.cs
index 77174f0bb5..3ea57cf637 100644
--- a/osu.Game/Online/API/Requests/DownloadReplayRequest.cs
+++ b/osu.Game/Online/API/Requests/DownloadReplayRequest.cs
@@ -14,6 +14,6 @@ namespace osu.Game.Online.API.Requests
 
         protected override string FileExtension => ".osr";
 
-        protected override string Target => $@"scores/{Model.Ruleset.ShortName}/{Model.OnlineID}/download";
+        protected override string Target => $@"scores/{Model.OnlineID}/download";
     }
 }
diff --git a/osu.Game/Online/DevelopmentEndpointConfiguration.cs b/osu.Game/Online/DevelopmentEndpointConfiguration.cs
index 69276f452a..5f3c353f4d 100644
--- a/osu.Game/Online/DevelopmentEndpointConfiguration.cs
+++ b/osu.Game/Online/DevelopmentEndpointConfiguration.cs
@@ -10,9 +10,9 @@ namespace osu.Game.Online
             WebsiteRootUrl = APIEndpointUrl = @"https://dev.ppy.sh";
             APIClientSecret = @"3LP2mhUrV89xxzD1YKNndXHEhWWCRLPNKioZ9ymT";
             APIClientID = "5";
-            SpectatorEndpointUrl = $"{APIEndpointUrl}/spectator";
-            MultiplayerEndpointUrl = $"{APIEndpointUrl}/multiplayer";
-            MetadataEndpointUrl = $"{APIEndpointUrl}/metadata";
+            SpectatorEndpointUrl = $@"{APIEndpointUrl}/signalr/spectator";
+            MultiplayerEndpointUrl = $@"{APIEndpointUrl}/signalr/multiplayer";
+            MetadataEndpointUrl = $@"{APIEndpointUrl}/signalr/metadata";
         }
     }
 }
diff --git a/osu.Game/Overlays/OSD/CopyUrlToast.cs b/osu.Game/Overlays/OSD/CopyUrlToast.cs
index ce5a5f56c4..2c5a9179f2 100644
--- a/osu.Game/Overlays/OSD/CopyUrlToast.cs
+++ b/osu.Game/Overlays/OSD/CopyUrlToast.cs
@@ -8,7 +8,7 @@ namespace osu.Game.Overlays.OSD
     public partial class CopyUrlToast : Toast
     {
         public CopyUrlToast()
-            : base(UserInterfaceStrings.GeneralHeader, ToastStrings.UrlCopied, "")
+            : base(CommonStrings.General, ToastStrings.UrlCopied, "")
         {
         }
     }
diff --git a/osu.Game/Overlays/Profile/Header/BadgeHeaderContainer.cs b/osu.Game/Overlays/Profile/Header/BadgeHeaderContainer.cs
index 24be6ce2f5..af9ec32421 100644
--- a/osu.Game/Overlays/Profile/Header/BadgeHeaderContainer.cs
+++ b/osu.Game/Overlays/Profile/Header/BadgeHeaderContainer.cs
@@ -32,7 +32,7 @@ namespace osu.Game.Overlays.Profile.Header
                 new Box
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Colour = colourProvider.Background5,
+                    Colour = colourProvider.Background4,
                 },
                 new Container // artificial shadow
                 {
@@ -50,7 +50,7 @@ namespace osu.Game.Overlays.Profile.Header
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
                     Spacing = new Vector2(10, 10),
-                    Padding = new MarginPadding { Horizontal = WaveOverlayContainer.HORIZONTAL_PADDING, Top = 10 },
+                    Padding = new MarginPadding { Horizontal = WaveOverlayContainer.HORIZONTAL_PADDING, Vertical = 10 },
                 }
             };
         }
diff --git a/osu.Game/Overlays/Profile/Header/TopHeaderContainer.cs b/osu.Game/Overlays/Profile/Header/TopHeaderContainer.cs
index de678cb5d1..dc47ce6e30 100644
--- a/osu.Game/Overlays/Profile/Header/TopHeaderContainer.cs
+++ b/osu.Game/Overlays/Profile/Header/TopHeaderContainer.cs
@@ -64,7 +64,7 @@ namespace osu.Game.Overlays.Profile.Header
                 new Box
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Colour = colourProvider.Background4,
+                    Colour = colourProvider.Background3,
                 },
                 new FillFlowContainer
                 {
diff --git a/osu.Game/Overlays/Settings/Sections/DebugSettings/GeneralSettings.cs b/osu.Game/Overlays/Settings/Sections/DebugSettings/GeneralSettings.cs
index cf97743fde..049ccedf37 100644
--- a/osu.Game/Overlays/Settings/Sections/DebugSettings/GeneralSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/DebugSettings/GeneralSettings.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Overlays.Settings.Sections.DebugSettings
 {
     public partial class GeneralSettings : SettingsSubsection
     {
-        protected override LocalisableString Header => DebugSettingsStrings.GeneralHeader;
+        protected override LocalisableString Header => CommonStrings.General;
 
         [BackgroundDependencyLoader]
         private void load(FrameworkDebugConfigManager config, FrameworkConfigManager frameworkConfig, IPerformFromScreenRunner? performer)
diff --git a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
index c7f5aa5665..83e9140b33 100644
--- a/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs
@@ -12,7 +12,7 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
 {
     public partial class GeneralSettings : SettingsSubsection
     {
-        protected override LocalisableString Header => GameplaySettingsStrings.GeneralHeader;
+        protected override LocalisableString Header => CommonStrings.General;
 
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
diff --git a/osu.Game/Overlays/Settings/Sections/GeneralSection.cs b/osu.Game/Overlays/Settings/Sections/GeneralSection.cs
index f4a79d65e6..2b043d40bc 100644
--- a/osu.Game/Overlays/Settings/Sections/GeneralSection.cs
+++ b/osu.Game/Overlays/Settings/Sections/GeneralSection.cs
@@ -19,7 +19,7 @@ namespace osu.Game.Overlays.Settings.Sections
         [Resolved(CanBeNull = true)]
         private OsuGame? game { get; set; }
 
-        public override LocalisableString Header => GeneralSettingsStrings.GeneralSectionHeader;
+        public override LocalisableString Header => CommonStrings.General;
 
         public override Drawable CreateIcon() => new SpriteIcon
         {
diff --git a/osu.Game/Overlays/Settings/Sections/UserInterface/GeneralSettings.cs b/osu.Game/Overlays/Settings/Sections/UserInterface/GeneralSettings.cs
index 844b8aeac6..3f39980b43 100644
--- a/osu.Game/Overlays/Settings/Sections/UserInterface/GeneralSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/UserInterface/GeneralSettings.cs
@@ -12,7 +12,7 @@ namespace osu.Game.Overlays.Settings.Sections.UserInterface
 {
     public partial class GeneralSettings : SettingsSubsection
     {
-        protected override LocalisableString Header => UserInterfaceStrings.GeneralHeader;
+        protected override LocalisableString Header => CommonStrings.General;
 
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
diff --git a/osu.Game/Overlays/SkinEditor/SkinSelectionHandler.cs b/osu.Game/Overlays/SkinEditor/SkinSelectionHandler.cs
index 72216f040e..94cf60a422 100644
--- a/osu.Game/Overlays/SkinEditor/SkinSelectionHandler.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinSelectionHandler.cs
@@ -47,10 +47,7 @@ namespace osu.Game.Overlays.SkinEditor
 
             // copy to mutate, as we will need to compare to the original later on.
             var adjustedRect = selectionRect;
-
-            // first, remove any scale axis we are not interested in.
-            if (anchor.HasFlagFast(Anchor.x1)) scale.X = 0;
-            if (anchor.HasFlagFast(Anchor.y1)) scale.Y = 0;
+            bool isRotated = false;
 
             // for now aspect lock scale adjustments that occur at corners..
             if (!anchor.HasFlagFast(Anchor.x1) && !anchor.HasFlagFast(Anchor.y1))
@@ -61,8 +58,9 @@ namespace osu.Game.Overlays.SkinEditor
             }
             // ..or if any of the selection have been rotated.
             // this is to avoid requiring skew logic (which would likely not be the user's expected transform anyway).
-            else if (SelectedBlueprints.Any(b => !Precision.AlmostEquals(((Drawable)b.Item).Rotation, 0)))
+            else if (SelectedBlueprints.Any(b => !Precision.AlmostEquals(((Drawable)b.Item).Rotation % 90, 0)))
             {
+                isRotated = true;
                 if (anchor.HasFlagFast(Anchor.x1))
                     // if dragging from the horizontal centre, only a vertical component is available.
                     scale.X = scale.Y / selectionRect.Height * selectionRect.Width;
@@ -74,13 +72,28 @@ namespace osu.Game.Overlays.SkinEditor
             if (anchor.HasFlagFast(Anchor.x0)) adjustedRect.X -= scale.X;
             if (anchor.HasFlagFast(Anchor.y0)) adjustedRect.Y -= scale.Y;
 
+            // Maintain the selection's centre position if dragging from the centre anchors and selection is rotated.
+            if (isRotated && anchor.HasFlagFast(Anchor.x1)) adjustedRect.X -= scale.X / 2;
+            if (isRotated && anchor.HasFlagFast(Anchor.y1)) adjustedRect.Y -= scale.Y / 2;
+
             adjustedRect.Width += scale.X;
             adjustedRect.Height += scale.Y;
 
+            if (adjustedRect.Width <= 0 || adjustedRect.Height <= 0)
+            {
+                Axes toFlip = Axes.None;
+
+                if (adjustedRect.Width <= 0) toFlip |= Axes.X;
+                if (adjustedRect.Height <= 0) toFlip |= Axes.Y;
+
+                SelectionBox.PerformFlipFromScaleHandles(toFlip);
+                return true;
+            }
+
             // scale adjust applied to each individual item should match that of the quad itself.
             var scaledDelta = new Vector2(
-                MathF.Max(adjustedRect.Width / selectionRect.Width, 0),
-                MathF.Max(adjustedRect.Height / selectionRect.Height, 0)
+                adjustedRect.Width / selectionRect.Width,
+                adjustedRect.Height / selectionRect.Height
             );
 
             foreach (var b in SelectedBlueprints)
@@ -102,7 +115,12 @@ namespace osu.Game.Overlays.SkinEditor
                 );
 
                 updateDrawablePosition(drawableItem, newPositionInAdjusted);
-                drawableItem.Scale *= scaledDelta;
+
+                var currentScaledDelta = scaledDelta;
+                if (Precision.AlmostEquals(MathF.Abs(drawableItem.Rotation) % 180, 90))
+                    currentScaledDelta = new Vector2(scaledDelta.Y, scaledDelta.X);
+
+                drawableItem.Scale *= currentScaledDelta;
             }
 
             return true;
@@ -291,7 +309,7 @@ namespace osu.Game.Overlays.SkinEditor
             if (parent == null)
                 return drawable.Anchor;
 
-            var screenPosition = getScreenPosition();
+            var screenPosition = drawable.ToScreenSpace(drawable.OriginPosition);
 
             var absolutePosition = parent.ToLocalSpace(screenPosition);
             var factor = parent.RelativeToAbsoluteFactor;
@@ -313,26 +331,6 @@ namespace osu.Game.Overlays.SkinEditor
             result |= getAnchorFromPosition(absolutePosition.Y / factor.Y, Anchor.y0, Anchor.y1, Anchor.y2);
 
             return result;
-
-            Vector2 getScreenPosition()
-            {
-                var quad = drawable.ScreenSpaceDrawQuad;
-                var origin = drawable.Origin;
-
-                var pos = quad.TopLeft;
-
-                if (origin.HasFlagFast(Anchor.x2))
-                    pos.X += quad.Width;
-                else if (origin.HasFlagFast(Anchor.x1))
-                    pos.X += quad.Width / 2f;
-
-                if (origin.HasFlagFast(Anchor.y2))
-                    pos.Y += quad.Height;
-                else if (origin.HasFlagFast(Anchor.y1))
-                    pos.Y += quad.Height / 2f;
-
-                return pos;
-            }
         }
 
         private static void applyAnchor(Drawable drawable, Anchor anchor)
diff --git a/osu.Game/Rulesets/Edit/DistancedHitObjectComposer.cs b/osu.Game/Rulesets/Edit/DistancedHitObjectComposer.cs
index 817e8bd5fe..e08cb41a26 100644
--- a/osu.Game/Rulesets/Edit/DistancedHitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/DistancedHitObjectComposer.cs
@@ -244,7 +244,7 @@ namespace osu.Game.Rulesets.Edit
 
         public virtual float GetBeatSnapDistanceAt(HitObject referenceObject, bool useReferenceSliderVelocity = true)
         {
-            return (float)(100 * (useReferenceSliderVelocity && referenceObject is IHasSliderVelocity hasSliderVelocity ? hasSliderVelocity.SliderVelocity : 1) * EditorBeatmap.Difficulty.SliderMultiplier * 1
+            return (float)(100 * (useReferenceSliderVelocity && referenceObject is IHasSliderVelocity hasSliderVelocity ? hasSliderVelocity.SliderVelocityMultiplier : 1) * EditorBeatmap.Difficulty.SliderMultiplier * 1
                            / BeatSnapProvider.BeatDivisor);
         }
 
diff --git a/osu.Game/Rulesets/Mods/DifficultyAdjustSettingsControl.cs b/osu.Game/Rulesets/Mods/DifficultyAdjustSettingsControl.cs
index a941c0a1db..d04d7636ec 100644
--- a/osu.Game/Rulesets/Mods/DifficultyAdjustSettingsControl.cs
+++ b/osu.Game/Rulesets/Mods/DifficultyAdjustSettingsControl.cs
@@ -29,7 +29,14 @@ namespace osu.Game.Rulesets.Mods
         /// </remarks>
         private readonly BindableNumber<float> sliderDisplayCurrent = new BindableNumber<float>();
 
-        protected override Drawable CreateControl() => new SliderControl(sliderDisplayCurrent);
+        protected sealed override Drawable CreateControl() => new SliderControl(sliderDisplayCurrent, CreateSlider);
+
+        protected virtual RoundedSliderBar<float> CreateSlider(BindableNumber<float> current) => new RoundedSliderBar<float>
+        {
+            RelativeSizeAxes = Axes.X,
+            Current = current,
+            KeyboardStep = 0.1f,
+        };
 
         /// <summary>
         /// Guards against beatmap values displayed on slider bars being transferred to user override.
@@ -100,16 +107,11 @@ namespace osu.Game.Rulesets.Mods
                 set => current.Current = value;
             }
 
-            public SliderControl(BindableNumber<float> currentNumber)
+            public SliderControl(BindableNumber<float> currentNumber, Func<BindableNumber<float>, RoundedSliderBar<float>> createSlider)
             {
                 InternalChildren = new Drawable[]
                 {
-                    new RoundedSliderBar<float>
-                    {
-                        RelativeSizeAxes = Axes.X,
-                        Current = currentNumber,
-                        KeyboardStep = 0.1f,
-                    }
+                    createSlider(currentNumber)
                 };
 
                 AutoSizeAxes = Axes.Y;
diff --git a/osu.Game/Rulesets/Mods/DifficultyBindable.cs b/osu.Game/Rulesets/Mods/DifficultyBindable.cs
index c21ce756c9..a207048882 100644
--- a/osu.Game/Rulesets/Mods/DifficultyBindable.cs
+++ b/osu.Game/Rulesets/Mods/DifficultyBindable.cs
@@ -34,9 +34,18 @@ namespace osu.Game.Rulesets.Mods
             set => CurrentNumber.Precision = value;
         }
 
+        private float minValue;
+
         public float MinValue
         {
-            set => CurrentNumber.MinValue = value;
+            set
+            {
+                if (value == minValue)
+                    return;
+
+                minValue = value;
+                updateExtents();
+            }
         }
 
         private float maxValue;
@@ -49,7 +58,24 @@ namespace osu.Game.Rulesets.Mods
                     return;
 
                 maxValue = value;
-                updateMaxValue();
+                updateExtents();
+            }
+        }
+
+        private float? extendedMinValue;
+
+        /// <summary>
+        /// The minimum value to be used when extended limits are applied.
+        /// </summary>
+        public float? ExtendedMinValue
+        {
+            set
+            {
+                if (value == extendedMinValue)
+                    return;
+
+                extendedMinValue = value;
+                updateExtents();
             }
         }
 
@@ -66,7 +92,7 @@ namespace osu.Game.Rulesets.Mods
                     return;
 
                 extendedMaxValue = value;
-                updateMaxValue();
+                updateExtents();
             }
         }
 
@@ -78,7 +104,7 @@ namespace osu.Game.Rulesets.Mods
         public DifficultyBindable(float? defaultValue = null)
             : base(defaultValue)
         {
-            ExtendedLimits.BindValueChanged(_ => updateMaxValue());
+            ExtendedLimits.BindValueChanged(_ => updateExtents());
         }
 
         public override float? Value
@@ -94,8 +120,9 @@ namespace osu.Game.Rulesets.Mods
             }
         }
 
-        private void updateMaxValue()
+        private void updateExtents()
         {
+            CurrentNumber.MinValue = ExtendedLimits.Value && extendedMinValue != null ? extendedMinValue.Value : minValue;
             CurrentNumber.MaxValue = ExtendedLimits.Value && extendedMaxValue != null ? extendedMaxValue.Value : maxValue;
         }
 
diff --git a/osu.Game/Rulesets/Mods/ModExtensions.cs b/osu.Game/Rulesets/Mods/ModExtensions.cs
index b22030414b..aa106f1203 100644
--- a/osu.Game/Rulesets/Mods/ModExtensions.cs
+++ b/osu.Game/Rulesets/Mods/ModExtensions.cs
@@ -21,8 +21,9 @@ namespace osu.Game.Rulesets.Mods
                 {
                     User = new APIUser
                     {
-                        Id = APIUser.SYSTEM_USER_ID,
+                        Id = replayData.User.OnlineID,
                         Username = replayData.User.Username,
+                        IsBot = replayData.User.IsBot,
                     }
                 }
             };
diff --git a/osu.Game/Rulesets/Mods/ModScoreV2.cs b/osu.Game/Rulesets/Mods/ModScoreV2.cs
index 6d56b2d86f..df83d96769 100644
--- a/osu.Game/Rulesets/Mods/ModScoreV2.cs
+++ b/osu.Game/Rulesets/Mods/ModScoreV2.cs
@@ -16,5 +16,6 @@ namespace osu.Game.Rulesets.Mods
         public override ModType Type => ModType.System;
         public override LocalisableString Description => "Score set on earlier osu! versions with the V2 scoring algorithm active.";
         public override double ScoreMultiplier => 1;
+        public override bool UserPlayable => false;
     }
 }
diff --git a/osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs b/osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs
index 7ddd372dc9..d91ecf956a 100644
--- a/osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs
@@ -41,12 +41,12 @@ namespace osu.Game.Rulesets.Objects.Legacy
 
         public double Velocity = 1;
 
-        public BindableNumber<double> SliderVelocityBindable { get; } = new BindableDouble(1);
+        public BindableNumber<double> SliderVelocityMultiplierBindable { get; } = new BindableDouble(1);
 
-        public double SliderVelocity
+        public double SliderVelocityMultiplier
         {
-            get => SliderVelocityBindable.Value;
-            set => SliderVelocityBindable.Value = value;
+            get => SliderVelocityMultiplierBindable.Value;
+            set => SliderVelocityMultiplierBindable.Value = value;
         }
 
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, IBeatmapDifficultyInfo difficulty)
@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
 
-            double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier * SliderVelocity;
+            double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier * SliderVelocityMultiplier;
 
             Velocity = scoringDistance / timingPoint.BeatLength;
         }
diff --git a/osu.Game/Rulesets/Objects/Types/IHasSliderVelocity.cs b/osu.Game/Rulesets/Objects/Types/IHasSliderVelocity.cs
index 80fd8dd8dc..e665dcc752 100644
--- a/osu.Game/Rulesets/Objects/Types/IHasSliderVelocity.cs
+++ b/osu.Game/Rulesets/Objects/Types/IHasSliderVelocity.cs
@@ -13,8 +13,8 @@ namespace osu.Game.Rulesets.Objects.Types
         /// <summary>
         /// The slider velocity multiplier.
         /// </summary>
-        double SliderVelocity { get; set; }
+        double SliderVelocityMultiplier { get; set; }
 
-        BindableNumber<double> SliderVelocityBindable { get; }
+        BindableNumber<double> SliderVelocityMultiplierBindable { get; }
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/HitObjectInspector.cs b/osu.Game/Screens/Edit/Compose/Components/HitObjectInspector.cs
index 7beaf7d086..ac339dc9d9 100644
--- a/osu.Game/Screens/Edit/Compose/Components/HitObjectInspector.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/HitObjectInspector.cs
@@ -73,7 +73,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
                     if (selected is IHasSliderVelocity sliderVelocity)
                     {
                         AddHeader("Slider Velocity");
-                        AddValue($"{sliderVelocity.SliderVelocity:#,0.00}x ({sliderVelocity.SliderVelocity * EditorBeatmap.Difficulty.SliderMultiplier:#,0.00}x)");
+                        AddValue($"{sliderVelocity.SliderVelocityMultiplier:#,0.00}x ({sliderVelocity.SliderVelocityMultiplier * EditorBeatmap.Difficulty.SliderMultiplier:#,0.00}x)");
                     }
 
                     if (selected is IHasRepeats repeats)
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs
index 876e8ccbe9..0c19f6c62e 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBox.cs
@@ -4,6 +4,7 @@
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -307,6 +308,25 @@ namespace osu.Game.Screens.Edit.Compose.Components
             return button;
         }
 
+        /// <remarks>
+        /// This method should be called when a selection needs to be flipped
+        /// because of an ongoing scale handle drag that would otherwise cause width or height to go negative.
+        /// </remarks>
+        public void PerformFlipFromScaleHandles(Axes axes)
+        {
+            if (axes.HasFlagFast(Axes.X))
+            {
+                dragHandles.FlipScaleHandles(Direction.Horizontal);
+                OnFlip?.Invoke(Direction.Horizontal, false);
+            }
+
+            if (axes.HasFlagFast(Axes.Y))
+            {
+                dragHandles.FlipScaleHandles(Direction.Vertical);
+                OnFlip?.Invoke(Direction.Vertical, false);
+            }
+        }
+
         private void addScaleHandle(Anchor anchor)
         {
             var handle = new SelectionBoxScaleHandle
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxDragHandleContainer.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxDragHandleContainer.cs
index 5c87271493..e7f69b7b37 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionBoxDragHandleContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionBoxDragHandleContainer.cs
@@ -7,6 +7,7 @@ using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 
@@ -69,6 +70,17 @@ namespace osu.Game.Screens.Edit.Compose.Components
             allDragHandles.Add(handle);
         }
 
+        public void FlipScaleHandles(Direction direction)
+        {
+            foreach (var handle in scaleHandles)
+            {
+                if (direction == Direction.Horizontal && !handle.Anchor.HasFlagFast(Anchor.x1))
+                    handle.Anchor ^= Anchor.x0 | Anchor.x2;
+                if (direction == Direction.Vertical && !handle.Anchor.HasFlagFast(Anchor.y1))
+                    handle.Anchor ^= Anchor.y0 | Anchor.y2;
+            }
+        }
+
         private SelectionBoxRotationHandle displayedRotationHandle;
         private SelectionBoxDragHandle activeHandle;
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/DifficultyPointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/DifficultyPointPiece.cs
index 173a665d5c..ca1e9a5d9b 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/DifficultyPointPiece.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/DifficultyPointPiece.cs
@@ -34,7 +34,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         {
             HitObject = hitObject;
 
-            speedMultiplier = (hitObject as IHasSliderVelocity)?.SliderVelocityBindable.GetBoundCopy();
+            speedMultiplier = (hitObject as IHasSliderVelocity)?.SliderVelocityMultiplierBindable.GetBoundCopy();
         }
 
         protected override Color4 GetRepresentingColour(OsuColour colours) => colours.Lime1;
@@ -106,8 +106,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 var relevantObjects = (beatmap.SelectedHitObjects.Contains(hitObject) ? beatmap.SelectedHitObjects : hitObject.Yield()).Where(o => o is IHasSliderVelocity).ToArray();
 
                 // even if there are multiple objects selected, we can still display a value if they all have the same value.
-                var selectedPointBindable = relevantObjects.Select(point => ((IHasSliderVelocity)point).SliderVelocity).Distinct().Count() == 1
-                    ? ((IHasSliderVelocity)relevantObjects.First()).SliderVelocityBindable
+                var selectedPointBindable = relevantObjects.Select(point => ((IHasSliderVelocity)point).SliderVelocityMultiplier).Distinct().Count() == 1
+                    ? ((IHasSliderVelocity)relevantObjects.First()).SliderVelocityMultiplierBindable
                     : null;
 
                 if (selectedPointBindable != null)
@@ -127,7 +127,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
                     foreach (var h in relevantObjects)
                     {
-                        ((IHasSliderVelocity)h).SliderVelocity = val.NewValue.Value;
+                        ((IHasSliderVelocity)h).SliderVelocityMultiplier = val.NewValue.Value;
                         beatmap.Update(h);
                     }
 
@@ -169,7 +169,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
             InspectorText.Clear();
 
-            double[] sliderVelocities = EditorBeatmap.HitObjects.OfType<IHasSliderVelocity>().Select(sv => sv.SliderVelocity).OrderBy(v => v).ToArray();
+            double[] sliderVelocities = EditorBeatmap.HitObjects.OfType<IHasSliderVelocity>().Select(sv => sv.SliderVelocityMultiplier).OrderBy(v => v).ToArray();
 
             AddHeader("Base velocity (from beatmap setup)");
             AddValue($"{beatmapVelocity:#,0.00}x");
@@ -177,6 +177,11 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             AddHeader("Final velocity");
             AddValue($"{beatmapVelocity * current.Value:#,0.00}x");
 
+            if (sliderVelocities.Length == 0)
+            {
+                return;
+            }
+
             if (sliderVelocities.First() != sliderVelocities.Last())
             {
                 AddHeader("Beatmap velocity range");
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
index 55f122669d..77afad2d4f 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
@@ -395,12 +395,12 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
                                 if (e.CurrentState.Keyboard.ShiftPressed && hitObject is IHasSliderVelocity hasSliderVelocity)
                                 {
-                                    double newVelocity = hasSliderVelocity.SliderVelocity * (repeatHitObject.Duration / proposedDuration);
+                                    double newVelocity = hasSliderVelocity.SliderVelocityMultiplier * (repeatHitObject.Duration / proposedDuration);
 
-                                    if (Precision.AlmostEquals(newVelocity, hasSliderVelocity.SliderVelocity))
+                                    if (Precision.AlmostEquals(newVelocity, hasSliderVelocity.SliderVelocityMultiplier))
                                         return;
 
-                                    hasSliderVelocity.SliderVelocity = newVelocity;
+                                    hasSliderVelocity.SliderVelocityMultiplier = newVelocity;
                                     beatmap.Update(hitObject);
                                 }
                                 else
diff --git a/osu.Game/Screens/Edit/LegacyEditorBeatmapPatcher.cs b/osu.Game/Screens/Edit/LegacyEditorBeatmapPatcher.cs
index 565379f391..fe0d4a7822 100644
--- a/osu.Game/Screens/Edit/LegacyEditorBeatmapPatcher.cs
+++ b/osu.Game/Screens/Edit/LegacyEditorBeatmapPatcher.cs
@@ -114,7 +114,7 @@ namespace osu.Game.Screens.Edit
                     continue;
 
                 if (oldObject is IHasSliderVelocity oldWithVelocity && newObject is IHasSliderVelocity newWithVelocity)
-                    oldWithVelocity.SliderVelocity = newWithVelocity.SliderVelocity;
+                    oldWithVelocity.SliderVelocityMultiplier = newWithVelocity.SliderVelocityMultiplier;
 
                 oldObject.Samples = newObject.Samples;
 
diff --git a/osu.Game/Screens/Ranking/ResultsScreen.cs b/osu.Game/Screens/Ranking/ResultsScreen.cs
index 1d0499c909..03231f9329 100644
--- a/osu.Game/Screens/Ranking/ResultsScreen.cs
+++ b/osu.Game/Screens/Ranking/ResultsScreen.cs
@@ -156,7 +156,7 @@ namespace osu.Game.Screens.Ranking
             if (Score != null)
             {
                 // only show flair / animation when arriving after watching a play that isn't autoplay.
-                bool shouldFlair = player != null && Score.Mods.All(m => m.UserPlayable);
+                bool shouldFlair = player != null && !Score.User.IsBot;
 
                 ScorePanelList.AddScore(Score, shouldFlair);
             }
diff --git a/osu.Game/Screens/Select/BeatmapCarousel.cs b/osu.Game/Screens/Select/BeatmapCarousel.cs
index 9af9a0ce72..16ae54b413 100644
--- a/osu.Game/Screens/Select/BeatmapCarousel.cs
+++ b/osu.Game/Screens/Select/BeatmapCarousel.cs
@@ -78,6 +78,8 @@ namespace osu.Game.Screens.Select
 
         private CarouselBeatmapSet? selectedBeatmapSet;
 
+        private List<BeatmapSetInfo> originalBeatmapSetsDetached = new List<BeatmapSetInfo>();
+
         /// <summary>
         /// Raised when the <see cref="SelectedBeatmapInfo"/> is changed.
         /// </summary>
@@ -127,15 +129,38 @@ namespace osu.Game.Screens.Select
 
         private void loadBeatmapSets(IEnumerable<BeatmapSetInfo> beatmapSets)
         {
+            originalBeatmapSetsDetached = beatmapSets.Detach();
+
+            if (selectedBeatmapSet != null && !originalBeatmapSetsDetached.Contains(selectedBeatmapSet.BeatmapSet))
+                selectedBeatmapSet = null;
+
+            var selectedBeatmapBefore = selectedBeatmap?.BeatmapInfo;
+
             CarouselRoot newRoot = new CarouselRoot(this);
 
-            newRoot.AddItems(beatmapSets.Select(s => createCarouselSet(s.Detach())).OfType<CarouselBeatmapSet>());
+            if (beatmapsSplitOut)
+            {
+                var carouselBeatmapSets = originalBeatmapSetsDetached.SelectMany(s => s.Beatmaps).Select(b =>
+                {
+                    return createCarouselSet(new BeatmapSetInfo(new[] { b })
+                    {
+                        ID = b.BeatmapSet!.ID,
+                        OnlineID = b.BeatmapSet!.OnlineID,
+                        Status = b.BeatmapSet!.Status,
+                    });
+                }).OfType<CarouselBeatmapSet>();
+
+                newRoot.AddItems(carouselBeatmapSets);
+            }
+            else
+            {
+                var carouselBeatmapSets = originalBeatmapSetsDetached.Select(createCarouselSet).OfType<CarouselBeatmapSet>();
+
+                newRoot.AddItems(carouselBeatmapSets);
+            }
 
             root = newRoot;
 
-            if (selectedBeatmapSet != null && !beatmapSets.Contains(selectedBeatmapSet.BeatmapSet))
-                selectedBeatmapSet = null;
-
             Scroll.Clear(false);
             itemsCache.Invalidate();
             ScrollToSelected();
@@ -144,6 +169,15 @@ namespace osu.Game.Screens.Select
 
             if (loadedTestBeatmaps)
                 signalBeatmapsLoaded();
+
+            // Restore selection
+            if (selectedBeatmapBefore != null && newRoot.BeatmapSetsByID.TryGetValue(selectedBeatmapBefore.BeatmapSet!.ID, out var newSelectionCandidates))
+            {
+                CarouselBeatmap? found = newSelectionCandidates.SelectMany(s => s.Beatmaps).SingleOrDefault(b => b.BeatmapInfo.ID == selectedBeatmapBefore.ID);
+
+                if (found != null)
+                    found.State.Value = CarouselItemState.Selected;
+            }
         }
 
         private readonly List<CarouselItem> visibleItems = new List<CarouselItem>();
@@ -330,8 +364,8 @@ namespace osu.Game.Screens.Select
 
                 // Only require to action here if the beatmap is missing.
                 // This avoids processing these events unnecessarily when new beatmaps are imported, for example.
-                if (root.BeatmapSetsByID.TryGetValue(beatmapSet.ID, out var existingSet)
-                    && existingSet.BeatmapSet.Beatmaps.All(b => b.ID != beatmapInfo.ID))
+                if (root.BeatmapSetsByID.TryGetValue(beatmapSet.ID, out var existingSets)
+                    && existingSets.SelectMany(s => s.Beatmaps).All(b => b.BeatmapInfo.ID != beatmapInfo.ID))
                 {
                     UpdateBeatmapSet(beatmapSet.Detach());
                 }
@@ -345,15 +379,20 @@ namespace osu.Game.Screens.Select
 
         private void removeBeatmapSet(Guid beatmapSetID) => Schedule(() =>
         {
-            if (!root.BeatmapSetsByID.TryGetValue(beatmapSetID, out var existingSet))
+            if (!root.BeatmapSetsByID.TryGetValue(beatmapSetID, out var existingSets))
                 return;
 
-            foreach (var beatmap in existingSet.Beatmaps)
-                randomSelectedBeatmaps.Remove(beatmap);
+            originalBeatmapSetsDetached.RemoveAll(set => set.ID == beatmapSetID);
 
-            previouslyVisitedRandomSets.Remove(existingSet);
+            foreach (var set in existingSets)
+            {
+                foreach (var beatmap in set.Beatmaps)
+                    randomSelectedBeatmaps.Remove(beatmap);
+                previouslyVisitedRandomSets.Remove(set);
+
+                root.RemoveItem(set);
+            }
 
-            root.RemoveItem(existingSet);
             itemsCache.Invalidate();
 
             if (!Scroll.UserScrolling)
@@ -366,26 +405,64 @@ namespace osu.Game.Screens.Select
         {
             Guid? previouslySelectedID = null;
 
+            originalBeatmapSetsDetached.RemoveAll(set => set.ID == beatmapSet.ID);
+            originalBeatmapSetsDetached.Add(beatmapSet.Detach());
+
             // If the selected beatmap is about to be removed, store its ID so it can be re-selected if required
             if (selectedBeatmapSet?.BeatmapSet.ID == beatmapSet.ID)
                 previouslySelectedID = selectedBeatmap?.BeatmapInfo.ID;
 
-            var newSet = createCarouselSet(beatmapSet);
-            var removedSet = root.RemoveChild(beatmapSet.ID);
+            var removedSets = root.RemoveItemsByID(beatmapSet.ID);
 
-            // If we don't remove this here, it may remain in a hidden state until scrolled off screen.
-            // Doesn't really affect anything during actual user interaction, but makes testing annoying.
-            var removedDrawable = Scroll.FirstOrDefault(c => c.Item == removedSet);
-            if (removedDrawable != null)
-                expirePanelImmediately(removedDrawable);
-
-            if (newSet != null)
+            foreach (var removedSet in removedSets)
             {
-                root.AddItem(newSet);
+                // If we don't remove this here, it may remain in a hidden state until scrolled off screen.
+                // Doesn't really affect anything during actual user interaction, but makes testing annoying.
+                var removedDrawable = Scroll.FirstOrDefault(c => c.Item == removedSet);
+                if (removedDrawable != null)
+                    expirePanelImmediately(removedDrawable);
+            }
+
+            if (beatmapsSplitOut)
+            {
+                var newSets = new List<CarouselBeatmapSet>();
+
+                foreach (var beatmap in beatmapSet.Beatmaps)
+                {
+                    var newSet = createCarouselSet(new BeatmapSetInfo(new[] { beatmap })
+                    {
+                        ID = beatmapSet.ID,
+                        OnlineID = beatmapSet.OnlineID,
+                        Status = beatmapSet.Status,
+                    });
+
+                    if (newSet != null)
+                    {
+                        newSets.Add(newSet);
+                        root.AddItem(newSet);
+                    }
+                }
 
                 // check if we can/need to maintain our current selection.
                 if (previouslySelectedID != null)
-                    select((CarouselItem?)newSet.Beatmaps.FirstOrDefault(b => b.BeatmapInfo.ID == previouslySelectedID) ?? newSet);
+                {
+                    var toSelect = newSets.FirstOrDefault(s => s.Beatmaps.Any(b => b.BeatmapInfo.ID == previouslySelectedID))
+                                   ?? newSets.FirstOrDefault();
+                    select(toSelect);
+                }
+            }
+            else
+            {
+                var newSet = createCarouselSet(beatmapSet);
+
+                if (newSet != null)
+                {
+                    root.AddItem(newSet);
+
+                    // check if we can/need to maintain our current selection.
+                    if (previouslySelectedID != null)
+                        select((CarouselItem?)newSet.Beatmaps.FirstOrDefault(b => b.BeatmapInfo.ID == previouslySelectedID) ?? newSet);
+                }
             }
 
             itemsCache.Invalidate();
@@ -632,6 +709,8 @@ namespace osu.Game.Screens.Select
             applyActiveCriteria(debounce);
         }
 
+        private bool beatmapsSplitOut;
+
         private void applyActiveCriteria(bool debounce, bool alwaysResetScrollPosition = true)
         {
             PendingFilter?.Cancel();
@@ -652,6 +731,13 @@ namespace osu.Game.Screens.Select
             {
                 PendingFilter = null;
 
+                if (activeCriteria.SplitOutDifficulties != beatmapsSplitOut)
+                {
+                    beatmapsSplitOut = activeCriteria.SplitOutDifficulties;
+                    loadBeatmapSets(originalBeatmapSetsDetached);
+                    return;
+                }
+
                 root.Filter(activeCriteria);
                 itemsCache.Invalidate();
 
@@ -1055,7 +1141,7 @@ namespace osu.Game.Screens.Select
             // May only be null during construction (State.Value set causes PerformSelection to be triggered).
             private readonly BeatmapCarousel? carousel;
 
-            public readonly Dictionary<Guid, CarouselBeatmapSet> BeatmapSetsByID = new Dictionary<Guid, CarouselBeatmapSet>();
+            public readonly Dictionary<Guid, List<CarouselBeatmapSet>> BeatmapSetsByID = new Dictionary<Guid, List<CarouselBeatmapSet>>();
 
             public CarouselRoot(BeatmapCarousel carousel)
             {
@@ -1069,20 +1155,25 @@ namespace osu.Game.Screens.Select
             public override void AddItem(CarouselItem i)
             {
                 CarouselBeatmapSet set = (CarouselBeatmapSet)i;
-                BeatmapSetsByID.Add(set.BeatmapSet.ID, set);
+                if (BeatmapSetsByID.TryGetValue(set.BeatmapSet.ID, out var sets))
+                    sets.Add(set);
+                else
+                    BeatmapSetsByID.Add(set.BeatmapSet.ID, new List<CarouselBeatmapSet> { set });
 
                 base.AddItem(i);
             }
 
-            public CarouselBeatmapSet? RemoveChild(Guid beatmapSetID)
+            public IEnumerable<CarouselBeatmapSet> RemoveItemsByID(Guid beatmapSetID)
             {
-                if (BeatmapSetsByID.TryGetValue(beatmapSetID, out var carouselBeatmapSet))
+                if (BeatmapSetsByID.TryGetValue(beatmapSetID, out var carouselBeatmapSets))
                 {
-                    RemoveItem(carouselBeatmapSet);
-                    return carouselBeatmapSet;
+                    foreach (var set in carouselBeatmapSets)
+                        RemoveItem(set);
+
+                    return carouselBeatmapSets;
                 }
 
-                return null;
+                return Enumerable.Empty<CarouselBeatmapSet>();
             }
 
             public override void RemoveItem(CarouselItem i)
diff --git a/osu.Game/Screens/Select/BeatmapDetails.cs b/osu.Game/Screens/Select/BeatmapDetails.cs
index 712b610515..179323176a 100644
--- a/osu.Game/Screens/Select/BeatmapDetails.cs
+++ b/osu.Game/Screens/Select/BeatmapDetails.cs
@@ -141,9 +141,9 @@ namespace osu.Game.Screens.Select
                                                     LayoutEasing = Easing.OutQuad,
                                                     Children = new[]
                                                     {
-                                                        description = new MetadataSectionDescription(searchOnSongSelect),
-                                                        source = new MetadataSectionSource(searchOnSongSelect),
-                                                        tags = new MetadataSectionTags(searchOnSongSelect),
+                                                        description = new MetadataSectionDescription(query => songSelect?.Search(query)),
+                                                        source = new MetadataSectionSource(query => songSelect?.Search(query)),
+                                                        tags = new MetadataSectionTags(query => songSelect?.Search(query)),
                                                     },
                                                 },
                                             },
@@ -176,12 +176,6 @@ namespace osu.Game.Screens.Select
                 },
                 loading = new LoadingLayer(true)
             };
-
-            void searchOnSongSelect(string text)
-            {
-                if (songSelect != null)
-                    songSelect.FilterControl.CurrentTextSearch.Value = text;
-            }
         }
 
         private void updateStatistics()
diff --git a/osu.Game/Screens/Select/BeatmapInfoWedge.cs b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
index 81759f6787..8bbf569566 100644
--- a/osu.Game/Screens/Select/BeatmapInfoWedge.cs
+++ b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
@@ -30,6 +30,7 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 using osu.Game.Graphics.Containers;
+using osu.Game.Resources.Localisation.Web;
 
 namespace osu.Game.Screens.Select
 {
@@ -371,7 +372,7 @@ namespace osu.Game.Screens.Select
                     {
                         new InfoLabel(new BeatmapStatistic
                         {
-                            Name = $"Length (Drain: {playableBeatmap.CalculateDrainLength().ToFormattedDuration().ToString()})",
+                            Name = BeatmapsetsStrings.ShowStatsTotalLength(playableBeatmap.CalculateDrainLength().ToFormattedDuration()),
                             CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Length),
                             Content = working.BeatmapInfo.Length.ToFormattedDuration().ToString(),
                         }),
@@ -415,7 +416,7 @@ namespace osu.Game.Screens.Select
 
                 bpmLabelContainer.Child = new InfoLabel(new BeatmapStatistic
                 {
-                    Name = "BPM",
+                    Name = BeatmapsetsStrings.ShowStatsBpm,
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Bpm),
                     Content = labelText
                 });
diff --git a/osu.Game/Screens/Select/BeatmapInfoWedgeV2.cs b/osu.Game/Screens/Select/BeatmapInfoWedgeV2.cs
new file mode 100644
index 0000000000..3c76ae1f08
--- /dev/null
+++ b/osu.Game/Screens/Select/BeatmapInfoWedgeV2.cs
@@ -0,0 +1,329 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Threading;
+using osuTK;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Localisation;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Screens.Select
+{
+    public partial class BeatmapInfoWedgeV2 : VisibilityContainer
+    {
+        public const float WEDGE_HEIGHT = 120;
+        private const float shear_width = 21;
+        private const float transition_duration = 250;
+        private const float corner_radius = 10;
+        private const float colour_bar_width = 30;
+
+        /// Todo: move this const out to song select when more new design elements are implemented for the beatmap details area, since it applies to text alignment of various elements
+        private const float text_margin = 62;
+
+        private static readonly Vector2 wedged_container_shear = new Vector2(shear_width / WEDGE_HEIGHT, 0);
+
+        [Resolved]
+        private IBindable<RulesetInfo> ruleset { get; set; } = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapDifficultyCache difficultyCache { get; set; } = null!;
+
+        protected Container? DisplayedContent { get; private set; }
+
+        protected WedgeInfoText? Info { get; private set; }
+
+        private Container difficultyColourBar = null!;
+        private StarCounter starCounter = null!;
+        private StarRatingDisplay starRatingDisplay = null!;
+        private BeatmapSetOnlineStatusPill statusPill = null!;
+        private Container content = null!;
+
+        private IBindable<StarDifficulty?>? starDifficulty;
+        private CancellationTokenSource? cancellationSource;
+
+        public BeatmapInfoWedgeV2()
+        {
+            Height = WEDGE_HEIGHT;
+            Shear = wedged_container_shear;
+            Masking = true;
+            Margin = new MarginPadding { Left = -corner_radius };
+            EdgeEffect = new EdgeEffectParameters
+            {
+                Colour = Colour4.Black.Opacity(0.2f),
+                Type = EdgeEffectType.Shadow,
+                Radius = 3,
+            };
+            CornerRadius = corner_radius;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Child = content = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    // These elements can't be grouped with the rest of the content, due to being present either outside or under the backgrounds area
+                    difficultyColourBar = new Container
+                    {
+                        Colour = Colour4.Transparent,
+                        Depth = float.MaxValue,
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                        RelativeSizeAxes = Axes.Y,
+
+                        // By limiting the width we avoid this box showing up as an outline around the drawables that are on top of it.
+                        Width = colour_bar_width + corner_radius,
+                        Child = new Box { RelativeSizeAxes = Axes.Both }
+                    },
+                    new Container
+                    {
+                        // Applying the shear to this container and nesting the starCounter inside avoids
+                        // the deformation that occurs if the shear is applied to the starCounter whilst rotated
+                        Shear = -wedged_container_shear,
+                        X = -colour_bar_width / 2,
+                        Anchor = Anchor.CentreRight,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Y,
+                        Width = colour_bar_width,
+                        Child = starCounter = new StarCounter
+                        {
+                            Rotation = (float)(Math.Atan(shear_width / WEDGE_HEIGHT) * (180 / Math.PI)),
+                            Colour = Colour4.Transparent,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Scale = new Vector2(0.35f),
+                            Direction = FillDirection.Vertical
+                        }
+                    },
+                    new FillFlowContainer
+                    {
+                        Name = "Topright-aligned metadata",
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                        Direction = FillDirection.Vertical,
+                        Padding = new MarginPadding { Top = 3, Right = colour_bar_width + 8 },
+                        AutoSizeAxes = Axes.Both,
+                        Spacing = new Vector2(0, 5),
+                        Depth = float.MinValue,
+                        Children = new Drawable[]
+                        {
+                            starRatingDisplay = new StarRatingDisplay(default, animated: true)
+                            {
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.TopRight,
+                                Shear = -wedged_container_shear,
+                                Alpha = 0,
+                            },
+                            statusPill = new BeatmapSetOnlineStatusPill
+                            {
+                                AutoSizeAxes = Axes.Both,
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.TopRight,
+                                Shear = -wedged_container_shear,
+                                TextSize = 11,
+                                TextPadding = new MarginPadding { Horizontal = 8, Vertical = 2 },
+                                Alpha = 0,
+                            }
+                        }
+                    },
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            ruleset.BindValueChanged(_ => updateDisplay());
+
+            starRatingDisplay.Current.BindValueChanged(s =>
+            {
+                // use actual stars as star counter has its own animation
+                starCounter.Current = (float)s.NewValue.Stars;
+            }, true);
+
+            starRatingDisplay.DisplayedStars.BindValueChanged(s =>
+            {
+                // sync color with star rating display
+                starCounter.Colour = s.NewValue >= 6.5 ? colours.Orange1 : Colour4.Black.Opacity(0.75f);
+                difficultyColourBar.FadeColour(colours.ForStarDifficulty(s.NewValue));
+            }, true);
+        }
+
+        private const double animation_duration = 600;
+
+        protected override void PopIn()
+        {
+            this.MoveToX(0, animation_duration, Easing.OutQuint);
+            this.FadeIn(200, Easing.In);
+        }
+
+        protected override void PopOut()
+        {
+            this.MoveToX(-150, animation_duration, Easing.OutQuint);
+            this.FadeOut(200, Easing.OutQuint);
+        }
+
+        private WorkingBeatmap beatmap = null!;
+
+        public WorkingBeatmap Beatmap
+        {
+            get => beatmap;
+            set
+            {
+                if (beatmap == value) return;
+
+                beatmap = value;
+
+                updateDisplay();
+            }
+        }
+
+        private Container? loadingInfo;
+
+        private void updateDisplay()
+        {
+            statusPill.Status = beatmap.BeatmapInfo.Status;
+
+            starDifficulty = difficultyCache.GetBindableDifficulty(beatmap.BeatmapInfo, (cancellationSource = new CancellationTokenSource()).Token);
+
+            starDifficulty.BindValueChanged(s =>
+            {
+                starRatingDisplay.Current.Value = s.NewValue ?? default;
+
+                starRatingDisplay.FadeIn(transition_duration);
+            });
+
+            Scheduler.AddOnce(() =>
+            {
+                LoadComponentAsync(loadingInfo = new Container
+                {
+                    Padding = new MarginPadding { Right = colour_bar_width },
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = DisplayedContent?.Depth + 1 ?? 0,
+                    Child = new Container
+                    {
+                        Masking = true,
+                        CornerRadius = corner_radius,
+                        RelativeSizeAxes = Axes.Both,
+                        Children = new Drawable[]
+                        {
+                            // TODO: New wedge design uses a coloured horizontal gradient for its background, however this lacks implementation information in the figma draft.
+                            // pending https://www.figma.com/file/DXKwqZhD5yyb1igc3mKo1P?node-id=2980:3361#340801912 being answered.
+                            new BeatmapInfoWedgeBackground(beatmap) { Shear = -Shear },
+                            Info = new WedgeInfoText(beatmap) { Shear = -Shear }
+                        }
+                    }
+                }, d =>
+                {
+                    // Ensure we are the most recent loaded wedge.
+                    if (d != loadingInfo) return;
+
+                    removeOldInfo();
+                    content.Add(DisplayedContent = d);
+                });
+            });
+
+            void removeOldInfo()
+            {
+                DisplayedContent?.FadeOut(transition_duration);
+                DisplayedContent?.Expire();
+                DisplayedContent = null;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            cancellationSource?.Cancel();
+        }
+
+        public partial class WedgeInfoText : Container
+        {
+            public OsuSpriteText TitleLabel { get; private set; } = null!;
+            public OsuSpriteText ArtistLabel { get; private set; } = null!;
+
+            private readonly WorkingBeatmap working;
+
+            public WedgeInfoText(WorkingBeatmap working)
+            {
+                this.working = working;
+
+                RelativeSizeAxes = Axes.Both;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(SongSelect? songSelect, LocalisationManager localisation)
+            {
+                var metadata = working.Metadata;
+
+                var titleText = new RomanisableString(metadata.TitleUnicode, metadata.Title);
+                var artistText = new RomanisableString(metadata.ArtistUnicode, metadata.Artist);
+
+                Child = new FillFlowContainer
+                {
+                    Name = "Top-left aligned metadata",
+                    Direction = FillDirection.Vertical,
+                    Padding = new MarginPadding { Left = text_margin, Top = 12 },
+                    AutoSizeAxes = Axes.Y,
+                    RelativeSizeAxes = Axes.X,
+                    Children = new Drawable[]
+                    {
+                        new OsuHoverContainer
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Action = () => songSelect?.Search(titleText.GetPreferred(localisation.CurrentParameters.Value.PreferOriginalScript)),
+                            Child = TitleLabel = new TruncatingSpriteText
+                            {
+                                Shadow = true,
+                                Text = titleText,
+                                Font = OsuFont.TorusAlternate.With(size: 40, weight: FontWeight.SemiBold),
+                            },
+                        },
+                        new OsuHoverContainer
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Action = () => songSelect?.Search(artistText.GetPreferred(localisation.CurrentParameters.Value.PreferOriginalScript)),
+                            Child = ArtistLabel = new TruncatingSpriteText
+                            {
+                                // TODO : figma design has a diffused shadow, instead of the solid one present here, not possible currently as far as i'm aware.
+                                Shadow = true,
+                                Text = artistText,
+                                // Not sure if this should be semi bold or medium
+                                Font = OsuFont.Torus.With(size: 20, weight: FontWeight.SemiBold),
+                            },
+                        },
+                    }
+                };
+            }
+
+            protected override void UpdateAfterChildren()
+            {
+                base.UpdateAfterChildren();
+
+                // best effort to confine the auto-sized text to wedge bounds
+                // the artist label doesn't have an extra text_margin as it doesn't touch the right metadata
+                TitleLabel.MaxWidth = DrawWidth - text_margin * 2 - shear_width;
+                ArtistLabel.MaxWidth = DrawWidth - text_margin - shear_width;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Select/FilterCriteria.cs b/osu.Game/Screens/Select/FilterCriteria.cs
index ab4f85fc92..a2ae114126 100644
--- a/osu.Game/Screens/Select/FilterCriteria.cs
+++ b/osu.Game/Screens/Select/FilterCriteria.cs
@@ -19,6 +19,11 @@ namespace osu.Game.Screens.Select
         public GroupMode Group;
         public SortMode Sort;
 
+        /// <summary>
+        /// Whether the display of beatmap sets should be split apart per-difficulty for the current criteria.
+        /// </summary>
+        public bool SplitOutDifficulties => Sort == SortMode.Difficulty;
+
         public BeatmapSetInfo? SelectedBeatmapSet;
 
         public OptionalRange<double> StarDifficulty;
diff --git a/osu.Game/Screens/Select/FooterV2/BeatmapOptionsPopover.cs b/osu.Game/Screens/Select/FooterV2/BeatmapOptionsPopover.cs
new file mode 100644
index 0000000000..f81036f745
--- /dev/null
+++ b/osu.Game/Screens/Select/FooterV2/BeatmapOptionsPopover.cs
@@ -0,0 +1,196 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
+using osu.Game.Overlays;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
+using WebCommonStrings = osu.Game.Resources.Localisation.Web.CommonStrings;
+
+namespace osu.Game.Screens.Select.FooterV2
+{
+    public partial class BeatmapOptionsPopover : OsuPopover
+    {
+        private FillFlowContainer buttonFlow = null!;
+        private readonly FooterButtonOptionsV2 footerButton;
+
+        private WorkingBeatmap beatmapWhenOpening = null!;
+
+        [Resolved]
+        private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
+
+        public BeatmapOptionsPopover(FooterButtonOptionsV2 footerButton)
+        {
+            this.footerButton = footerButton;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ManageCollectionsDialog? manageCollectionsDialog, SongSelect? songSelect, OsuColour colours, BeatmapManager? beatmapManager)
+        {
+            Content.Padding = new MarginPadding(5);
+
+            Child = buttonFlow = new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Both,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(3),
+            };
+
+            beatmapWhenOpening = beatmap.Value;
+
+            addHeader(CommonStrings.General);
+            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);
+
+            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);
+
+            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));
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            ScheduleAfterChildren(() => GetContainingInputManager().ChangeFocus(this));
+
+            beatmap.BindValueChanged(_ => Hide());
+        }
+
+        [Resolved]
+        private OverlayColourProvider overlayColourProvider { get; set; } = null!;
+
+        private void addHeader(LocalisableString text, string? context = null)
+        {
+            var textFlow = new OsuTextFlowContainer
+            {
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+                Padding = new MarginPadding(10),
+            };
+
+            textFlow.AddText(text, t => t.Font = OsuFont.Default.With(weight: FontWeight.SemiBold));
+
+            if (context != null)
+            {
+                textFlow.NewLine();
+                textFlow.AddText(context, t =>
+                {
+                    t.Colour = overlayColourProvider.Content2;
+                    t.Font = t.Font.With(size: 13);
+                });
+            }
+
+            buttonFlow.Add(textFlow);
+        }
+
+        private void addButton(LocalisableString text, IconUsage icon, Action? action, Color4? colour = null)
+        {
+            var button = new OptionButton
+            {
+                Text = text,
+                Icon = icon,
+                TextColour = colour,
+                Action = () =>
+                {
+                    Scheduler.AddDelayed(Hide, 50);
+                    action?.Invoke();
+                },
+            };
+
+            buttonFlow.Add(button);
+        }
+
+        private partial class OptionButton : OsuButton
+        {
+            public IconUsage Icon { get; init; }
+            public Color4? TextColour { get; init; }
+
+            public OptionButton()
+            {
+                Size = new Vector2(265, 50);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider)
+            {
+                BackgroundColour = colourProvider.Background3;
+
+                SpriteText.Colour = TextColour ?? Color4.White;
+                Content.CornerRadius = 10;
+
+                Add(new SpriteIcon
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Size = new Vector2(17),
+                    X = 15,
+                    Icon = Icon,
+                    Colour = TextColour ?? Color4.White,
+                });
+            }
+
+            protected override SpriteText CreateText() => new OsuSpriteText
+            {
+                Depth = -1,
+                Origin = Anchor.CentreLeft,
+                Anchor = Anchor.CentreLeft,
+                X = 40
+            };
+        }
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            // don't absorb control as ToolbarRulesetSelector uses control + number to navigate
+            if (e.ControlPressed) return false;
+
+            if (!e.Repeat && e.Key >= Key.Number1 && e.Key <= Key.Number9)
+            {
+                int requested = e.Key - Key.Number1;
+
+                OptionButton? found = buttonFlow.Children.OfType<OptionButton>().ElementAtOrDefault(requested);
+
+                if (found != null)
+                {
+                    found.TriggerClick();
+                    return true;
+                }
+            }
+
+            return base.OnKeyDown(e);
+        }
+
+        protected override void UpdateState(ValueChangedEvent<Visibility> state)
+        {
+            base.UpdateState(state);
+
+            if (state.NewValue == Visibility.Hidden)
+                footerButton.IsActive.Value = false;
+        }
+    }
+}
diff --git a/osu.Game/Screens/Select/FooterV2/FooterButtonOptionsV2.cs b/osu.Game/Screens/Select/FooterV2/FooterButtonOptionsV2.cs
index 87cca0042a..a1559d32dc 100644
--- a/osu.Game/Screens/Select/FooterV2/FooterButtonOptionsV2.cs
+++ b/osu.Game/Screens/Select/FooterV2/FooterButtonOptionsV2.cs
@@ -2,14 +2,21 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics;
 using osu.Game.Input.Bindings;
 
 namespace osu.Game.Screens.Select.FooterV2
 {
-    public partial class FooterButtonOptionsV2 : FooterButtonV2
+    public partial class FooterButtonOptionsV2 : FooterButtonV2, IHasPopover
     {
+        public readonly BindableBool IsActive = new BindableBool();
+
         [BackgroundDependencyLoader]
         private void load(OsuColour colour)
         {
@@ -17,6 +24,34 @@ namespace osu.Game.Screens.Select.FooterV2
             Icon = FontAwesome.Solid.Cog;
             AccentColour = colour.Purple1;
             Hotkey = GlobalAction.ToggleBeatmapOptions;
+
+            Action = () => IsActive.Toggle();
         }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            IsActive.BindValueChanged(active =>
+            {
+                OverlayState.Value = active.NewValue ? Visibility.Visible : Visibility.Hidden;
+            });
+
+            OverlayState.BindValueChanged(state =>
+            {
+                switch (state.NewValue)
+                {
+                    case Visibility.Hidden:
+                        this.HidePopover();
+                        break;
+
+                    case Visibility.Visible:
+                        this.ShowPopover();
+                        break;
+                }
+            });
+        }
+
+        public Popover GetPopover() => new BeatmapOptionsPopover(this);
     }
 }
diff --git a/osu.Game/Screens/Select/FooterV2/FooterV2.cs b/osu.Game/Screens/Select/FooterV2/FooterV2.cs
index cd95f3eb6c..0529f0d082 100644
--- a/osu.Game/Screens/Select/FooterV2/FooterV2.cs
+++ b/osu.Game/Screens/Select/FooterV2/FooterV2.cs
@@ -48,11 +48,17 @@ namespace osu.Game.Screens.Select.FooterV2
 
         private FillFlowContainer<FooterButtonV2> buttons = null!;
 
-        [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colourProvider)
+        public FooterV2()
         {
             RelativeSizeAxes = Axes.X;
             Height = height;
+            Anchor = Anchor.BottomLeft;
+            Origin = Anchor.BottomLeft;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
+        {
             InternalChildren = new Drawable[]
             {
                 new Box
diff --git a/osu.Game/Screens/Select/SongSelect.cs b/osu.Game/Screens/Select/SongSelect.cs
index f9d41f98ea..34ee0ae4e8 100644
--- a/osu.Game/Screens/Select/SongSelect.cs
+++ b/osu.Game/Screens/Select/SongSelect.cs
@@ -311,9 +311,9 @@ namespace osu.Game.Screens.Select
                     Footer.AddButton(button, overlay);
 
                 BeatmapOptions.AddButton(@"Manage", @"collections", FontAwesome.Solid.Book, colours.Green, () => manageCollectionsDialog?.Show());
-                BeatmapOptions.AddButton(@"Delete", @"all difficulties", FontAwesome.Solid.Trash, colours.Pink, () => delete(Beatmap.Value.BeatmapSetInfo));
+                BeatmapOptions.AddButton(@"Delete", @"all difficulties", FontAwesome.Solid.Trash, colours.Pink, () => DeleteBeatmap(Beatmap.Value.BeatmapSetInfo));
                 BeatmapOptions.AddButton(@"Remove", @"from unplayed", FontAwesome.Regular.TimesCircle, colours.Purple, null);
-                BeatmapOptions.AddButton(@"Clear", @"local scores", FontAwesome.Solid.Eraser, colours.Purple, () => clearScores(Beatmap.Value.BeatmapInfo));
+                BeatmapOptions.AddButton(@"Clear", @"local scores", FontAwesome.Solid.Eraser, colours.Purple, () => ClearScores(Beatmap.Value.BeatmapInfo));
             }
 
             sampleChangeDifficulty = audio.Samples.Get(@"SongSelect/select-difficulty");
@@ -390,6 +390,15 @@ namespace osu.Game.Screens.Select
             this.Push(new EditorLoader());
         }
 
+        /// <summary>
+        /// Set the query to the search text box.
+        /// </summary>
+        /// <param name="query">The string to search.</param>
+        public void Search(string query)
+        {
+            FilterControl.CurrentTextSearch.Value = query;
+        }
+
         /// <summary>
         /// Call to make a selection and perform the default action for this SongSelect.
         /// </summary>
@@ -918,14 +927,20 @@ namespace osu.Game.Screens.Select
             return true;
         }
 
-        private void delete(BeatmapSetInfo? beatmap)
+        /// <summary>
+        /// Request to delete a specific beatmap.
+        /// </summary>
+        public void DeleteBeatmap(BeatmapSetInfo? beatmap)
         {
             if (beatmap == null) return;
 
             dialogOverlay?.Push(new BeatmapDeleteDialog(beatmap));
         }
 
-        private void clearScores(BeatmapInfo? beatmapInfo)
+        /// <summary>
+        /// Request to clear the scores of a specific beatmap.
+        /// </summary>
+        public void ClearScores(BeatmapInfo? beatmapInfo)
         {
             if (beatmapInfo == null) return;
 
@@ -965,7 +980,7 @@ namespace osu.Game.Screens.Select
                     if (e.ShiftPressed)
                     {
                         if (!Beatmap.IsDefault)
-                            delete(Beatmap.Value.BeatmapSetInfo);
+                            DeleteBeatmap(Beatmap.Value.BeatmapSetInfo);
                         return true;
                     }
 
diff --git a/osu.Game/Skinning/ArgonSkin.cs b/osu.Game/Skinning/ArgonSkin.cs
index 61b0dc5aa1..6e17458082 100644
--- a/osu.Game/Skinning/ArgonSkin.cs
+++ b/osu.Game/Skinning/ArgonSkin.cs
@@ -219,15 +219,20 @@ namespace osu.Game.Skinning
                     switch (global)
                     {
                         case GlobalSkinColours.ComboColours:
+                        {
+                            LogLookupDebug(this, lookup, LookupDebugType.Hit);
                             return SkinUtils.As<TValue>(new Bindable<IReadOnlyList<Color4>?>(Configuration.ComboColours));
+                        }
                     }
 
                     break;
 
                 case SkinComboColourLookup comboColour:
+                    LogLookupDebug(this, lookup, LookupDebugType.Hit);
                     return SkinUtils.As<TValue>(new Bindable<Color4>(getComboColour(Configuration, comboColour.ColourIndex)));
             }
 
+            LogLookupDebug(this, lookup, LookupDebugType.Miss);
             return null;
         }
 
diff --git a/osu.Game/Skinning/LegacyBeatmapSkin.cs b/osu.Game/Skinning/LegacyBeatmapSkin.cs
index 1cbfda16cf..90eb5fa013 100644
--- a/osu.Game/Skinning/LegacyBeatmapSkin.cs
+++ b/osu.Game/Skinning/LegacyBeatmapSkin.cs
@@ -19,7 +19,7 @@ namespace osu.Game.Skinning
 {
     public class LegacyBeatmapSkin : LegacySkin
     {
-        protected override bool AllowManiaSkin => false;
+        protected override bool AllowManiaConfigLookups => false;
         protected override bool UseCustomSampleBanks => true;
 
         /// <summary>
@@ -72,6 +72,8 @@ namespace osu.Game.Skinning
                     // If it is decided that we need this due to beatmaps somehow using it, the default (1.0 specified in LegacySkinDecoder.CreateTemplateObject)
                     // needs to be removed else it will cause incorrect skin behaviours. This is due to the config lookup having no context of which skin
                     // it should be returning the version for.
+
+                    Skin.LogLookupDebug(this, lookup, Skin.LookupDebugType.Miss);
                     return null;
             }
 
diff --git a/osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs b/osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs
index a2408a92bb..784e57708e 100644
--- a/osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs
+++ b/osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs
@@ -30,6 +30,8 @@ namespace osu.Game.Skinning
             Lookup = lookup;
             ColumnIndex = columnIndex;
         }
+
+        public override string ToString() => $"[{nameof(LegacyManiaSkinConfigurationLookup)} lookup:{Lookup} col:{ColumnIndex} totalcols:{TotalColumns}]";
     }
 
     public enum LegacyManiaSkinConfigurationLookups
diff --git a/osu.Game/Skinning/LegacySkin.cs b/osu.Game/Skinning/LegacySkin.cs
index cf51fa8f74..76190d0abe 100644
--- a/osu.Game/Skinning/LegacySkin.cs
+++ b/osu.Game/Skinning/LegacySkin.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using JetBrains.Annotations;
@@ -29,13 +30,7 @@ namespace osu.Game.Skinning
 {
     public class LegacySkin : Skin
     {
-        /// <summary>
-        /// Whether texture for the keys exists.
-        /// Used to determine if the mania ruleset is skinned.
-        /// </summary>
-        private readonly Lazy<bool> hasKeyTexture;
-
-        protected virtual bool AllowManiaSkin => hasKeyTexture.Value;
+        protected virtual bool AllowManiaConfigLookups => true;
 
         /// <summary>
         /// Whether this skin can use samples with a custom bank (custom sample set in stable terminology).
@@ -61,10 +56,6 @@ namespace osu.Game.Skinning
         protected LegacySkin(SkinInfo skin, IStorageResourceProvider? resources, IResourceStore<byte[]>? storage, string configurationFilename = @"skin.ini")
             : base(skin, resources, storage, configurationFilename)
         {
-            // todo: this shouldn't really be duplicated here (from ManiaLegacySkinTransformer). we need to come up with a better solution.
-            hasKeyTexture = new Lazy<bool>(() => this.GetAnimation(
-                lookupForMania<string>(new LegacyManiaSkinConfigurationLookup(4, LegacyManiaSkinConfigurationLookups.KeyImage, 0))?.Value ?? "mania-key1", true,
-                true) != null);
         }
 
         protected override void ParseConfigurationStream(Stream stream)
@@ -82,50 +73,61 @@ namespace osu.Game.Skinning
             }
         }
 
+        [SuppressMessage("ReSharper", "RedundantAssignment")] // for `wasHit` assignments used in `finally` debug logic
         public override IBindable<TValue>? GetConfig<TLookup, TValue>(TLookup lookup)
         {
-            switch (lookup)
+            bool wasHit = true;
+
+            try
             {
-                case GlobalSkinColours colour:
-                    switch (colour)
-                    {
-                        case GlobalSkinColours.ComboColours:
-                            var comboColours = Configuration.ComboColours;
-                            if (comboColours != null)
-                                return SkinUtils.As<TValue>(new Bindable<IReadOnlyList<Color4>>(comboColours));
+                switch (lookup)
+                {
+                    case GlobalSkinColours colour:
+                        switch (colour)
+                        {
+                            case GlobalSkinColours.ComboColours:
+                                var comboColours = Configuration.ComboColours;
+                                if (comboColours != null)
+                                    return SkinUtils.As<TValue>(new Bindable<IReadOnlyList<Color4>>(comboColours));
 
-                            break;
+                                break;
 
-                        default:
-                            return SkinUtils.As<TValue>(getCustomColour(Configuration, colour.ToString()));
-                    }
+                            default:
+                                return SkinUtils.As<TValue>(getCustomColour(Configuration, colour.ToString()));
+                        }
 
-                    break;
-
-                case SkinComboColourLookup comboColour:
-                    return SkinUtils.As<TValue>(GetComboColour(Configuration, comboColour.ColourIndex, comboColour.Combo));
-
-                case SkinCustomColourLookup customColour:
-                    return SkinUtils.As<TValue>(getCustomColour(Configuration, customColour.Lookup.ToString() ?? string.Empty));
-
-                case LegacyManiaSkinConfigurationLookup maniaLookup:
-                    if (!AllowManiaSkin)
                         break;
 
-                    var result = lookupForMania<TValue>(maniaLookup);
-                    if (result != null)
-                        return result;
+                    case SkinComboColourLookup comboColour:
+                        return SkinUtils.As<TValue>(GetComboColour(Configuration, comboColour.ColourIndex, comboColour.Combo));
 
-                    break;
+                    case SkinCustomColourLookup customColour:
+                        return SkinUtils.As<TValue>(getCustomColour(Configuration, customColour.Lookup.ToString() ?? string.Empty));
 
-                case SkinConfiguration.LegacySetting legacy:
-                    return legacySettingLookup<TValue>(legacy);
+                    case LegacyManiaSkinConfigurationLookup maniaLookup:
+                        if (!AllowManiaConfigLookups)
+                            break;
 
-                default:
-                    return genericLookup<TLookup, TValue>(lookup);
+                        var result = lookupForMania<TValue>(maniaLookup);
+                        if (result != null)
+                            return result;
+
+                        break;
+
+                    case SkinConfiguration.LegacySetting legacy:
+                        return legacySettingLookup<TValue>(legacy);
+
+                    default:
+                        return genericLookup<TLookup, TValue>(lookup);
+                }
+
+                wasHit = false;
+                return null;
+            }
+            finally
+            {
+                LogLookupDebug(this, lookup, wasHit ? LookupDebugType.Hit : LookupDebugType.Miss);
             }
-
-            return null;
         }
 
         private IBindable<TValue>? lookupForMania<TValue>(LegacyManiaSkinConfigurationLookup maniaLookup)
diff --git a/osu.Game/Skinning/ResourceStoreBackedSkin.cs b/osu.Game/Skinning/ResourceStoreBackedSkin.cs
index f5c6192ba5..206c400a88 100644
--- a/osu.Game/Skinning/ResourceStoreBackedSkin.cs
+++ b/osu.Game/Skinning/ResourceStoreBackedSkin.cs
@@ -46,7 +46,10 @@ namespace osu.Game.Skinning
         public IBindable<TValue>? GetConfig<TLookup, TValue>(TLookup lookup)
             where TLookup : notnull
             where TValue : notnull
-            => null;
+        {
+            Skin.LogLookupDebug(this, lookup, Skin.LookupDebugType.Miss);
+            return null;
+        }
 
         public void Dispose()
         {
diff --git a/osu.Game/Skinning/Skin.cs b/osu.Game/Skinning/Skin.cs
index a6250d7488..659edc6f5f 100644
--- a/osu.Game/Skinning/Skin.cs
+++ b/osu.Game/Skinning/Skin.cs
@@ -6,10 +6,13 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
+using System.Threading;
 using Newtonsoft.Json;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Textures;
@@ -54,6 +57,8 @@ namespace osu.Game.Skinning
 
         private readonly RealmBackedResourceStore<SkinInfo>? realmBackedStorage;
 
+        public string Name { get; }
+
         /// <summary>
         /// Construct a new skin.
         /// </summary>
@@ -63,6 +68,8 @@ namespace osu.Game.Skinning
         /// <param name="configurationFilename">An optional filename to read the skin configuration from. If not provided, the configuration will be retrieved from the storage using "skin.ini".</param>
         protected Skin(SkinInfo skin, IStorageResourceProvider? resources, IResourceStore<byte[]>? storage = null, string configurationFilename = @"skin.ini")
         {
+            Name = skin.Name;
+
             if (resources != null)
             {
                 SkinInfo = skin.ToLive(resources.RealmAccess);
@@ -239,5 +246,50 @@ namespace osu.Game.Skinning
         }
 
         #endregion
+
+        public override string ToString() => $"{GetType().ReadableName()} {{ Name: {Name} }}";
+
+        private static readonly ThreadLocal<int> nested_level = new ThreadLocal<int>(() => 0);
+
+        [Conditional("SKIN_LOOKUP_DEBUG")]
+        internal static void LogLookupDebug(object callingClass, object lookup, LookupDebugType type, [CallerMemberName] string callerMethod = "")
+        {
+            string icon = string.Empty;
+            int level = nested_level.Value;
+
+            switch (type)
+            {
+                case LookupDebugType.Hit:
+                    icon = "🟢 hit";
+                    break;
+
+                case LookupDebugType.Miss:
+                    icon = "🔴 miss";
+                    break;
+
+                case LookupDebugType.Enter:
+                    nested_level.Value++;
+                    break;
+
+                case LookupDebugType.Exit:
+                    nested_level.Value--;
+                    if (nested_level.Value == 0)
+                        Logger.Log(string.Empty);
+                    return;
+            }
+
+            string lookupString = lookup.ToString() ?? string.Empty;
+            string callingClassString = callingClass.ToString() ?? string.Empty;
+
+            Logger.Log($"{string.Join(null, Enumerable.Repeat("|-", level))}{callingClassString}.{callerMethod}(lookup: {lookupString}) {icon}");
+        }
+
+        internal enum LookupDebugType
+        {
+            Hit,
+            Miss,
+            Enter,
+            Exit
+        }
     }
 }
diff --git a/osu.Game/Skinning/SkinManager.cs b/osu.Game/Skinning/SkinManager.cs
index 51605c6045..ca46d3af0c 100644
--- a/osu.Game/Skinning/SkinManager.cs
+++ b/osu.Game/Skinning/SkinManager.cs
@@ -261,13 +261,22 @@ namespace osu.Game.Skinning
         private T lookupWithFallback<T>(Func<ISkin, T> lookupFunction)
             where T : class
         {
-            foreach (var source in AllSources)
+            try
             {
-                if (lookupFunction(source) is T skinSourced)
-                    return skinSourced;
-            }
+                Skin.LogLookupDebug(this, lookupFunction, Skin.LookupDebugType.Enter);
 
-            return null;
+                foreach (var source in AllSources)
+                {
+                    if (lookupFunction(source) is T skinSourced)
+                        return skinSourced;
+                }
+
+                return null;
+            }
+            finally
+            {
+                Skin.LogLookupDebug(this, lookupFunction, Skin.LookupDebugType.Exit);
+            }
         }
 
         #region IResourceStorageProvider
diff --git a/osu.Game/Skinning/SkinProvidingContainer.cs b/osu.Game/Skinning/SkinProvidingContainer.cs
index 2612e0b47c..acb15da80e 100644
--- a/osu.Game/Skinning/SkinProvidingContainer.cs
+++ b/osu.Game/Skinning/SkinProvidingContainer.cs
@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Textures;
@@ -161,17 +162,26 @@ namespace osu.Game.Skinning
             where TLookup : notnull
             where TValue : notnull
         {
-            foreach (var (_, lookupWrapper) in skinSources)
+            try
             {
-                IBindable<TValue>? bindable;
-                if ((bindable = lookupWrapper.GetConfig<TLookup, TValue>(lookup)) != null)
-                    return bindable;
+                Skin.LogLookupDebug(this, lookup, Skin.LookupDebugType.Enter);
+
+                foreach (var (_, lookupWrapper) in skinSources)
+                {
+                    IBindable<TValue>? bindable;
+                    if ((bindable = lookupWrapper.GetConfig<TLookup, TValue>(lookup)) != null)
+                        return bindable;
+                }
+
+                if (!AllowFallingBackToParent)
+                    return null;
+
+                return ParentSource?.GetConfig<TLookup, TValue>(lookup);
+            }
+            finally
+            {
+                Skin.LogLookupDebug(this, lookup, Skin.LookupDebugType.Exit);
             }
-
-            if (!AllowFallingBackToParent)
-                return null;
-
-            return ParentSource?.GetConfig<TLookup, TValue>(lookup);
         }
 
         /// <summary>
@@ -271,25 +281,36 @@ namespace osu.Game.Skinning
                 where TLookup : notnull
                 where TValue : notnull
             {
-                switch (lookup)
+                try
                 {
-                    case GlobalSkinColours:
-                    case SkinComboColourLookup:
-                    case SkinCustomColourLookup:
-                        if (provider.AllowColourLookup)
-                            return skin.GetConfig<TLookup, TValue>(lookup);
+                    Skin.LogLookupDebug(this, lookup, Skin.LookupDebugType.Enter);
 
-                        break;
+                    switch (lookup)
+                    {
+                        case GlobalSkinColours:
+                        case SkinComboColourLookup:
+                        case SkinCustomColourLookup:
+                            if (provider.AllowColourLookup)
+                                return skin.GetConfig<TLookup, TValue>(lookup);
 
-                    default:
-                        if (provider.AllowConfigurationLookup)
-                            return skin.GetConfig<TLookup, TValue>(lookup);
+                            break;
 
-                        break;
+                        default:
+                            if (provider.AllowConfigurationLookup)
+                                return skin.GetConfig<TLookup, TValue>(lookup);
+
+                            break;
+                    }
+
+                    return null;
+                }
+                finally
+                {
+                    Skin.LogLookupDebug(this, lookup, Skin.LookupDebugType.Exit);
                 }
-
-                return null;
             }
+
+            public override string ToString() => $"{GetType().ReadableName()} {{ Skin: {skin} }}";
         }
     }
 }
diff --git a/osu.Game/Skinning/SkinTransformer.cs b/osu.Game/Skinning/SkinTransformer.cs
index ed5b04da1e..95572aa7b1 100644
--- a/osu.Game/Skinning/SkinTransformer.cs
+++ b/osu.Game/Skinning/SkinTransformer.cs
@@ -34,6 +34,19 @@ namespace osu.Game.Skinning
 
         public virtual ISample? GetSample(ISampleInfo sampleInfo) => Skin.GetSample(sampleInfo);
 
-        public virtual IBindable<TValue>? GetConfig<TLookup, TValue>(TLookup lookup) where TLookup : notnull where TValue : notnull => Skin.GetConfig<TLookup, TValue>(lookup);
+        public virtual IBindable<TValue>? GetConfig<TLookup, TValue>(TLookup lookup) where TLookup : notnull where TValue : notnull
+        {
+            try
+            {
+                Skinning.Skin.LogLookupDebug(this, lookup, Skinning.Skin.LookupDebugType.Enter);
+                return Skin.GetConfig<TLookup, TValue>(lookup);
+            }
+            finally
+            {
+                Skinning.Skin.LogLookupDebug(this, lookup, Skinning.Skin.LookupDebugType.Exit);
+            }
+        }
+
+        public override string ToString() => $"{nameof(SkinTransformer)} {{ Skin: {Skin} }}";
     }
 }
diff --git a/osu.Game/Skinning/TrianglesSkin.cs b/osu.Game/Skinning/TrianglesSkin.cs
index 0957f60579..a2dca5d333 100644
--- a/osu.Game/Skinning/TrianglesSkin.cs
+++ b/osu.Game/Skinning/TrianglesSkin.cs
@@ -190,15 +190,20 @@ namespace osu.Game.Skinning
                     switch (global)
                     {
                         case GlobalSkinColours.ComboColours:
+                        {
+                            LogLookupDebug(this, lookup, LookupDebugType.Hit);
                             return SkinUtils.As<TValue>(new Bindable<IReadOnlyList<Color4>?>(Configuration.ComboColours));
+                        }
                     }
 
                     break;
 
                 case SkinComboColourLookup comboColour:
+                    LogLookupDebug(this, lookup, LookupDebugType.Hit);
                     return SkinUtils.As<TValue>(new Bindable<Color4>(getComboColour(Configuration, comboColour.ColourIndex)));
             }
 
+            LogLookupDebug(this, lookup, LookupDebugType.Miss);
             return null;
         }
 
diff --git a/osu.Game/Users/Badge.cs b/osu.Game/Users/Badge.cs
index b87e2ddecd..42f2234744 100644
--- a/osu.Game/Users/Badge.cs
+++ b/osu.Game/Users/Badge.cs
@@ -16,9 +16,12 @@ namespace osu.Game.Users
         [JsonProperty("description")]
         public string Description;
 
-        [JsonProperty("image_url")]
+        [JsonProperty("image@2x_url")]
         public string ImageUrl;
 
+        [JsonProperty("image_url")]
+        public string ImageUrlLowRes;
+
         [JsonProperty("url")]
         public string Url;
     }
diff --git a/osu.Game/Users/Drawables/ClickableAvatar.cs b/osu.Game/Users/Drawables/ClickableAvatar.cs
index e74ffc9d54..677a8fff36 100644
--- a/osu.Game/Users/Drawables/ClickableAvatar.cs
+++ b/osu.Game/Users/Drawables/ClickableAvatar.cs
@@ -6,14 +6,13 @@ using osu.Framework.Allocation;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Game.Graphics.Containers;
+using osu.Game.Localisation;
 using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Users.Drawables
 {
     public partial class ClickableAvatar : OsuClickableContainer
     {
-        private const string default_tooltip_text = "view profile";
-
         public override LocalisableString TooltipText
         {
             get
@@ -21,7 +20,7 @@ namespace osu.Game.Users.Drawables
                 if (!Enabled.Value)
                     return string.Empty;
 
-                return ShowUsernameTooltip ? (user?.Username ?? string.Empty) : default_tooltip_text;
+                return ShowUsernameTooltip ? (user?.Username ?? string.Empty) : ContextMenuStrings.ViewProfile;
             }
             set => throw new NotSupportedException();
         }
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index cd57c33109..052528f93b 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -36,7 +36,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="11.1.2" />
-    <PackageReference Include="ppy.osu.Framework" Version="2023.823.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2023.904.0" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2023.822.0" />
     <PackageReference Include="Sentry" Version="3.28.1" />
     <PackageReference Include="SharpCompress" Version="0.32.2" />
diff --git a/osu.iOS.props b/osu.iOS.props
index d515a035da..760ea2e31e 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="2023.823.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2023.904.0" />
   </ItemGroup>
 </Project>