diff --git a/osu.Android.props b/osu.Android.props
index 8e383a705c..5bca6cc497 100644
--- a/osu.Android.props
+++ b/osu.Android.props
@@ -10,7 +10,7 @@
     <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.321.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.419.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.
diff --git a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs
index 1f05d66b86..d43290e661 100644
--- a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs
+++ b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmap.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
@@ -16,26 +17,30 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             int fruits = HitObjects.Count(s => s is Fruit);
             int juiceStreams = HitObjects.Count(s => s is JuiceStream);
             int bananaShowers = HitObjects.Count(s => s is BananaShower);
+            int sum = Math.Max(1, fruits + juiceStreams);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Fruit Count",
+                    Name = @"Fruits",
                     Content = fruits.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
+                    BarDisplayLength = fruits / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Juice Stream Count",
+                    Name = @"Juice Streams",
                     Content = juiceStreams.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
+                    BarDisplayLength = juiceStreams / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Banana Shower Count",
+                    Name = @"Banana Showers",
                     Content = bananaShowers.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
+                    BarDisplayLength = Math.Min(bananaShowers / 10f, 1),
                 }
             };
         }
diff --git a/osu.Game.Rulesets.Catch/Edit/Setup/CatchDifficultySection.cs b/osu.Game.Rulesets.Catch/Edit/Setup/CatchDifficultySection.cs
index 6ae60c4d24..98e30fa3cc 100644
--- a/osu.Game.Rulesets.Catch/Edit/Setup/CatchDifficultySection.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Setup/CatchDifficultySection.cs
@@ -75,6 +75,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Setup
                 {
                     Caption = EditorSetupStrings.BaseVelocity,
                     HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                     {
                         Default = 1.4,
@@ -89,6 +90,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,
diff --git a/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs b/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs
new file mode 100644
index 0000000000..24da447482
--- /dev/null
+++ b/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs
@@ -0,0 +1,187 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [TestFixture]
+    public class ManiaFilterCriteriaTest
+    {
+        [TestCase]
+        public void TestKeysEqualSingleValue()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "1");
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysEqualMultipleValues()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "1,3,5,7");
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysNotEqualSingleValue()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "1");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysNotEqualMultipleValues()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "1,3,5,7");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey1()]
+                }));
+        }
+
+        [TestCase]
+        public void TestKeysGreaterOrEqualThan()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 5 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria
+                {
+                    Mods = [new ManiaModKey7()]
+                }));
+        }
+
+        [TestCase]
+        public void TestFilterIntersection()
+        {
+            var criteria = new ManiaFilterCriteria();
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.Greater, "4");
+            criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "7");
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 4 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 5 }),
+                new FilterCriteria()));
+
+            Assert.False(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 7 }),
+                new FilterCriteria()));
+
+            Assert.True(criteria.Matches(
+                new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 9 }),
+                new FilterCriteria()));
+        }
+
+        [TestCase]
+        public void TestInvalidFilters()
+        {
+            var criteria = new ManiaFilterCriteria();
+
+            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "4,some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4,5,6"));
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs
new file mode 100644
index 0000000000..ea66386c9a
--- /dev/null
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneLegacyReplayPlayback.cs
@@ -0,0 +1,470 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
+    {
+        protected override Ruleset CreateRuleset() => new ManiaRuleset();
+
+        protected override string? ExportLocation => null;
+
+        private static readonly object[][] score_v2_test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // Note that mania hitwindows are heavily idiosyncratic,
+            // and if you *think* a number here is wrong, probably double check.
+
+            // Known issues / complexities:
+            // - There is a disparate set of hitwindow ranges for: score V1 non-converts, score V1 converts, and score V2 (regardless of convert)
+            // - It is NEVER POSSIBLE to get a MEH result when late; exceeding the OK hit windows will result in a MISS.
+            //   Additionally, the OK hit window when late is EXCLUSIVE / OPEN rather than INCLUSIVE / CLOSED.
+            //   Relevant stable source: https://github.com/peppy/osu-stable-reference/blob/996648fba06baf4e7d2e0b248959399444017895/osu!/GameplayElements/HitObjectManagerMania.cs#L737-L751
+            // - There is also a seemingly mania-specific issue wherein key inputs registered before time instant 0 get truncated to time 0,
+            //   which is why the beatmaps used below make sure not to cross that boundary (the note starts at t=300ms).
+            //   This is not an issue in osu! or taiko.
+            //   The source of this behaviour has not been investigated in detail.
+
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -19ms,  19ms]
+            // GREAT   hit window is [ -49ms,  49ms]
+            // GOOD    hit window is [ -82ms,  82ms]
+            // OK      hit window is [-112ms, 112ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-136ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -18d, HitResult.Perfect },
+            new object[] { 5f, -19d, HitResult.Perfect },
+            new object[] { 5f, -20d, HitResult.Great },
+            new object[] { 5f, -21d, HitResult.Great },
+            new object[] { 5f, -48d, HitResult.Great },
+            new object[] { 5f, -49d, HitResult.Great },
+            new object[] { 5f, -50d, HitResult.Good },
+            new object[] { 5f, -51d, HitResult.Good },
+            new object[] { 5f, -81d, HitResult.Good },
+            new object[] { 5f, -82d, HitResult.Good },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -84d, HitResult.Ok },
+            new object[] { 5f, -111d, HitResult.Ok },
+            new object[] { 5f, -112d, HitResult.Ok },
+            new object[] { 5f, -113d, HitResult.Meh },
+            new object[] { 5f, -114d, HitResult.Meh },
+            new object[] { 5f, -135d, HitResult.Meh },
+            new object[] { 5f, -136d, HitResult.Meh },
+            new object[] { 5f, -137d, HitResult.Miss },
+            new object[] { 5f, -138d, HitResult.Miss },
+            new object[] { 5f, 111d, HitResult.Ok },
+            new object[] { 5f, 112d, HitResult.Miss },
+            new object[] { 5f, 113d, HitResult.Miss },
+            new object[] { 5f, 114d, HitResult.Miss },
+            new object[] { 5f, 135d, HitResult.Miss },
+            new object[] { 5f, 136d, HitResult.Miss },
+            new object[] { 5f, 137d, HitResult.Miss },
+            new object[] { 5f, 138d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // PERFECT hit window is [ -14ms,  14ms]
+            // GREAT   hit window is [ -36ms,  36ms]
+            // GOOD    hit window is [ -69ms,  69ms]
+            // OK      hit window is [ -99ms,  99ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-123ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 9.3f, 13d, HitResult.Perfect },
+            new object[] { 9.3f, 14d, HitResult.Perfect },
+            new object[] { 9.3f, 15d, HitResult.Great },
+            new object[] { 9.3f, 16d, HitResult.Great },
+            new object[] { 9.3f, 35d, HitResult.Great },
+            new object[] { 9.3f, 36d, HitResult.Great },
+            new object[] { 9.3f, 37d, HitResult.Good },
+            new object[] { 9.3f, 38d, HitResult.Good },
+            new object[] { 9.3f, 68d, HitResult.Good },
+            new object[] { 9.3f, 69d, HitResult.Good },
+            new object[] { 9.3f, 70d, HitResult.Ok },
+            new object[] { 9.3f, 71d, HitResult.Ok },
+            new object[] { 9.3f, 98d, HitResult.Ok },
+            new object[] { 9.3f, 99d, HitResult.Miss },
+            new object[] { 9.3f, 100d, HitResult.Miss },
+            new object[] { 9.3f, 101d, HitResult.Miss },
+            new object[] { 9.3f, 122d, HitResult.Miss },
+            new object[] { 9.3f, 123d, HitResult.Miss },
+            new object[] { 9.3f, 124d, HitResult.Miss },
+            new object[] { 9.3f, 125d, HitResult.Miss },
+            new object[] { 9.3f, -98d, HitResult.Ok },
+            new object[] { 9.3f, -99d, HitResult.Ok },
+            new object[] { 9.3f, -100d, HitResult.Meh },
+            new object[] { 9.3f, -101d, HitResult.Meh },
+            new object[] { 9.3f, -122d, HitResult.Meh },
+            new object[] { 9.3f, -123d, HitResult.Meh },
+            new object[] { 9.3f, -124d, HitResult.Miss },
+            new object[] { 9.3f, -125d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_non_convert_test_cases =
+        {
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -49ms,  49ms]
+            // GOOD    hit window is [ -82ms,  82ms]
+            // OK      hit window is [-112ms, 112ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-136ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -15d, HitResult.Perfect },
+            new object[] { 5f, -16d, HitResult.Perfect },
+            new object[] { 5f, -17d, HitResult.Great },
+            new object[] { 5f, -18d, HitResult.Great },
+            new object[] { 5f, -48d, HitResult.Great },
+            new object[] { 5f, -49d, HitResult.Great },
+            new object[] { 5f, -50d, HitResult.Good },
+            new object[] { 5f, -51d, HitResult.Good },
+            new object[] { 5f, -81d, HitResult.Good },
+            new object[] { 5f, -82d, HitResult.Good },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -84d, HitResult.Ok },
+            new object[] { 5f, -111d, HitResult.Ok },
+            new object[] { 5f, -112d, HitResult.Ok },
+            new object[] { 5f, -113d, HitResult.Meh },
+            new object[] { 5f, -114d, HitResult.Meh },
+            new object[] { 5f, -135d, HitResult.Meh },
+            new object[] { 5f, -136d, HitResult.Meh },
+            new object[] { 5f, -137d, HitResult.Miss },
+            new object[] { 5f, -138d, HitResult.Miss },
+            new object[] { 5f, 111d, HitResult.Ok },
+            new object[] { 5f, 112d, HitResult.Miss },
+            new object[] { 5f, 113d, HitResult.Miss },
+            new object[] { 5f, 114d, HitResult.Miss },
+            new object[] { 5f, 135d, HitResult.Miss },
+            new object[] { 5f, 136d, HitResult.Miss },
+            new object[] { 5f, 137d, HitResult.Miss },
+            new object[] { 5f, 138d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -36ms,  36ms]
+            // GOOD    hit window is [ -69ms,  69ms]
+            // OK      hit window is [ -99ms,  99ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-123ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 9.3f, 15d, HitResult.Perfect },
+            new object[] { 9.3f, 16d, HitResult.Perfect },
+            new object[] { 9.3f, 17d, HitResult.Great },
+            new object[] { 9.3f, 18d, HitResult.Great },
+            new object[] { 9.3f, 35d, HitResult.Great },
+            new object[] { 9.3f, 36d, HitResult.Great },
+            new object[] { 9.3f, 37d, HitResult.Good },
+            new object[] { 9.3f, 38d, HitResult.Good },
+            new object[] { 9.3f, 68d, HitResult.Good },
+            new object[] { 9.3f, 69d, HitResult.Good },
+            new object[] { 9.3f, 70d, HitResult.Ok },
+            new object[] { 9.3f, 71d, HitResult.Ok },
+            new object[] { 9.3f, 98d, HitResult.Ok },
+            new object[] { 9.3f, 99d, HitResult.Miss },
+            new object[] { 9.3f, 100d, HitResult.Miss },
+            new object[] { 9.3f, 101d, HitResult.Miss },
+            new object[] { 9.3f, 122d, HitResult.Miss },
+            new object[] { 9.3f, 123d, HitResult.Miss },
+            new object[] { 9.3f, 124d, HitResult.Miss },
+            new object[] { 9.3f, 125d, HitResult.Miss },
+            new object[] { 9.3f, -98d, HitResult.Ok },
+            new object[] { 9.3f, -99d, HitResult.Ok },
+            new object[] { 9.3f, -100d, HitResult.Meh },
+            new object[] { 9.3f, -101d, HitResult.Meh },
+            new object[] { 9.3f, -122d, HitResult.Meh },
+            new object[] { 9.3f, -123d, HitResult.Meh },
+            new object[] { 9.3f, -124d, HitResult.Miss },
+            new object[] { 9.3f, -125d, HitResult.Miss },
+
+            // OD = 3.1 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -54ms,  54ms]
+            // GOOD    hit window is [ -87ms,  87ms]
+            // OK      hit window is [-117ms, 117ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-141ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 3.1f, 15d, HitResult.Perfect },
+            new object[] { 3.1f, 16d, HitResult.Perfect },
+            new object[] { 3.1f, 17d, HitResult.Great },
+            new object[] { 3.1f, 18d, HitResult.Great },
+            new object[] { 3.1f, 53d, HitResult.Great },
+            new object[] { 3.1f, 54d, HitResult.Great },
+            new object[] { 3.1f, 55d, HitResult.Good },
+            new object[] { 3.1f, 56d, HitResult.Good },
+            new object[] { 3.1f, 86d, HitResult.Good },
+            new object[] { 3.1f, 87d, HitResult.Good },
+            new object[] { 3.1f, 88d, HitResult.Ok },
+            new object[] { 3.1f, 89d, HitResult.Ok },
+            new object[] { 3.1f, 116d, HitResult.Ok },
+            new object[] { 3.1f, 117d, HitResult.Miss },
+            new object[] { 3.1f, 118d, HitResult.Miss },
+            new object[] { 3.1f, 119d, HitResult.Miss },
+            new object[] { 3.1f, 140d, HitResult.Miss },
+            new object[] { 3.1f, 141d, HitResult.Miss },
+            new object[] { 3.1f, 142d, HitResult.Miss },
+            new object[] { 3.1f, 143d, HitResult.Miss },
+            new object[] { 3.1f, -116d, HitResult.Ok },
+            new object[] { 3.1f, -117d, HitResult.Ok },
+            new object[] { 3.1f, -118d, HitResult.Meh },
+            new object[] { 3.1f, -119d, HitResult.Meh },
+            new object[] { 3.1f, -140d, HitResult.Meh },
+            new object[] { 3.1f, -141d, HitResult.Meh },
+            new object[] { 3.1f, -142d, HitResult.Miss },
+            new object[] { 3.1f, -143d, HitResult.Miss },
+        };
+
+        private static readonly object[][] score_v1_convert_test_cases =
+        {
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -34ms,  34ms]
+            // GOOD    hit window is [ -67ms,  67ms]
+            // OK      hit window is [ -97ms,  97ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-121ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 5f, -15d, HitResult.Perfect },
+            new object[] { 5f, -16d, HitResult.Perfect },
+            new object[] { 5f, -17d, HitResult.Great },
+            new object[] { 5f, -18d, HitResult.Great },
+            new object[] { 5f, -33d, HitResult.Great },
+            new object[] { 5f, -34d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Good },
+            new object[] { 5f, -36d, HitResult.Good },
+            new object[] { 5f, -66d, HitResult.Good },
+            new object[] { 5f, -67d, HitResult.Good },
+            new object[] { 5f, -68d, HitResult.Ok },
+            new object[] { 5f, -69d, HitResult.Ok },
+            new object[] { 5f, -96d, HitResult.Ok },
+            new object[] { 5f, -97d, HitResult.Ok },
+            new object[] { 5f, -98d, HitResult.Meh },
+            new object[] { 5f, -99d, HitResult.Meh },
+            new object[] { 5f, -120d, HitResult.Meh },
+            new object[] { 5f, -121d, HitResult.Meh },
+            new object[] { 5f, -122d, HitResult.Miss },
+            new object[] { 5f, -123d, HitResult.Miss },
+            new object[] { 5f, 96d, HitResult.Ok },
+            new object[] { 5f, 97d, HitResult.Miss },
+            new object[] { 5f, 98d, HitResult.Miss },
+            new object[] { 5f, 99d, HitResult.Miss },
+            new object[] { 5f, 120d, HitResult.Miss },
+            new object[] { 5f, 121d, HitResult.Miss },
+            new object[] { 5f, 122d, HitResult.Miss },
+            new object[] { 5f, 123d, HitResult.Miss },
+
+            // OD = 3.1 test cases.
+            // PERFECT hit window is [ -16ms,  16ms]
+            // GREAT   hit window is [ -47ms,  47ms]
+            // GOOD    hit window is [ -77ms,  77ms]
+            // OK      hit window is [ -97ms,  97ms) <- not a typo, this side of the interval is OPEN!
+            // MEH     hit window is [-121ms, -----) <- it is NOT POSSIBLE to get a MEH result on a late hit!
+            new object[] { 3.1f, 15d, HitResult.Perfect },
+            new object[] { 3.1f, 16d, HitResult.Perfect },
+            new object[] { 3.1f, 17d, HitResult.Great },
+            new object[] { 3.1f, 18d, HitResult.Great },
+            new object[] { 3.1f, 46d, HitResult.Great },
+            new object[] { 3.1f, 47d, HitResult.Great },
+            new object[] { 3.1f, 48d, HitResult.Good },
+            new object[] { 3.1f, 49d, HitResult.Good },
+            new object[] { 3.1f, 76d, HitResult.Good },
+            new object[] { 3.1f, 77d, HitResult.Good },
+            new object[] { 3.1f, 78d, HitResult.Ok },
+            new object[] { 3.1f, 79d, HitResult.Ok },
+            new object[] { 3.1f, 96d, HitResult.Ok },
+            new object[] { 3.1f, 97d, HitResult.Miss },
+            new object[] { 3.1f, 98d, HitResult.Miss },
+            new object[] { 3.1f, 99d, HitResult.Miss },
+            new object[] { 3.1f, 120d, HitResult.Miss },
+            new object[] { 3.1f, 121d, HitResult.Miss },
+            new object[] { 3.1f, 122d, HitResult.Miss },
+            new object[] { 3.1f, 123d, HitResult.Miss },
+            new object[] { 3.1f, -96d, HitResult.Ok },
+            new object[] { 3.1f, -97d, HitResult.Ok },
+            new object[] { 3.1f, -98d, HitResult.Meh },
+            new object[] { 3.1f, -99d, HitResult.Meh },
+            new object[] { 3.1f, -120d, HitResult.Meh },
+            new object[] { 3.1f, -121d, HitResult.Meh },
+            new object[] { 3.1f, -122d, HitResult.Miss },
+            new object[] { 3.1f, -123d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(score_v2_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV2(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double note_time = 300;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new ManiaBeatmap(new StageDefinition(1))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = note_time,
+                        Column = 0,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                    CircleSize = 1,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ModScoreV2()]
+                }
+            };
+
+            RunTest($@"SV2 single note @ OD{overallDifficulty}", beatmap, $@"SV2 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_non_convert_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1NonConvert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double note_time = 300;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new ManiaBeatmap(new StageDefinition(1))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = note_time,
+                        Column = 0,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                    CircleSize = 1,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                }
+            };
+
+            RunTest($@"SV1 single note @ OD{overallDifficulty}", beatmap, $@"SV1 {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        [TestCaseSource(nameof(score_v1_convert_test_cases))]
+        public void TestHitWindowTreatmentWithScoreV1Convert(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double note_time = 300;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new Beatmap
+            {
+                HitObjects =
+                {
+                    new FakeCircle
+                    {
+                        StartTime = note_time,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new RulesetInfo { OnlineID = 0 }
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                    Mods = [new ManiaModKey1()],
+                }
+            };
+
+            RunTest($@"SV1 convert single note @ OD{overallDifficulty}", beatmap, $@"SV1 convert {hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+
+        private class FakeCircle : HitObject, IHasPosition
+        {
+            public float X
+            {
+                get => Position.X;
+                set => Position = new Vector2(value, Position.Y);
+            }
+
+            public float Y
+            {
+                get => Position.Y;
+                set => Position = new Vector2(Position.X, value);
+            }
+
+            public Vector2 Position { get; set; }
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneReplayStability.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneReplayStability.cs
new file mode 100644
index 0000000000..64496d7628
--- /dev/null
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneReplayStability.cs
@@ -0,0 +1,149 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneReplayStability : ReplayStabilityTestScene
+    {
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // OD = 5 test cases.
+            // PERFECT hit window is [ -19.4ms,  19.4ms]
+            // GREAT   hit window is [ -49.0ms,  49.0ms]
+            // GOOD    hit window is [ -82.0ms,  82.0ms]
+            // OK      hit window is [-112.0ms, 112.0ms]
+            // MEH     hit window is [-136.0ms, 136.0ms]
+            // MISS    hit window is [-173.0ms, 173.0ms]
+            new object[] { 5f, -19d, HitResult.Perfect },
+            new object[] { 5f, -19.2d, HitResult.Perfect },
+            new object[] { 5f, -19.38d, HitResult.Perfect },
+            // new object[] { 5f, -19.4d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
+            new object[] { 5f, -19.44d, HitResult.Great },
+            new object[] { 5f, -19.7d, HitResult.Great },
+            new object[] { 5f, -20d, HitResult.Great },
+            new object[] { 5f, -48d, HitResult.Great },
+            new object[] { 5f, -48.4d, HitResult.Great },
+            new object[] { 5f, -48.7d, HitResult.Great },
+            new object[] { 5f, -49d, HitResult.Great },
+            new object[] { 5f, -49.2d, HitResult.Good },
+            new object[] { 5f, -49.7d, HitResult.Good },
+            new object[] { 5f, -50d, HitResult.Good },
+            new object[] { 5f, -81d, HitResult.Good },
+            new object[] { 5f, -81.2d, HitResult.Good },
+            new object[] { 5f, -81.7d, HitResult.Good },
+            new object[] { 5f, -82d, HitResult.Good },
+            new object[] { 5f, -82.2d, HitResult.Ok },
+            new object[] { 5f, -82.7d, HitResult.Ok },
+            new object[] { 5f, -83d, HitResult.Ok },
+            new object[] { 5f, -111d, HitResult.Ok },
+            new object[] { 5f, -111.2d, HitResult.Ok },
+            new object[] { 5f, -111.7d, HitResult.Ok },
+            new object[] { 5f, -112d, HitResult.Ok },
+            new object[] { 5f, -112.2d, HitResult.Meh },
+            new object[] { 5f, -112.7d, HitResult.Meh },
+            new object[] { 5f, -113d, HitResult.Meh },
+            new object[] { 5f, -135d, HitResult.Meh },
+            new object[] { 5f, -135.2d, HitResult.Meh },
+            new object[] { 5f, -135.8d, HitResult.Meh },
+            new object[] { 5f, -136d, HitResult.Meh },
+            new object[] { 5f, -136.2d, HitResult.Miss },
+            new object[] { 5f, -136.7d, HitResult.Miss },
+            new object[] { 5f, -137d, HitResult.Miss },
+
+            // OD = 9.3 test cases.
+            // PERFECT hit window is [ -14.67ms,  14.67ms]
+            // GREAT   hit window is [ -36.10ms,  36.10ms]
+            // GOOD    hit window is [ -69.10ms,  69.10ms]
+            // OK      hit window is [ -99.10ms,  99.10ms]
+            // MEH     hit window is [-123.10ms, 123.10ms]
+            // MISS    hit window is [-160.10ms, 160.10ms]
+            new object[] { 9.3f, 14d, HitResult.Perfect },
+            new object[] { 9.3f, 14.2d, HitResult.Perfect },
+            new object[] { 9.3f, 14.6d, HitResult.Perfect },
+            // new object[] { 9.3f, 14.67d, HitResult.Perfect }, <- in theory this should work, in practice it does not (fails even before encode & rounding due to floating point precision issues)
+            new object[] { 9.3f, 14.7d, HitResult.Great },
+            new object[] { 9.3f, 15d, HitResult.Great },
+            new object[] { 9.3f, 35d, HitResult.Great },
+            new object[] { 9.3f, 35.3d, HitResult.Great },
+            new object[] { 9.3f, 35.8d, HitResult.Great },
+            new object[] { 9.3f, 36.05d, HitResult.Great },
+            new object[] { 9.3f, 36.3d, HitResult.Good },
+            new object[] { 9.3f, 36.7d, HitResult.Good },
+            new object[] { 9.3f, 37d, HitResult.Good },
+            new object[] { 9.3f, 68d, HitResult.Good },
+            new object[] { 9.3f, 68.4d, HitResult.Good },
+            new object[] { 9.3f, 68.9d, HitResult.Good },
+            new object[] { 9.3f, 69.07d, HitResult.Good },
+            new object[] { 9.3f, 69.25d, HitResult.Ok },
+            new object[] { 9.3f, 69.85d, HitResult.Ok },
+            new object[] { 9.3f, 70d, HitResult.Ok },
+            new object[] { 9.3f, 98d, HitResult.Ok },
+            new object[] { 9.3f, 98.3d, HitResult.Ok },
+            new object[] { 9.3f, 98.6d, HitResult.Ok },
+            new object[] { 9.3f, 99d, HitResult.Ok },
+            new object[] { 9.3f, 99.3d, HitResult.Meh },
+            new object[] { 9.3f, 99.7d, HitResult.Meh },
+            new object[] { 9.3f, 100d, HitResult.Meh },
+            new object[] { 9.3f, 122d, HitResult.Meh },
+            new object[] { 9.3f, 122.34d, HitResult.Meh },
+            new object[] { 9.3f, 122.57d, HitResult.Meh },
+            new object[] { 9.3f, 123.04d, HitResult.Meh },
+            new object[] { 9.3f, 123.45d, HitResult.Miss },
+            new object[] { 9.3f, 123.95d, HitResult.Miss },
+            new object[] { 9.3f, 124d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowStability(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double note_time = 100;
+
+            var beatmap = new ManiaBeatmap(new StageDefinition(1))
+            {
+                HitObjects =
+                {
+                    new Note
+                    {
+                        StartTime = note_time,
+                        Column = 0,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty
+                {
+                    OverallDifficulty = overallDifficulty,
+                    CircleSize = 1,
+                },
+                BeatmapInfo =
+                {
+                    Ruleset = new ManiaRuleset().RulesetInfo,
+                },
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new ManiaReplayFrame(0),
+                    new ManiaReplayFrame(note_time + hitOffset, ManiaAction.Key1),
+                    new ManiaReplayFrame(note_time + hitOffset + 20),
+                }
+            };
+
+            RunTest(beatmap, replay, [expectedResult]);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs
index 8222e5477d..3ee1b63800 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs
@@ -36,20 +36,23 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         {
             int notes = HitObjects.Count(s => s is Note);
             int holdNotes = HitObjects.Count(s => s is HoldNote);
+            int sum = Math.Max(1, notes + holdNotes);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Note Count",
+                    Name = @"Notes",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     Content = notes.ToString(),
+                    BarDisplayLength = notes / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Hold Note Count",
+                    Name = @"Hold Notes",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     Content = holdNotes.ToString(),
+                    BarDisplayLength = holdNotes / (float)sum,
                 },
             };
         }
diff --git a/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs b/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
index 5242b6685c..b999a521d5 100644
--- a/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
+++ b/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.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;
 using osu.Framework.Configuration.Tracking;
 using osu.Game.Configuration;
 using osu.Game.Localisation;
@@ -25,17 +24,6 @@ namespace osu.Game.Rulesets.Mania.Configuration
             SetDefault(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
             SetDefault(ManiaRulesetSetting.TimingBasedNoteColouring, false);
             SetDefault(ManiaRulesetSetting.MobileLayout, ManiaMobileLayout.Portrait);
-
-#pragma warning disable CS0618
-            // Although obsolete, this is still required to populate the bindable from the database in case migration is required.
-            SetDefault<double?>(ManiaRulesetSetting.ScrollTime, null);
-
-            if (Get<double?>(ManiaRulesetSetting.ScrollTime) is double scrollTime)
-            {
-                SetValue(ManiaRulesetSetting.ScrollSpeed, Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime));
-                SetValue<double?>(ManiaRulesetSetting.ScrollTime, null);
-            }
-#pragma warning restore CS0618
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
@@ -52,8 +40,6 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
     public enum ManiaRulesetSetting
     {
-        [Obsolete("Use ScrollSpeed instead.")] // Can be removed 2023-11-30
-        ScrollTime,
         ScrollSpeed,
         ScrollDirection,
         TimingBasedNoteColouring,
diff --git a/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs b/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
index a5c3c2264c..835a37e064 100644
--- a/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
@@ -89,6 +89,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
                 {
                     Caption = EditorSetupStrings.BaseVelocity,
                     HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                     {
                         Default = 1.4,
@@ -103,6 +104,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,
diff --git a/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs b/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
index 8c6efbc72d..9b2700c6e8 100644
--- a/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
+++ b/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets.Filter;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
@@ -17,20 +18,72 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaFilterCriteria : IRulesetFilterCriteria
     {
-        private FilterCriteria.OptionalRange<float> keys;
+        private readonly HashSet<int> includedKeyCounts = Enumerable.Range(1, LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT).ToHashSet();
 
         public bool Matches(BeatmapInfo beatmapInfo, FilterCriteria criteria)
         {
-            return !keys.HasFilter || keys.IsInRange(ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods));
+            int keyCount = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods);
+
+            return includedKeyCounts.Contains(keyCount);
         }
 
-        public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)
+        public bool TryParseCustomKeywordCriteria(string key, Operator op, string strValues)
         {
             switch (key)
             {
                 case "key":
                 case "keys":
-                    return FilterQueryParser.TryUpdateCriteriaRange(ref keys, op, value);
+                {
+                    var keyCounts = new HashSet<int>();
+
+                    foreach (string strValue in strValues.Split(','))
+                    {
+                        if (!int.TryParse(strValue, out int keyCount))
+                            return false;
+
+                        keyCounts.Add(keyCount);
+                    }
+
+                    int? singleKeyCount = keyCounts.Count == 1 ? keyCounts.Single() : null;
+
+                    switch (op)
+                    {
+                        case Operator.Equal:
+                            includedKeyCounts.IntersectWith(keyCounts);
+                            return true;
+
+                        case Operator.NotEqual:
+                            includedKeyCounts.ExceptWith(keyCounts);
+                            return true;
+
+                        case Operator.Less:
+                            if (singleKeyCount == null) return false;
+
+                            includedKeyCounts.RemoveWhere(k => k >= singleKeyCount.Value);
+                            return true;
+
+                        case Operator.LessOrEqual:
+                            if (singleKeyCount == null) return false;
+
+                            includedKeyCounts.RemoveWhere(k => k > singleKeyCount.Value);
+                            return true;
+
+                        case Operator.Greater:
+                            if (singleKeyCount == null) return false;
+
+                            includedKeyCounts.RemoveWhere(k => k <= singleKeyCount.Value);
+                            return true;
+
+                        case Operator.GreaterOrEqual:
+                            if (singleKeyCount == null) return false;
+
+                            includedKeyCounts.RemoveWhere(k => k < singleKeyCount.Value);
+                            return true;
+
+                        default:
+                            return false;
+                    }
+                }
             }
 
             return false;
@@ -38,7 +91,7 @@ namespace osu.Game.Rulesets.Mania
 
         public bool FilterMayChangeFromMods(ValueChangedEvent<IReadOnlyList<Mod>> mods)
         {
-            if (keys.HasFilter)
+            if (includedKeyCounts.Count != LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT)
             {
                 // Interpreting as the Mod type is required for equality comparison.
                 HashSet<Mod> oldSet = mods.OldValue.OfType<ManiaKeyMod>().AsEnumerable<Mod>().ToHashSet();
diff --git a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
index 66400b0a55..fe3535d857 100644
--- a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
@@ -60,8 +60,9 @@ namespace osu.Game.Rulesets.Mania.UI
         private readonly BindableDouble configScrollSpeed = new BindableDouble();
         private readonly Bindable<ManiaMobileLayout> mobileLayout = new Bindable<ManiaMobileLayout>();
 
+        public double TargetTimeRange { get; protected set; }
+
         private double currentTimeRange;
-        protected double TargetTimeRange;
 
         // Stores the current speed adjustment active in gameplay.
         private readonly Track speedAdjustmentTrack = new TrackVirtual(0);
@@ -109,7 +110,13 @@ namespace osu.Game.Rulesets.Mania.UI
             configDirection.BindValueChanged(direction => Direction.Value = (ScrollingDirection)direction.NewValue, true);
 
             Config.BindWith(ManiaRulesetSetting.ScrollSpeed, configScrollSpeed);
-            configScrollSpeed.BindValueChanged(speed => TargetTimeRange = ComputeScrollTime(speed.NewValue));
+            configScrollSpeed.BindValueChanged(speed =>
+            {
+                if (!AllowScrollSpeedAdjustment)
+                    return;
+
+                TargetTimeRange = ComputeScrollTime(speed.NewValue);
+            });
 
             TimeRange.Value = TargetTimeRange = currentTimeRange = ComputeScrollTime(configScrollSpeed.Value);
 
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyReplayPlayback.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyReplayPlayback.cs
new file mode 100644
index 0000000000..c22255bbdf
--- /dev/null
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneLegacyReplayPlayback.cs
@@ -0,0 +1,118 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
+    {
+        protected override Ruleset CreateRuleset() => new OsuRuleset();
+
+        protected override string? ExportLocation => null;
+
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+            // Additionally, note that offsets provided in double will be rounded to the nearest integer.
+
+            // OD = 5 test cases.
+            // GREAT hit window is ( -50ms,  50ms)
+            // OK    hit window is (-100ms, 100ms)
+            // MEH   hit window is (-150ms, 150ms)
+            new object[] { 5f, 48d, HitResult.Great },
+            new object[] { 5f, 49d, HitResult.Great },
+            new object[] { 5f, 50d, HitResult.Ok },
+            new object[] { 5f, 51d, HitResult.Ok },
+            new object[] { 5f, 98d, HitResult.Ok },
+            new object[] { 5f, 99d, HitResult.Ok },
+            new object[] { 5f, 100d, HitResult.Meh },
+            new object[] { 5f, 101d, HitResult.Meh },
+            new object[] { 5f, 148d, HitResult.Meh },
+            new object[] { 5f, 149d, HitResult.Meh },
+            new object[] { 5f, 150d, HitResult.Miss },
+            new object[] { 5f, 151d, HitResult.Miss },
+
+            // OD = 5.7 test cases.
+            // GREAT hit window is ( -45ms,  45ms)
+            // OK    hit window is ( -94ms,  94ms)
+            // MEH   hit window is (-143ms, 143ms)
+            new object[] { 5.7f, 43d, HitResult.Great },
+            new object[] { 5.7f, 44d, HitResult.Great },
+            new object[] { 5.7f, 45d, HitResult.Ok },
+            new object[] { 5.7f, 46d, HitResult.Ok },
+            new object[] { 5.7f, 92d, HitResult.Ok },
+            new object[] { 5.7f, 93d, HitResult.Ok },
+            new object[] { 5.7f, 94d, HitResult.Meh },
+            new object[] { 5.7f, 95d, HitResult.Meh },
+            new object[] { 5.7f, 141d, HitResult.Meh },
+            new object[] { 5.7f, 142d, HitResult.Meh },
+            new object[] { 5.7f, 143d, HitResult.Miss },
+            new object[] { 5.7f, 144d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowTreatment(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double hit_circle_time = 100;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new OsuBeatmap
+            {
+                HitObjects =
+                {
+                    new HitCircle
+                    {
+                        StartTime = hit_circle_time,
+                        Position = OsuPlayfield.BASE_SIZE / 2
+                    }
+                },
+                Difficulty = new BeatmapDifficulty { OverallDifficulty = overallDifficulty },
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    // required for correct playback in stable
+                    new OsuReplayFrame(0, new Vector2(256, -500)),
+                    new OsuReplayFrame(0, new Vector2(256, -500)),
+                    new OsuReplayFrame(0, OsuPlayfield.BASE_SIZE / 2),
+                    new OsuReplayFrame(hit_circle_time + hitOffset, OsuPlayfield.BASE_SIZE / 2, OsuAction.LeftButton),
+                    new OsuReplayFrame(hit_circle_time + hitOffset + 20, OsuPlayfield.BASE_SIZE / 2),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                }
+            };
+
+            RunTest($@"single circle @ OD{overallDifficulty}", beatmap, $@"{hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneReplayStability.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneReplayStability.cs
new file mode 100644
index 0000000000..2303b17d96
--- /dev/null
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneReplayStability.cs
@@ -0,0 +1,113 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneReplayStability : ReplayStabilityTestScene
+    {
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // OD = 5 test cases.
+            // GREAT hit window is [ -50ms,  50ms]
+            // OK    hit window is [-100ms, 100ms]
+            // MEH   hit window is [-150ms, 150ms]
+            // MISS  hit window is [-400ms, 400ms]
+            new object[] { 5f, 49d, HitResult.Great },
+            new object[] { 5f, 49.2d, HitResult.Great },
+            new object[] { 5f, 49.7d, HitResult.Great },
+            new object[] { 5f, 50d, HitResult.Great },
+            new object[] { 5f, 50.4d, HitResult.Ok },
+            new object[] { 5f, 50.9d, HitResult.Ok },
+            new object[] { 5f, 51d, HitResult.Ok },
+            new object[] { 5f, 99d, HitResult.Ok },
+            new object[] { 5f, 99.2d, HitResult.Ok },
+            new object[] { 5f, 99.7d, HitResult.Ok },
+            new object[] { 5f, 100d, HitResult.Ok },
+            new object[] { 5f, 100.4d, HitResult.Meh },
+            new object[] { 5f, 100.9d, HitResult.Meh },
+            new object[] { 5f, 101d, HitResult.Meh },
+            new object[] { 5f, 149d, HitResult.Meh },
+            new object[] { 5f, 149.2d, HitResult.Meh },
+            new object[] { 5f, 149.7d, HitResult.Meh },
+            new object[] { 5f, 150d, HitResult.Meh },
+            new object[] { 5f, 150.4d, HitResult.Miss },
+            new object[] { 5f, 150.9d, HitResult.Miss },
+            new object[] { 5f, 151d, HitResult.Miss },
+
+            // OD = 5.7 test cases.
+            // GREAT hit window is [ -45.8ms,  45.8ms]
+            // OK    hit window is [ -94.4ms,  94.4ms]
+            // MEH   hit window is [-143.0ms, 143.0ms]
+            // MISS  hit window is [-400.0ms, 400.0ms]
+            new object[] { 5.7f, 45d, HitResult.Great },
+            new object[] { 5.7f, 45.2d, HitResult.Great },
+            new object[] { 5.7f, 45.8d, HitResult.Great },
+            new object[] { 5.7f, 45.9d, HitResult.Ok },
+            new object[] { 5.7f, 46d, HitResult.Ok },
+            new object[] { 5.7f, 46.4d, HitResult.Ok },
+            new object[] { 5.7f, 94d, HitResult.Ok },
+            new object[] { 5.7f, 94.2d, HitResult.Ok },
+            new object[] { 5.7f, 94.4d, HitResult.Ok },
+            new object[] { 5.7f, 94.48d, HitResult.Ok },
+            new object[] { 5.7f, 94.9d, HitResult.Meh },
+            new object[] { 5.7f, 95d, HitResult.Meh },
+            new object[] { 5.7f, 95.4d, HitResult.Meh },
+            new object[] { 5.7f, 142d, HitResult.Meh },
+            new object[] { 5.7f, 142.7d, HitResult.Meh },
+            new object[] { 5.7f, 143d, HitResult.Meh },
+            new object[] { 5.7f, 143.4d, HitResult.Miss },
+            new object[] { 5.7f, 143.9d, HitResult.Miss },
+            new object[] { 5.7f, 144d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowStability(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double hit_circle_time = 100;
+
+            var beatmap = new OsuBeatmap
+            {
+                HitObjects =
+                {
+                    new HitCircle
+                    {
+                        StartTime = hit_circle_time,
+                        Position = OsuPlayfield.BASE_SIZE / 2
+                    }
+                },
+                Difficulty = new BeatmapDifficulty { OverallDifficulty = overallDifficulty },
+                BeatmapInfo =
+                {
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                },
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new OsuReplayFrame(0, OsuPlayfield.BASE_SIZE / 2),
+                    new OsuReplayFrame(hit_circle_time + hitOffset, OsuPlayfield.BASE_SIZE / 2, OsuAction.LeftButton),
+                    new OsuReplayFrame(hit_circle_time + hitOffset + 20, OsuPlayfield.BASE_SIZE / 2),
+                }
+            };
+
+            RunTest(beatmap, replay, [expectedResult]);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs
index 77b16dd0c5..2e082c292b 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs
@@ -86,9 +86,12 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Test]
         public void TestSpinningSamplePitchShift()
         {
+            PausableSkinnableSound spinSample = null;
+
             AddStep("Add spinner", () => SetContents(_ => testSingle(5, true, 4000)));
-            AddUntilStep("Pitch starts low", () => getSpinningSample().Frequency.Value < 0.8);
-            AddUntilStep("Pitch increases", () => getSpinningSample().Frequency.Value > 0.8);
+            AddUntilStep("wait for spin sample", () => (spinSample = getSpinningSample()) != null);
+            AddUntilStep("Pitch starts low", () => spinSample.Frequency.Value < 0.8);
+            AddUntilStep("Pitch increases", () => spinSample.Frequency.Value > 0.8);
 
             PausableSkinnableSound getSpinningSample() =>
                 drawableSpinner.ChildrenOfType<PausableSkinnableSound>().FirstOrDefault(s => s.Samples.Any(i => i.LookupNames.Any(l => l.Contains("spinnerspin"))));
diff --git a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs
index a5282877ee..d11b4aac3b 100644
--- a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs
+++ b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmap.cs
@@ -1,10 +1,10 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
-using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Beatmaps
@@ -16,26 +16,30 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
             int circles = HitObjects.Count(c => c is HitCircle);
             int sliders = HitObjects.Count(s => s is Slider);
             int spinners = HitObjects.Count(s => s is Spinner);
+            int sum = Math.Max(1, circles + sliders);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = BeatmapsetsStrings.ShowStatsCountCircles,
+                    Name = "Circles",
                     Content = circles.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
+                    BarDisplayLength = circles / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = BeatmapsetsStrings.ShowStatsCountSliders,
+                    Name = "Sliders",
                     Content = sliders.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
+                    BarDisplayLength = sliders / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Spinner Count",
+                    Name = @"Spinners",
                     Content = spinners.ToString(),
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
+                    BarDisplayLength = Math.Min(spinners / 10f, 1),
                 }
             };
         }
diff --git a/osu.Game.Rulesets.Osu/Edit/PolygonGenerationPopover.cs b/osu.Game.Rulesets.Osu/Edit/PolygonGenerationPopover.cs
index 695ff516b1..046f57c0a5 100644
--- a/osu.Game.Rulesets.Osu/Edit/PolygonGenerationPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PolygonGenerationPopover.cs
@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                         Current = new BindableNumber<int>(3)
                         {
                             MinValue = 3,
-                            MaxValue = 10,
+                            MaxValue = 32,
                             Precision = 1,
                         },
                         Instantaneous = true
diff --git a/osu.Game.Rulesets.Osu/Edit/Setup/OsuDifficultySection.cs b/osu.Game.Rulesets.Osu/Edit/Setup/OsuDifficultySection.cs
index 45e3f3ac49..3ed1d82883 100644
--- a/osu.Game.Rulesets.Osu/Edit/Setup/OsuDifficultySection.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Setup/OsuDifficultySection.cs
@@ -91,6 +91,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
                 {
                     Caption = EditorSetupStrings.BaseVelocity,
                     HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                     {
                         Default = 1.4,
@@ -105,6 +106,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,
@@ -119,6 +121,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
                 {
                     Caption = "Stack Leniency",
                     HintText = "In play mode, osu! automatically stacks notes which occur at the same location. Increasing this value means it is more likely to snap notes of further time-distance.",
+                    KeyboardStep = 0.1f,
                     Current = new BindableFloat(Beatmap.StackLeniency)
                     {
                         Default = 0.7f,
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModSpunOut.cs b/osu.Game.Rulesets.Osu/Mods/OsuModSpunOut.cs
index 992f4d5f03..222cf4242a 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModSpunOut.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModSpunOut.cs
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             var spinner = (DrawableSpinner)drawable;
 
-            spinner.RotationTracker.Tracking = true;
+            spinner.RotationTracker.Tracking = spinner.RotationTracker.IsSpinnableTime;
 
             // early-return if we were paused to avoid division-by-zero in the subsequent calculations.
             if (Precision.AlmostEquals(spinner.Clock.Rate, 0))
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
index b3a68ec92d..b29be97951 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -149,5 +150,24 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected float CalculateDrawableRelativePosition(Drawable drawable) => (drawable.ScreenSpaceDrawQuad.Centre.X - parentScreenSpaceRectangle.X) / parentScreenSpaceRectangle.Width;
 
         protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(HitObject, judgement);
+
+        protected void ApplyRepeatFadeIn(Drawable target, double fadeTime)
+        {
+            DrawableSlider slider = (DrawableSlider)ParentHitObject;
+            int repeatIndex = ((SliderEndCircle)HitObject).RepeatIndex;
+
+            Debug.Assert(slider != null);
+
+            // When snaking in is enabled, the first end circle needs to be delayed until the snaking completes.
+            bool delayFadeIn = slider.SliderBody?.SnakingIn.Value == true && repeatIndex == 0;
+
+            if (repeatIndex > 0)
+                fadeTime = Math.Min(slider.HitObject.SpanDuration, fadeTime);
+
+            target
+                .FadeOut()
+                .Delay(delayFadeIn ? (slider.HitObject.TimePreempt) / 3 : 0)
+                .FadeIn(fadeTime);
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderRepeat.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderRepeat.cs
index bc48f34828..8205483f82 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderRepeat.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderRepeat.cs
@@ -27,8 +27,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public DrawableSlider DrawableSlider => (DrawableSlider)ParentHitObject;
 
-        private double animDuration;
-
         public SkinnableDrawable CirclePiece { get; private set; }
 
         public SkinnableDrawable Arrow { get; private set; }
@@ -87,21 +85,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateInitialTransforms()
         {
-            // When snaking in is enabled, the first end circle needs to be delayed until the snaking completes.
-            bool delayFadeIn = DrawableSlider.SliderBody?.SnakingIn.Value == true && HitObject.RepeatIndex == 0;
+            base.UpdateInitialTransforms();
 
-            animDuration = Math.Min(300, HitObject.SpanDuration);
-
-            this
-                .FadeOut()
-                .Delay(delayFadeIn ? (Slider?.TimePreempt ?? 0) / 3 : 0)
-                .FadeIn(HitObject.RepeatIndex == 0 ? HitObject.TimeFadeIn : animDuration);
+            ApplyRepeatFadeIn(CirclePiece, HitObject.TimeFadeIn);
+            ApplyRepeatFadeIn(Arrow, 150);
         }
 
         protected override void UpdateHitStateTransforms(ArmedState state)
         {
             base.UpdateHitStateTransforms(state);
 
+            double animDuration = Math.Min(300, HitObject.SpanDuration);
+
             switch (state)
             {
                 case ArmedState.Idle:
@@ -181,10 +176,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 // More or less matches stable (see https://github.com/peppy/osu-stable-reference/blob/bb57924c1552adbed11ee3d96cdcde47cf96f2b6/osu!/GameplayElements/HitObjects/Osu/HitCircleOsu.cs#L336-L338)
                 AccentColour.Value = Color4.White;
                 Alpha = Interpolation.ValueAt(Time.Current, 1f, 0f, HitStateUpdateTime, HitStateUpdateTime + 700);
+                Arrow.Alpha = 0;
             }
 
-            Arrow.Alpha = hit ? 0 : 1;
-
             LifetimeEnd = HitStateUpdateTime + 700;
         }
 
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
index 8bb1b0aebc..e9f6f105bb 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
@@ -86,13 +86,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             base.UpdateInitialTransforms();
 
-            // When snaking in is enabled, the first end circle needs to be delayed until the snaking completes.
-            bool delayFadeIn = DrawableSlider.SliderBody?.SnakingIn.Value == true && HitObject.RepeatIndex == 0;
-
-            CirclePiece
-                .FadeOut()
-                .Delay(delayFadeIn ? (Slider?.TimePreempt ?? 0) / 3 : 0)
-                .FadeIn(HitObject.TimeFadeIn);
+            ApplyRepeatFadeIn(CirclePiece, HitObject.TimeFadeIn);
         }
 
         protected override void UpdateHitStateTransforms(ArmedState state)
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index 8c21e6a6bc..64cedd216b 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -277,13 +277,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             base.Update();
 
             if (HandleUserInput)
-            {
-                bool isValidSpinningTime = Time.Current >= HitObject.StartTime && Time.Current <= HitObject.EndTime;
-
-                RotationTracker.Tracking = !Result.HasResult
-                                           && correctButtonPressed()
-                                           && isValidSpinningTime;
-            }
+                RotationTracker.Tracking = RotationTracker.IsSpinnableTime && !Result.HasResult && correctButtonPressed();
 
             if (spinningSample != null && spinnerFrequencyModulate)
                 spinningSample.Frequency.Value = spinning_sample_modulated_base_frequency + Progress;
diff --git a/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonReverseArrow.cs b/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonReverseArrow.cs
index 1fbdbafec4..bb5499b1a5 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonReverseArrow.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonReverseArrow.cs
@@ -85,9 +85,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
             {
                 double animDuration = Math.Min(300, drawableRepeat.HitObject.SpanDuration);
                 Scale = new Vector2(Interpolation.ValueAt(Time.Current, 1, 1.5f, drawableRepeat.HitStateUpdateTime, drawableRepeat.HitStateUpdateTime + animDuration, Easing.Out));
+
+                // When hit, don't animate further. This avoids a scale being applied on a scale and looking very weird.
+                return;
             }
-            else
-                Scale = Vector2.One;
+
+            Scale = Vector2.One;
 
             const float move_distance = -12;
             const float scale_amount = 1.3f;
diff --git a/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerRotationTracker.cs b/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerRotationTracker.cs
index 7e97f826f9..7cd1f39871 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerRotationTracker.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerRotationTracker.cs
@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
         /// <summary>
         /// Whether currently in the correct time range to allow spinning.
         /// </summary>
-        private bool isSpinnableTime => drawableSpinner.HitObject.StartTime <= Time.Current && drawableSpinner.HitObject.EndTime > Time.Current;
+        public bool IsSpinnableTime => drawableSpinner.HitObject.StartTime <= Time.Current && drawableSpinner.HitObject.EndTime > Time.Current;
 
         protected override bool OnMouseMove(MouseMoveEvent e)
         {
@@ -79,7 +79,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
                 lastAngle = thisAngle;
             }
 
-            IsSpinning.Value = isSpinnableTime && Math.Abs(currentRotation - Rotation) > 10f;
+            IsSpinning.Value = IsSpinnableTime && Math.Abs(currentRotation - Rotation) > 10f;
             Rotation = (float)Interpolation.Damp(Rotation, currentRotation, 0.99, Math.Abs(Time.Elapsed));
         }
 
@@ -92,7 +92,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
         /// <param name="delta">The delta angle.</param>
         public void AddRotation(float delta)
         {
-            if (!isSpinnableTime)
+            if (!IsSpinnableTime)
                 return;
 
             if (!rotationTransferred)
diff --git a/osu.Game.Rulesets.Taiko.Tests/TestSceneLegacyReplayPlayback.cs b/osu.Game.Rulesets.Taiko.Tests/TestSceneLegacyReplayPlayback.cs
new file mode 100644
index 0000000000..459312f2b4
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko.Tests/TestSceneLegacyReplayPlayback.cs
@@ -0,0 +1,102 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneLegacyReplayPlayback : LegacyReplayPlaybackTestScene
+    {
+        protected override string? ExportLocation => null;
+
+        protected override Ruleset CreateRuleset() => new TaikoRuleset();
+
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // OD = 5 test cases.
+            // GREAT hit window is (-35ms, 35ms)
+            // OK    hit window is (-80ms, 80ms)
+            new object[] { 5f, -33d, HitResult.Great },
+            new object[] { 5f, -34d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Ok },
+            new object[] { 5f, -36d, HitResult.Ok },
+            new object[] { 5f, -78d, HitResult.Ok },
+            new object[] { 5f, -79d, HitResult.Ok },
+            new object[] { 5f, -80d, HitResult.Miss },
+            new object[] { 5f, -81d, HitResult.Miss },
+
+            // OD = 7.8 test cases.
+            // GREAT hit window is (-26ms, 26ms)
+            // OK    hit window is (-63ms, 63ms)
+            new object[] { 7.8f, -24d, HitResult.Great },
+            new object[] { 7.8f, -25d, HitResult.Great },
+            new object[] { 7.8f, -26d, HitResult.Ok },
+            new object[] { 7.8f, -27d, HitResult.Ok },
+            new object[] { 7.8f, -61d, HitResult.Ok },
+            new object[] { 7.8f, -62d, HitResult.Ok },
+            new object[] { 7.8f, -63d, HitResult.Miss },
+            new object[] { 7.8f, -64d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowTreatment(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double hit_time = 100;
+
+            var cpi = new ControlPointInfo();
+            cpi.Add(0, new TimingControlPoint { BeatLength = 1000 });
+            var beatmap = new TaikoBeatmap
+            {
+                HitObjects =
+                {
+                    new Hit
+                    {
+                        StartTime = hit_time,
+                        Type = HitType.Centre,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty { OverallDifficulty = overallDifficulty },
+                BeatmapInfo =
+                {
+                    Ruleset = new TaikoRuleset().RulesetInfo,
+                },
+                ControlPointInfo = cpi,
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new TaikoReplayFrame(0),
+                    new TaikoReplayFrame(hit_time + hitOffset, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(hit_time + hitOffset + 20),
+                }
+            };
+
+            var score = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo
+                {
+                    Ruleset = CreateRuleset().RulesetInfo,
+                }
+            };
+
+            RunTest($@"single hit @ OD{overallDifficulty}", beatmap, $@"{hitOffset}ms @ OD{overallDifficulty} = {expectedResult}", score, [expectedResult]);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko.Tests/TestSceneReplayStability.cs b/osu.Game.Rulesets.Taiko.Tests/TestSceneReplayStability.cs
new file mode 100644
index 0000000000..62bbebcf0b
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko.Tests/TestSceneReplayStability.cs
@@ -0,0 +1,96 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Beatmaps;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Replays;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    [Ignore("These tests are expected to fail until an acceptable solution for various replay playback issues concerning rounding of replay frame times & hit windows is found.")]
+    public partial class TestSceneReplayStability : ReplayStabilityTestScene
+    {
+        private static readonly object[][] test_cases =
+        {
+            // With respect to notation,
+            // square brackets `[]` represent *closed* or *inclusive* bounds,
+            // while round brackets `()` represent *open* or *exclusive* bounds.
+
+            // OD = 5 test cases.
+            // GREAT hit window is [-35ms, 35ms]
+            // OK    hit window is [-80ms, 80ms]
+            // MISS  hit window is [-95ms, 95ms]
+            new object[] { 5f, -34d, HitResult.Great },
+            new object[] { 5f, -34.2d, HitResult.Great },
+            new object[] { 5f, -34.7d, HitResult.Great },
+            new object[] { 5f, -35d, HitResult.Great },
+            new object[] { 5f, -35.2d, HitResult.Ok },
+            new object[] { 5f, -35.8d, HitResult.Ok },
+            new object[] { 5f, -36d, HitResult.Ok },
+            new object[] { 5f, -79d, HitResult.Ok },
+            new object[] { 5f, -79.3d, HitResult.Ok },
+            new object[] { 5f, -79.7d, HitResult.Ok },
+            new object[] { 5f, -80d, HitResult.Ok },
+            new object[] { 5f, -80.2d, HitResult.Miss },
+            new object[] { 5f, -80.8d, HitResult.Miss },
+            new object[] { 5f, -81d, HitResult.Miss },
+
+            // OD = 7.8 test cases.
+            // GREAT hit window is [-26.6ms, 26.6ms]
+            // OK    hit window is [-63.2ms, 63.2ms]
+            // MISS  hit window is [-81.0ms, 81.0ms]
+            new object[] { 7.8f, -26d, HitResult.Great },
+            new object[] { 7.8f, -26.4d, HitResult.Great },
+            new object[] { 7.8f, -26.59d, HitResult.Great },
+            new object[] { 7.8f, -26.8d, HitResult.Ok },
+            new object[] { 7.8f, -27d, HitResult.Ok },
+            new object[] { 7.8f, -27.1d, HitResult.Ok },
+            new object[] { 7.8f, -63d, HitResult.Ok },
+            new object[] { 7.8f, -63.18d, HitResult.Ok },
+            new object[] { 7.8f, -63.4d, HitResult.Ok },
+            new object[] { 7.8f, -63.7d, HitResult.Miss },
+            new object[] { 7.8f, -64d, HitResult.Miss },
+            new object[] { 7.8f, -64.2d, HitResult.Miss },
+        };
+
+        [TestCaseSource(nameof(test_cases))]
+        public void TestHitWindowStability(float overallDifficulty, double hitOffset, HitResult expectedResult)
+        {
+            const double hit_time = 100;
+
+            var beatmap = new TaikoBeatmap
+            {
+                HitObjects =
+                {
+                    new Hit
+                    {
+                        StartTime = hit_time,
+                        Type = HitType.Centre,
+                    }
+                },
+                Difficulty = new BeatmapDifficulty { OverallDifficulty = overallDifficulty },
+                BeatmapInfo =
+                {
+                    Ruleset = new TaikoRuleset().RulesetInfo,
+                },
+            };
+
+            var replay = new Replay
+            {
+                Frames =
+                {
+                    new TaikoReplayFrame(0),
+                    new TaikoReplayFrame(hit_time + hitOffset, TaikoAction.LeftCentre),
+                    new TaikoReplayFrame(hit_time + hitOffset + 20),
+                }
+            };
+
+            RunTest(beatmap, replay, [expectedResult]);
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs
index 41fe63a553..5b0582ab59 100644
--- a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs
+++ b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmap.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
@@ -15,26 +16,30 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             int hits = HitObjects.Count(s => s is Hit);
             int drumRolls = HitObjects.Count(s => s is DrumRoll);
             int swells = HitObjects.Count(s => s is Swell);
+            int sum = Math.Max(1, hits + drumRolls);
 
             return new[]
             {
                 new BeatmapStatistic
                 {
-                    Name = @"Hit Count",
+                    Name = @"Hits",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Circles),
                     Content = hits.ToString(),
+                    BarDisplayLength = hits / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Drumroll Count",
+                    Name = @"Drumrolls",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Sliders),
                     Content = drumRolls.ToString(),
+                    BarDisplayLength = drumRolls / (float)sum,
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Swell Count",
+                    Name = @"Swells",
                     CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Spinners),
                     Content = swells.ToString(),
+                    BarDisplayLength = Math.Min(swells / 10f, 1),
                 }
             };
         }
diff --git a/osu.Game.Rulesets.Taiko/Edit/Setup/TaikoDifficultySection.cs b/osu.Game.Rulesets.Taiko/Edit/Setup/TaikoDifficultySection.cs
index 52f7176b3f..7f7da92688 100644
--- a/osu.Game.Rulesets.Taiko/Edit/Setup/TaikoDifficultySection.cs
+++ b/osu.Game.Rulesets.Taiko/Edit/Setup/TaikoDifficultySection.cs
@@ -60,6 +60,7 @@ namespace osu.Game.Rulesets.Taiko.Edit.Setup
                 {
                     Caption = EditorSetupStrings.BaseVelocity,
                     HintText = EditorSetupStrings.BaseVelocityDescription,
+                    KeyboardStep = 0.1f,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderMultiplier)
                     {
                         Default = 1.4,
@@ -74,6 +75,7 @@ namespace osu.Game.Rulesets.Taiko.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,
diff --git a/osu.Game.Rulesets.Taiko/Skinning/Argon/ArgonCirclePiece.cs b/osu.Game.Rulesets.Taiko/Skinning/Argon/ArgonCirclePiece.cs
index cecb99c690..d94031380b 100644
--- a/osu.Game.Rulesets.Taiko/Skinning/Argon/ArgonCirclePiece.cs
+++ b/osu.Game.Rulesets.Taiko/Skinning/Argon/ArgonCirclePiece.cs
@@ -3,6 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Shapes;
@@ -112,5 +113,13 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Argon
                     .FadeOut(timingPoint.BeatLength * 0.75, Easing.OutSine);
             }
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (drawableHitObject.IsNotNull())
+                drawableHitObject.ApplyCustomUpdateState -= updateStateTransforms;
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Skinning/Default/CirclePiece.cs b/osu.Game.Rulesets.Taiko/Skinning/Default/CirclePiece.cs
index b3833d372c..a7b1b9c4b6 100644
--- a/osu.Game.Rulesets.Taiko/Skinning/Default/CirclePiece.cs
+++ b/osu.Game.Rulesets.Taiko/Skinning/Default/CirclePiece.cs
@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
@@ -202,5 +203,13 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Default
                 .Then()
                 .FadeEdgeEffectTo(edge_alpha_kiai, duration, Easing.OutQuint);
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (drawableHitObject.IsNotNull())
+                drawableHitObject.ApplyCustomUpdateState -= updateStateTransforms;
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyKiaiGlow.cs b/osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyKiaiGlow.cs
index 9877efa127..58830f7492 100644
--- a/osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyKiaiGlow.cs
+++ b/osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyKiaiGlow.cs
@@ -17,12 +17,14 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 {
     internal partial class LegacyKiaiGlow : BeatSyncedContainer
     {
-        private bool isKiaiActive;
+        [Resolved]
+        private HealthProcessor? healthProcessor { get; set; }
 
+        private bool isKiaiActive;
         private Sprite sprite = null!;
 
-        [BackgroundDependencyLoader(true)]
-        private void load(ISkinSource skin, HealthProcessor? healthProcessor)
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
         {
             Child = sprite = new Sprite
             {
@@ -33,6 +35,11 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
                 Scale = new Vector2(TaikoLegacyHitTarget.SCALE),
                 Colour = new Colour4(255, 228, 0, 255),
             };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
 
             if (healthProcessor != null)
                 healthProcessor.NewJudgement += onNewJudgement;
@@ -61,5 +68,13 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
             sprite.ScaleTo(TaikoLegacyHitTarget.SCALE + 0.15f).Then()
                   .ScaleTo(TaikoLegacyHitTarget.SCALE, 80, Easing.OutQuad);
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (healthProcessor != null)
+                healthProcessor.NewJudgement -= onNewJudgement;
+        }
     }
 }
diff --git a/osu.Game.Tests.Android/osu.Game.Tests.Android.csproj b/osu.Game.Tests.Android/osu.Game.Tests.Android.csproj
index b02425eadd..a8fc9536b9 100644
--- a/osu.Game.Tests.Android/osu.Game.Tests.Android.csproj
+++ b/osu.Game.Tests.Android/osu.Game.Tests.Android.csproj
@@ -28,6 +28,7 @@
     <ProjectReference Include="..\osu.Game\osu.Game.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
+    <PackageReference Include="Bogus" Version="35.6.2" />
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Moq" Version="4.17.2" />
   </ItemGroup>
diff --git a/osu.Game.Tests.iOS/osu.Game.Tests.iOS.csproj b/osu.Game.Tests.iOS/osu.Game.Tests.iOS.csproj
index da07373037..9f13b0587b 100644
--- a/osu.Game.Tests.iOS/osu.Game.Tests.iOS.csproj
+++ b/osu.Game.Tests.iOS/osu.Game.Tests.iOS.csproj
@@ -29,6 +29,7 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
+    <PackageReference Include="Bogus" Version="35.6.2" />
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Moq" Version="4.17.2" />
   </ItemGroup>
diff --git a/osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs b/osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs
index 647c0aed75..b10cce6a52 100644
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs
@@ -135,6 +135,24 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
+        [Test]
+        public void TestNoopFadeTransformIsIgnoredForLifetime()
+        {
+            var decoder = new LegacyStoryboardDecoder();
+
+            using (var resStream = TestResources.OpenResource("noop-fade-transform-is-ignored-for-lifetime.osb"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var storyboard = decoder.Decode(stream);
+
+                StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
+                Assert.AreEqual(2, background.Elements.Count);
+
+                Assert.AreEqual(1500, background.Elements[0].StartTime);
+                Assert.AreEqual(1500, background.Elements[1].StartTime);
+            }
+        }
+
         [Test]
         public void TestOutOfOrderStartTimes()
         {
@@ -288,6 +306,29 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
+        [Test]
+        public void TestVideoWithCustomFadeIn()
+        {
+            var decoder = new LegacyStoryboardDecoder();
+
+            using var resStream = TestResources.OpenResource("video-custom-alpha-transform.osb");
+            using var stream = new LineBufferedReader(resStream);
+
+            var storyboard = decoder.Decode(stream);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(storyboard.GetLayer(@"Video").Elements, Has.Count.EqualTo(1));
+                Assert.That(storyboard.GetLayer(@"Video").Elements.Single(), Is.InstanceOf<StoryboardVideo>());
+                Assert.That(storyboard.GetLayer(@"Video").Elements.Single().StartTime, Is.EqualTo(-5678));
+                Assert.That(((StoryboardVideo)storyboard.GetLayer(@"Video").Elements.Single()).Commands.Alpha.Single().StartTime, Is.EqualTo(1500));
+                Assert.That(((StoryboardVideo)storyboard.GetLayer(@"Video").Elements.Single()).Commands.Alpha.Single().EndTime, Is.EqualTo(1600));
+
+                Assert.That(storyboard.EarliestEventTime, Is.Null);
+                Assert.That(storyboard.LatestEventTime, Is.Null);
+            });
+        }
+
         [Test]
         public void TestVideoAndBackgroundEventsDoNotAffectStoryboardBounds()
         {
diff --git a/osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs b/osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs
new file mode 100644
index 0000000000..b02bf01019
--- /dev/null
+++ b/osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs
@@ -0,0 +1,54 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Extensions;
+
+namespace osu.Game.Tests.Extensions
+{
+    [TestFixture]
+    public class NumberFormattingExtensionsTest
+    {
+        [TestCase(-1, false, 0, ExpectedResult = "-1")]
+        [TestCase(0, false, 0, ExpectedResult = "0")]
+        [TestCase(1, false, 0, ExpectedResult = "1")]
+        [TestCase(500, false, 10, ExpectedResult = "500")]
+        [TestCase(-1, true, 0, ExpectedResult = "-1%")]
+        [TestCase(0, true, 0, ExpectedResult = "0%")]
+        [TestCase(1, true, 0, ExpectedResult = "1%")]
+        [TestCase(50, true, 0, ExpectedResult = "50%")]
+        public string TestInteger(int input, bool percent, int decimalDigits)
+        {
+            return input.ToStandardFormattedString(decimalDigits, percent);
+        }
+
+        [TestCase(-1, false, 0, ExpectedResult = "-1")]
+        [TestCase(-1e-6, false, 0, ExpectedResult = "0")]
+        [TestCase(-1e-6, false, 6, ExpectedResult = "-0.000001")]
+        [TestCase(0, false, 10, ExpectedResult = "0")]
+        [TestCase(0, false, 0, ExpectedResult = "0")]
+        [TestCase(double.NegativeZero, false, 0, ExpectedResult = "0")]
+        [TestCase(1e-6, false, 0, ExpectedResult = "0")]
+        [TestCase(1e-6, false, 6, ExpectedResult = "0.000001")]
+        [TestCase(1, false, 0, ExpectedResult = "1")]
+        [TestCase(1.528, false, 2, ExpectedResult = "1.53")]
+        [TestCase(500, false, 10, ExpectedResult = "500")]
+        [TestCase(-0.1, true, 0, ExpectedResult = "-10%")]
+        [TestCase(0, true, 0, ExpectedResult = "0%")]
+        [TestCase(0.4, true, 0, ExpectedResult = "40%")]
+        [TestCase(0.48333, true, 2, ExpectedResult = "48%")]
+        [TestCase(0.48333, true, 4, ExpectedResult = "48.33%")]
+        [TestCase(1, true, 0, ExpectedResult = "100%")]
+        public string TestDouble(double input, bool percent, int decimalDigits)
+        {
+            return input.ToStandardFormattedString(decimalDigits, percent);
+        }
+
+        [Test]
+        [SetCulture("fr-FR")]
+        public void TestCultureInsensitivity()
+        {
+            Assert.That(0.4.ToStandardFormattedString(maxDecimalDigits: 2, asPercentage: true), Is.EqualTo("40%"));
+        }
+    }
+}
diff --git a/osu.Game.Tests/OnlinePlay/MultiplayerPlaylistItemTest.cs b/osu.Game.Tests/OnlinePlay/MultiplayerPlaylistItemTest.cs
new file mode 100644
index 0000000000..4a80c71c3d
--- /dev/null
+++ b/osu.Game.Tests/OnlinePlay/MultiplayerPlaylistItemTest.cs
@@ -0,0 +1,73 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using Bogus;
+using MessagePack;
+using NUnit.Framework;
+using osu.Game.Online.API;
+using osu.Game.Online.Rooms;
+
+namespace osu.Game.Tests.OnlinePlay
+{
+    [TestFixture]
+    public class MultiplayerPlaylistItemTest
+    {
+        [SetUp]
+        public void Setup()
+        {
+            Randomizer.Seed = new Random(1337);
+        }
+
+        [Test]
+        public void TestCloneMultiplayerPlaylistItem()
+        {
+            var faker = new Faker<MultiplayerPlaylistItem>()
+                        .StrictMode(true)
+                        .RuleFor(o => o.ID, f => f.Random.Long())
+                        .RuleFor(o => o.OwnerID, f => f.Random.Int())
+                        .RuleFor(o => o.BeatmapID, f => f.Random.Int())
+                        .RuleFor(o => o.BeatmapChecksum, f => f.Random.Hash())
+                        .RuleFor(o => o.RulesetID, f => f.Random.Int())
+                        .RuleFor(o => o.RequiredMods, f => f.Make(5, _ => new APIMod { Acronym = f.Random.String2(3) }))
+                        .RuleFor(o => o.AllowedMods, f => f.Make(5, _ => new APIMod { Acronym = f.Random.String2(3) }))
+                        .RuleFor(o => o.Expired, f => f.Random.Bool())
+                        .RuleFor(o => o.PlaylistOrder, f => f.Random.UShort())
+                        .RuleFor(o => o.PlayedAt, f => f.Date.RecentOffset())
+                        .RuleFor(o => o.StarRating, f => f.Random.Double())
+                        .RuleFor(o => o.Freestyle, f => f.Random.Bool());
+
+            for (int i = 0; i < 100; i++)
+            {
+                MultiplayerPlaylistItem item = faker.Generate();
+                Assert.That(MessagePackSerializer.SerializeToJson(item.Clone()), Is.EqualTo(MessagePackSerializer.SerializeToJson(item)));
+            }
+        }
+
+        [Test]
+        public void TestConstructFromAPIModel()
+        {
+            var faker = new Faker<MultiplayerPlaylistItem>()
+                        .StrictMode(true)
+                        .RuleFor(o => o.ID, f => f.Random.Long())
+                        .RuleFor(o => o.OwnerID, f => f.Random.Int())
+                        .RuleFor(o => o.BeatmapID, f => f.Random.Int())
+                        .RuleFor(o => o.BeatmapChecksum, f => f.Random.Hash())
+                        .RuleFor(o => o.RulesetID, f => f.Random.Int())
+                        .RuleFor(o => o.RequiredMods, f => f.Make(5, _ => new APIMod { Acronym = f.Random.String2(3) }))
+                        .RuleFor(o => o.AllowedMods, f => f.Make(5, _ => new APIMod { Acronym = f.Random.String2(3) }))
+                        .RuleFor(o => o.Expired, f => f.Random.Bool())
+                        .RuleFor(o => o.PlaylistOrder, f => f.Random.UShort())
+                        .RuleFor(o => o.PlayedAt, f => f.Date.RecentOffset())
+                        .RuleFor(o => o.StarRating, f => f.Random.Double())
+                        .RuleFor(o => o.Freestyle, f => f.Random.Bool());
+
+            for (int i = 0; i < 100; i++)
+            {
+                MultiplayerPlaylistItem initialItem = faker.Generate();
+                MultiplayerPlaylistItem copiedItem = new MultiplayerPlaylistItem(new PlaylistItem(initialItem));
+                Assert.That(MessagePackSerializer.SerializeToJson(copiedItem), Is.EqualTo(MessagePackSerializer.SerializeToJson(initialItem)));
+            }
+        }
+    }
+}
diff --git a/osu.Game.Tests/Resources/noop-fade-transform-is-ignored-for-lifetime.osb b/osu.Game.Tests/Resources/noop-fade-transform-is-ignored-for-lifetime.osb
new file mode 100644
index 0000000000..aca9bf926a
--- /dev/null
+++ b/osu.Game.Tests/Resources/noop-fade-transform-is-ignored-for-lifetime.osb
@@ -0,0 +1,8 @@
+[Events]
+//Storyboard Layer 0 (Background)
+Sprite,Background,TopCentre,"img.jpg",320,240
+ F,0,1000,1000,0,0 // should be ignored
+ F,0,1500,1600,0,1
+Sprite,Background,TopCentre,"img.jpg",320,240
+ F,0,1000,1000,0,0 // should be ignored
+ F,0,1500,1600,1,1
diff --git a/osu.Game.Tests/Resources/video-custom-alpha-transform.osb b/osu.Game.Tests/Resources/video-custom-alpha-transform.osb
new file mode 100644
index 0000000000..39fcf87c06
--- /dev/null
+++ b/osu.Game.Tests/Resources/video-custom-alpha-transform.osb
@@ -0,0 +1,5 @@
+osu file format v14
+
+[Events]
+Video,-5678,"Video.avi",0,0
+ F,0,1500,1600,0,1
diff --git a/osu.Game.Tests/Scores/IO/ImportScoreTest.cs b/osu.Game.Tests/Scores/IO/ImportScoreTest.cs
index 9c72804a6b..6558834a63 100644
--- a/osu.Game.Tests/Scores/IO/ImportScoreTest.cs
+++ b/osu.Game.Tests/Scores/IO/ImportScoreTest.cs
@@ -215,6 +215,35 @@ namespace osu.Game.Tests.Scores.IO
             }
         }
 
+        [Test]
+        public void TestScoreWithInvalidModCombinationsWillNotImport()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host, true);
+
+                    var beatmap = BeatmapImportHelper.LoadOszIntoOsu(osu, TestResources.GetQuickTestBeatmapForImport()).GetResultSafely();
+
+                    var toImport = new ScoreInfo
+                    {
+                        User = new APIUser { Username = "Test user" },
+                        BeatmapInfo = beatmap.Beatmaps.First(),
+                        Ruleset = new OsuRuleset().RulesetInfo,
+                        ClientVersion = "12345",
+                        Mods = new Mod[] { new OsuModHalfTime(), new OsuModDoubleTime() },
+                    };
+
+                    Assert.Throws<InvalidOperationException>(() => LoadScoreIntoOsu(osu, toImport));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
         [Test]
         public void TestImportStatistics()
         {
diff --git a/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardFavouriteButton.cs b/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardFavouriteButton.cs
index c33033624a..81abe105f1 100644
--- a/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardFavouriteButton.cs
+++ b/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapCardFavouriteButton.cs
@@ -91,6 +91,6 @@ namespace osu.Game.Tests.Visual.Beatmaps
         }
 
         private void assertCorrectIcon(bool favourited) => AddAssert("icon correct",
-            () => this.ChildrenOfType<SpriteIcon>().Single().Icon.Equals(favourited ? FontAwesome.Solid.Heart : FontAwesome.Regular.Heart));
+            () => this.ChildrenOfType<SpriteIcon>().First().Icon.Equals(favourited ? FontAwesome.Solid.Heart : FontAwesome.Regular.Heart));
     }
 }
diff --git a/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs b/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs
index dcc4654437..82e02a9b6f 100644
--- a/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs
+++ b/osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs
@@ -19,6 +19,8 @@ namespace osu.Game.Tests.Visual.Beatmaps
 {
     public partial class TestSceneBeatmapSetOnlineStatusPill : ThemeComparisonTestScene
     {
+        private bool showUnknownStatus;
+
         protected override Drawable CreateContent() => new FillFlowContainer
         {
             AutoSizeAxes = Axes.Both,
@@ -26,12 +28,20 @@ namespace osu.Game.Tests.Visual.Beatmaps
             Origin = Anchor.Centre,
             Direction = FillDirection.Vertical,
             Spacing = new Vector2(0, 10),
-            ChildrenEnumerable = Enum.GetValues(typeof(BeatmapOnlineStatus)).Cast<BeatmapOnlineStatus>().Select(status => new BeatmapSetOnlineStatusPill
+            ChildrenEnumerable = Enum.GetValues(typeof(BeatmapOnlineStatus)).Cast<BeatmapOnlineStatus>().Select(status => new Container
             {
-                AutoSizeAxes = Axes.Both,
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Status = status
+                RelativeSizeAxes = Axes.X,
+                Height = 20,
+                Children = new Drawable[]
+                {
+                    new BeatmapSetOnlineStatusPill
+                    {
+                        ShowUnknownStatus = showUnknownStatus,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Status = status
+                    }
+                }
             })
         };
 
@@ -48,6 +58,12 @@ namespace osu.Game.Tests.Visual.Beatmaps
                 pill.Width = 90;
             }));
 
+            AddStep("toggle show unknown", () =>
+            {
+                showUnknownStatus = !showUnknownStatus;
+                CreateThemedContent(OverlayColourScheme.Red);
+            });
+
             AddStep("unset fixed width", () => statusPills.ForEach(pill => pill.AutoSizeAxes = Axes.Both));
         }
 
@@ -65,11 +81,6 @@ namespace osu.Game.Tests.Visual.Beatmaps
                             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/DailyChallenge/TestSceneDailyChallenge.cs b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs
index c974a852f3..f1422b4654 100644
--- a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs
+++ b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs
@@ -15,7 +15,7 @@ using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Screens.SelectV2.Leaderboards;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual.Metadata;
 using osu.Game.Tests.Visual.OnlinePlay;
@@ -43,7 +43,6 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         {
             var room = new Room
             {
-                RoomID = 1234,
                 Name = "Daily Challenge: June 4, 2024",
                 Playlist =
                 [
@@ -66,7 +65,6 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         {
             var room = new Room
             {
-                RoomID = 1234,
                 Name = "Daily Challenge: June 4, 2024",
                 Playlist =
                 [
@@ -87,7 +85,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
             AddStep("force transforms to finish", () => FinishTransforms(true));
             AddStep("right click second score", () =>
             {
-                InputManager.MoveMouseTo(this.ChildrenOfType<LeaderboardScoreV2>().ElementAt(1));
+                InputManager.MoveMouseTo(this.ChildrenOfType<BeatmapLeaderboardScore>().ElementAt(1));
                 InputManager.Click(MouseButton.Right);
             });
             AddAssert("use these mods not present",
@@ -99,7 +97,6 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         {
             var room = new Room
             {
-                RoomID = 1234,
                 Name = "Daily Challenge: June 4, 2024",
                 Playlist =
                 [
@@ -114,7 +111,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
             };
 
             AddStep("add room", () => API.Perform(new CreateRoomRequest(room)));
-            AddStep("set daily challenge info", () => metadataClient.DailyChallengeInfo.Value = new DailyChallengeInfo { RoomID = 1234 });
+            AddStep("set daily challenge info", () => metadataClient.DailyChallengeInfo.Value = new DailyChallengeInfo { RoomID = room.RoomID!.Value });
 
             Screens.OnlinePlay.DailyChallenge.DailyChallenge screen = null!;
             AddStep("push screen", () => LoadScreen(screen = new Screens.OnlinePlay.DailyChallenge.DailyChallenge(room)));
@@ -128,7 +125,6 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         {
             var room = new Room
             {
-                RoomID = 1234,
                 Name = "Daily Challenge: June 4, 2024",
                 Playlist =
                 [
@@ -143,7 +139,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
             };
 
             AddStep("add room", () => API.Perform(new CreateRoomRequest(room)));
-            AddStep("set daily challenge info", () => metadataClient.DailyChallengeInfo.Value = new DailyChallengeInfo { RoomID = 1234 });
+            AddStep("set daily challenge info", () => metadataClient.DailyChallengeInfo.Value = new DailyChallengeInfo { RoomID = room.RoomID!.Value });
 
             Screens.OnlinePlay.DailyChallenge.DailyChallenge screen = null!;
             AddStep("push screen", () => LoadScreen(screen = new Screens.OnlinePlay.DailyChallenge.DailyChallenge(room)));
diff --git a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeIntro.cs b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeIntro.cs
index d6665e24a4..97b957df43 100644
--- a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeIntro.cs
+++ b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallengeIntro.cs
@@ -44,17 +44,17 @@ namespace osu.Game.Tests.Visual.DailyChallenge
         [Test]
         public void TestDailyChallenge()
         {
-            startChallenge(1234);
+            startChallenge();
             AddStep("push screen", () => LoadScreen(new DailyChallengeIntro(room)));
         }
 
         [Test]
         public void TestPlayIntroOnceFlag()
         {
-            startChallenge(1234);
+            startChallenge();
             AddStep("set intro played flag", () => Dependencies.Get<SessionStatics>().SetValue(Static.DailyChallengeIntroPlayed, true));
 
-            startChallenge(1235);
+            startChallenge();
 
             AddAssert("intro played flag reset", () => Dependencies.Get<SessionStatics>().Get<bool>(Static.DailyChallengeIntroPlayed), () => Is.False);
 
@@ -62,13 +62,12 @@ namespace osu.Game.Tests.Visual.DailyChallenge
             AddUntilStep("intro played flag set", () => Dependencies.Get<SessionStatics>().Get<bool>(Static.DailyChallengeIntroPlayed), () => Is.True);
         }
 
-        private void startChallenge(int roomId)
+        private void startChallenge()
         {
             AddStep("add room", () =>
             {
                 API.Perform(new CreateRoomRequest(room = new Room
                 {
-                    RoomID = roomId,
                     Name = "Daily Challenge: June 4, 2024",
                     Playlist =
                     [
@@ -83,7 +82,7 @@ namespace osu.Game.Tests.Visual.DailyChallenge
                     Category = RoomCategory.DailyChallenge
                 }));
             });
-            AddStep("signal client", () => metadataClient.DailyChallengeUpdated(new DailyChallengeInfo { RoomID = roomId }));
+            AddStep("signal client", () => metadataClient.DailyChallengeUpdated(new DailyChallengeInfo { RoomID = room.RoomID!.Value }));
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneEditorSamplePlayback.cs b/osu.Game.Tests/Visual/Editing/TestSceneEditorSamplePlayback.cs
index 8b941d7597..092b2bc01c 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorSamplePlayback.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorSamplePlayback.cs
@@ -24,12 +24,7 @@ namespace osu.Game.Tests.Visual.Editing
             PoolableSkinnableSample[] loopingSamples = null;
             PoolableSkinnableSample[] onceOffSamples = null;
 
-            AddStep("get first slider", () =>
-            {
-                slider = Editor.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).First();
-                onceOffSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => !s.Looping).ToArray();
-                loopingSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => s.Looping).ToArray();
-            });
+            AddStep("get first slider", () => slider = Editor.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).First());
 
             AddStep("start playback", () => EditorClock.Start());
 
@@ -38,6 +33,9 @@ namespace osu.Game.Tests.Visual.Editing
                 if (!slider.Tracking.Value)
                     return false;
 
+                onceOffSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => !s.Looping).ToArray();
+                loopingSamples = slider.ChildrenOfType<PoolableSkinnableSample>().Where(s => s.Looping).ToArray();
+
                 if (!loopingSamples.Any(s => s.Playing))
                     return false;
 
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneMetadataSection.cs b/osu.Game.Tests/Visual/Editing/TestSceneMetadataSection.cs
index 743529d40c..995acd28dd 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneMetadataSection.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneMetadataSection.cs
@@ -65,10 +65,10 @@ namespace osu.Game.Tests.Visual.Editing
                 InputManager.Keys(PlatformAction.Paste);
             });
 
-            assertArtistMetadata("Example Artist");
+            assertArtistMetadata("Example ArtistExample Artist");
 
             // It's important values are committed immediately on focus loss so the editor exit sequence detects them.
-            AddAssert("value immediately changed on focus loss", () =>
+            AddAssert("value still changed after focus loss", () =>
             {
                 ((IFocusManager)InputManager).TriggerFocusContention(metadataSection);
                 return editorBeatmap.Metadata.Artist;
@@ -104,7 +104,7 @@ namespace osu.Game.Tests.Visual.Editing
                 InputManager.Keys(PlatformAction.Paste);
             });
 
-            assertArtistMetadata("Example Artist");
+            assertArtistMetadata("Example ArtistExample Artist");
 
             AddStep("commit", () => InputManager.Key(Key.Enter));
 
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
index aa99b22701..92a10628ff 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneBeatmapOffsetControl.cs
@@ -50,21 +50,17 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("Set short reference score", () =>
             {
+                // 50 events total. one of them (head circle) being timed / having hitwindows, rest having no hitwindows
                 List<HitEvent> hitEvents =
                 [
-                    // 10 events total. one of them (head circle) being timed / having hitwindows, rest having no hitwindows
                     new HitEvent(30, 1, HitResult.LargeTickHit, new SliderHeadCircle { ClassicSliderBehaviour = true }, null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
-                    new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null),
                 ];
 
+                for (int i = 0; i < 49; i++)
+                {
+                    hitEvents.Add(new HitEvent(0, 1, HitResult.LargeTickHit, new SliderTick(), null, null));
+                }
+
                 foreach (var ev in hitEvents)
                     ev.HitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
 
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs
index 1787230117..bef43b3108 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneGameplayLeaderboard.cs
@@ -1,12 +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.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Extensions.PolygonExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -16,6 +16,7 @@ using osu.Framework.Utils;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -23,7 +24,10 @@ namespace osu.Game.Tests.Visual.Gameplay
     [TestFixture]
     public partial class TestSceneGameplayLeaderboard : OsuTestScene
     {
-        private TestGameplayLeaderboard leaderboard;
+        private TestDrawableGameplayLeaderboard leaderboard = null!;
+
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private TestGameplayLeaderboardProvider leaderboardProvider = new TestGameplayLeaderboardProvider();
 
         private readonly BindableLong playerScore = new BindableLong();
 
@@ -31,7 +35,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("toggle expanded", () =>
             {
-                if (leaderboard != null)
+                if (leaderboard.IsNotNull())
                     leaderboard.Expanded.Value = !leaderboard.Expanded.Value;
             });
 
@@ -57,10 +61,10 @@ namespace osu.Game.Tests.Visual.Gameplay
             // has caused layout to not work in the past.
 
             AddUntilStep("wait for fill flow layout",
-                () => leaderboard.ChildrenOfType<FillFlowContainer<GameplayLeaderboardScore>>().First().ScreenSpaceDrawQuad.Intersects(leaderboard.ScreenSpaceDrawQuad));
+                () => leaderboard.ChildrenOfType<FillFlowContainer<DrawableGameplayLeaderboardScore>>().First().ScreenSpaceDrawQuad.Intersects(leaderboard.ScreenSpaceDrawQuad));
 
             AddUntilStep("wait for some scores not masked away",
-                () => leaderboard.ChildrenOfType<GameplayLeaderboardScore>().Any(s => leaderboard.ScreenSpaceDrawQuad.Contains(s.ScreenSpaceDrawQuad.Centre)));
+                () => leaderboard.ChildrenOfType<DrawableGameplayLeaderboardScore>().Any(s => leaderboard.ScreenSpaceDrawQuad.Contains(s.ScreenSpaceDrawQuad.Centre)));
 
             AddUntilStep("wait for tracked score fully visible", () => leaderboard.ScreenSpaceDrawQuad.Intersects(leaderboard.TrackedScore!.ScreenSpaceDrawQuad));
 
@@ -139,7 +143,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             checkHeight(8);
 
             void checkHeight(int panelCount)
-                => AddAssert($"leaderboard height is {panelCount} panels high", () => leaderboard.DrawHeight == (GameplayLeaderboardScore.PANEL_HEIGHT + leaderboard.Spacing) * panelCount);
+                => AddAssert($"leaderboard height is {panelCount} panels high", () => leaderboard.DrawHeight == (DrawableGameplayLeaderboardScore.PANEL_HEIGHT + leaderboard.Spacing) * panelCount);
         }
 
         [Test]
@@ -179,6 +183,30 @@ namespace osu.Game.Tests.Visual.Gameplay
                 () => Does.Contain("#FF549A"));
         }
 
+        [Test]
+        public void TestTrackedScorePosition([Values] bool partial)
+        {
+            createLeaderboard(partial);
+
+            AddStep("add many scores in one go", () =>
+            {
+                for (int i = 0; i < 49; i++)
+                    createRandomScore(new APIUser { Username = $"Player {i + 1}" });
+
+                // Add player at end to force an animation down the whole list.
+                playerScore.Value = 0;
+                createLeaderboardScore(playerScore, new APIUser { Username = "You", Id = 3 }, true);
+            });
+
+            if (partial)
+                AddUntilStep("tracked player has null position", () => leaderboard.TrackedScore?.ScorePosition, () => Is.Null);
+            else
+                AddUntilStep("tracked player is #50", () => leaderboard.TrackedScore?.ScorePosition, () => Is.EqualTo(50));
+
+            AddStep("move tracked player to top", () => leaderboard.TrackedScore!.TotalScore.Value = 8_000_000);
+            AddUntilStep("all players have non-null position", () => leaderboard.AllScores.Select(s => s.ScorePosition), () => Does.Not.Contain(null));
+        }
+
         private void addLocalPlayer()
         {
             AddStep("add local player", () =>
@@ -188,11 +216,13 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
         }
 
-        private void createLeaderboard()
+        private void createLeaderboard(bool partial = false)
         {
             AddStep("create leaderboard", () =>
             {
-                Child = leaderboard = new TestGameplayLeaderboard
+                leaderboardProvider.Scores.Clear();
+                leaderboardProvider.IsPartial = partial;
+                Child = leaderboard = new TestDrawableGameplayLeaderboard
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -205,11 +235,11 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void createLeaderboardScore(BindableLong score, APIUser user, bool isTracked = false)
         {
-            var leaderboardScore = leaderboard.Add(user, isTracked);
-            leaderboardScore.TotalScore.BindTo(score);
+            var leaderboardScore = new GameplayLeaderboardScore(user, isTracked, score);
+            leaderboardProvider.Scores.Add(leaderboardScore);
         }
 
-        private partial class TestGameplayLeaderboard : GameplayLeaderboard
+        private partial class TestDrawableGameplayLeaderboard : DrawableGameplayLeaderboard
         {
             public float Spacing => Flow.Spacing.Y;
 
@@ -220,8 +250,17 @@ namespace osu.Game.Tests.Visual.Gameplay
                 return scoreItem != null && scoreItem.ScorePosition == expectedPosition;
             }
 
-            public IEnumerable<GameplayLeaderboardScore> GetAllScoresForUsername(string username)
+            public IEnumerable<DrawableGameplayLeaderboardScore> GetAllScoresForUsername(string username)
                 => Flow.Where(i => i.User?.Username == username);
+
+            public IEnumerable<DrawableGameplayLeaderboardScore> AllScores => Flow;
+        }
+
+        private class TestGameplayLeaderboardProvider : IGameplayLeaderboardProvider
+        {
+            IBindableList<GameplayLeaderboardScore> IGameplayLeaderboardProvider.Scores => Scores;
+            public BindableList<GameplayLeaderboardScore> Scores { get; } = new BindableList<GameplayLeaderboardScore>();
+            public bool IsPartial { get; set; }
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.cs
index 91188f5bac..97889eea4d 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSkinEditor.cs
@@ -15,6 +15,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
 using osu.Framework.Testing;
 using osu.Game.Database;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Settings;
 using osu.Game.Overlays.SkinEditor;
@@ -458,6 +459,62 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("combo placed in ruleset target", () => rulesetHUDTarget.Components.OfType<LegacyDefaultComboCounter>().Count() == 1);
         }
 
+        [Test]
+        public void TestAnchorRadioButtonBehavior()
+        {
+            ISerialisableDrawable? selectedComponent = null;
+
+            AddStep("Select first component", () =>
+            {
+                var blueprint = skinEditor.ChildrenOfType<SkinBlueprint>().First();
+                skinEditor.SelectedComponents.Clear();
+                skinEditor.SelectedComponents.Add(blueprint.Item);
+                selectedComponent = blueprint.Item;
+            });
+
+            AddStep("Right-click to open context menu", () =>
+            {
+                if (selectedComponent != null)
+                    InputManager.MoveMouseTo(((Drawable)selectedComponent).ScreenSpaceDrawQuad.Centre);
+                InputManager.Click(MouseButton.Right);
+            });
+
+            AddStep("Click on Anchor menu", () =>
+            {
+                InputManager.MoveMouseTo(getMenuItemByText("Anchor"));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("Right-click TopLeft anchor", () =>
+            {
+                InputManager.MoveMouseTo(getMenuItemByText("TopLeft"));
+                InputManager.Click(MouseButton.Right);
+            });
+
+            AddAssert("TopLeft item checked", () => (getMenuItemByText("TopLeft").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.True);
+
+            AddStep("Right-click Centre anchor", () =>
+            {
+                InputManager.MoveMouseTo(getMenuItemByText("Centre"));
+                InputManager.Click(MouseButton.Right);
+            });
+
+            AddAssert("Centre item checked", () => (getMenuItemByText("Centre").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.True);
+            AddAssert("TopLeft item unchecked", () => (getMenuItemByText("TopLeft").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.False);
+
+            AddStep("Right-click Closest anchor", () =>
+            {
+                InputManager.MoveMouseTo(getMenuItemByText("Closest"));
+                InputManager.Click(MouseButton.Right);
+            });
+
+            AddAssert("Closest item checked", () => (getMenuItemByText("Closest").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.True);
+            AddAssert("Centre item unchecked", () => (getMenuItemByText("Centre").Item as TernaryStateRadioMenuItem)?.State.Value == TernaryState.False);
+
+            Menu.DrawableMenuItem getMenuItemByText(string text)
+                => this.ChildrenOfType<Menu.DrawableMenuItem>().First(m => m.Item.Text.ToString() == text);
+        }
+
         private Skin importSkinFromArchives(string filename)
         {
             var imported = skins.Import(new ImportTask(TestResources.OpenResource($@"Archives/{filename}"), filename)).GetResultSafely();
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSoloGameplayLeaderboard.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSoloGameplayLeaderboard.cs
deleted file mode 100644
index dbd14db818..0000000000
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSoloGameplayLeaderboard.cs
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Testing;
-using osu.Framework.Utils;
-using osu.Game.Configuration;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Scoring;
-using osu.Game.Screens.Play.HUD;
-using osu.Game.Screens.Select;
-using osu.Game.Tests.Gameplay;
-
-namespace osu.Game.Tests.Visual.Gameplay
-{
-    public partial class TestSceneSoloGameplayLeaderboard : OsuTestScene
-    {
-        [Cached(typeof(ScoreProcessor))]
-        private readonly ScoreProcessor scoreProcessor = TestGameplayState.Create(new OsuRuleset()).ScoreProcessor;
-
-        private readonly BindableList<ScoreInfo> scores = new BindableList<ScoreInfo>();
-
-        private readonly Bindable<bool> configVisibility = new Bindable<bool>();
-        private readonly Bindable<PlayBeatmapDetailArea.TabType> beatmapTabType = new Bindable<PlayBeatmapDetailArea.TabType>();
-
-        private SoloGameplayLeaderboard leaderboard = null!;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            config.BindWith(OsuSetting.GameplayLeaderboard, configVisibility);
-            config.BindWith(OsuSetting.BeatmapDetailTab, beatmapTabType);
-        }
-
-        [SetUpSteps]
-        public void SetUpSteps()
-        {
-            AddStep("clear scores", () => scores.Clear());
-
-            AddStep("create component", () =>
-            {
-                var trackingUser = new APIUser
-                {
-                    Username = "local user",
-                    Id = 2,
-                };
-
-                Child = leaderboard = new SoloGameplayLeaderboard(trackingUser)
-                {
-                    Scores = { BindTarget = scores },
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    AlwaysVisible = { Value = false },
-                    Expanded = { Value = true },
-                };
-            });
-
-            AddStep("add scores", () => scores.AddRange(createSampleScores()));
-        }
-
-        [Test]
-        public void TestLocalUser()
-        {
-            AddSliderStep("score", 0, 1000000, 500000, v => scoreProcessor.TotalScore.Value = v);
-            AddSliderStep("accuracy", 0f, 1f, 0.5f, v => scoreProcessor.Accuracy.Value = v);
-            AddSliderStep("combo", 0, 10000, 0, v => scoreProcessor.HighestCombo.Value = v);
-            AddStep("toggle expanded", () => leaderboard.Expanded.Value = !leaderboard.Expanded.Value);
-        }
-
-        [TestCase(PlayBeatmapDetailArea.TabType.Local, 51)]
-        [TestCase(PlayBeatmapDetailArea.TabType.Global, null)]
-        [TestCase(PlayBeatmapDetailArea.TabType.Country, null)]
-        [TestCase(PlayBeatmapDetailArea.TabType.Friends, null)]
-        public void TestTrackedScorePosition(PlayBeatmapDetailArea.TabType tabType, int? expectedOverflowIndex)
-        {
-            AddStep($"change TabType to {tabType}", () => beatmapTabType.Value = tabType);
-            AddUntilStep("tracked player is #50", () => leaderboard.TrackedScore?.ScorePosition, () => Is.EqualTo(50));
-
-            AddStep("add one more score", () => scores.Add(new ScoreInfo { User = new APIUser { Username = "New player 1" }, TotalScore = RNG.Next(600000, 1000000) }));
-
-            AddUntilStep("wait for sort", () => leaderboard.ChildrenOfType<GameplayLeaderboardScore>().First().ScorePosition != null);
-
-            if (expectedOverflowIndex == null)
-                AddUntilStep("tracked player has null position", () => leaderboard.TrackedScore?.ScorePosition, () => Is.Null);
-            else
-                AddUntilStep($"tracked player is #{expectedOverflowIndex}", () => leaderboard.TrackedScore?.ScorePosition, () => Is.EqualTo(expectedOverflowIndex));
-        }
-
-        [Test]
-        public void TestVisibility()
-        {
-            AddStep("set config visible true", () => configVisibility.Value = true);
-            AddUntilStep("leaderboard visible", () => leaderboard.Alpha == 1);
-
-            AddStep("set config visible false", () => configVisibility.Value = false);
-            AddUntilStep("leaderboard not visible", () => leaderboard.Alpha == 0);
-
-            AddStep("set always visible", () => leaderboard.AlwaysVisible.Value = true);
-            AddUntilStep("leaderboard visible", () => leaderboard.Alpha == 1);
-
-            AddStep("set config visible true", () => configVisibility.Value = true);
-            AddAssert("leaderboard still visible", () => leaderboard.Alpha == 1);
-        }
-
-        private static List<ScoreInfo> createSampleScores()
-        {
-            return new[]
-            {
-                new ScoreInfo { User = new APIUser { Username = @"peppy" }, TotalScore = RNG.Next(500000, 1000000) },
-                new ScoreInfo { User = new APIUser { Username = @"smoogipoo" }, TotalScore = RNG.Next(500000, 1000000) },
-                new ScoreInfo { User = new APIUser { Username = @"spaceman_atlas" }, TotalScore = RNG.Next(500000, 1000000) },
-                new ScoreInfo { User = new APIUser { Username = @"frenzibyte" }, TotalScore = RNG.Next(500000, 1000000) },
-                new ScoreInfo { User = new APIUser { Username = @"Susko3" }, TotalScore = RNG.Next(500000, 1000000) },
-            }.Concat(Enumerable.Range(0, 44).Select(i => new ScoreInfo { User = new APIUser { Username = $"User {i + 1}" }, TotalScore = 1000000 - i * 10000 })).ToList();
-        }
-    }
-}
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs
index 5da60966b2..4b90bec784 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs
@@ -2,12 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@@ -48,7 +50,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         [Test]
-        public void TestVideoSize()
+        public void TestVideo()
         {
             AddStep("load storyboard with only video", () =>
             {
@@ -56,6 +58,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                 loadStoryboard("storyboard_only_video.osu", s => s.Beatmap.WidescreenStoryboard = false);
             });
 
+            AddAssert("storyboard video present in hierarchy", () => this.ChildrenOfType<DrawableStoryboardVideo>().Any());
             AddAssert("storyboard is correct width", () => Precision.AlmostEquals(storyboard?.Width ?? 0f, 480 * 16 / 9f));
         }
 
diff --git a/osu.Game.Tests/Visual/Menus/TestSceneMusicActionHandling.cs b/osu.Game.Tests/Visual/Menus/TestSceneMusicActionHandling.cs
index 32009dc8c2..0c11c929c4 100644
--- a/osu.Game.Tests/Visual/Menus/TestSceneMusicActionHandling.cs
+++ b/osu.Game.Tests/Visual/Menus/TestSceneMusicActionHandling.cs
@@ -185,8 +185,12 @@ namespace osu.Game.Tests.Visual.Menus
             AddUntilStep("track changed", () => trackChangeQueue.Count == 1);
 
             AddStep("press previous", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPrev));
-            AddUntilStep("track changed", () =>
+            AddUntilStep("new track selected", () =>
                 trackChangeQueue.Count == 2 && !trackChangeQueue.First().working.BeatmapInfo.Equals(trackChangeQueue.Last().working.BeatmapInfo));
+
+            AddStep("press next", () => globalActionContainer.TriggerPressed(GlobalAction.MusicNext));
+            AddUntilStep("first track selected",
+                () => trackChangeQueue.Count == 3 && trackChangeQueue.First().working.BeatmapInfo.Equals(trackChangeQueue.Last().working.BeatmapInfo));
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Multiplayer/MultiplayerGameplayLeaderboardTestScene.cs b/osu.Game.Tests/Visual/Multiplayer/MultiplayerGameplayLeaderboardTestScene.cs
index 1eb08ad3c8..1481629ba0 100644
--- a/osu.Game.Tests/Visual/Multiplayer/MultiplayerGameplayLeaderboardTestScene.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/MultiplayerGameplayLeaderboardTestScene.cs
@@ -10,6 +10,7 @@ using Moq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
@@ -20,6 +21,7 @@ using osu.Game.Online.Spectator;
 using osu.Game.Replays.Legacy;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -29,11 +31,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         protected readonly BindableList<MultiplayerRoomUser> MultiplayerUsers = new BindableList<MultiplayerRoomUser>();
 
-        protected MultiplayerGameplayLeaderboard? Leaderboard { get; private set; }
+        protected MultiplayerLeaderboardProvider? LeaderboardProvider { get; private set; }
+
+        protected DrawableGameplayLeaderboard? Leaderboard { get; private set; }
 
         protected virtual MultiplayerRoomUser CreateUser(int userId) => new MultiplayerRoomUser(userId);
 
-        protected abstract MultiplayerGameplayLeaderboard CreateLeaderboard();
+        protected abstract MultiplayerLeaderboardProvider CreateLeaderboardProvider();
 
         private readonly BindableList<int> multiplayerUserIds = new BindableList<int>();
         private readonly BindableDictionary<int, SpectatorState> watchedUserStates = new BindableDictionary<int, SpectatorState>();
@@ -124,19 +128,38 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create leaderboard", () =>
             {
-                Leaderboard?.Expire();
+                Clear(true);
 
                 Beatmap.Value = CreateWorkingBeatmap(Ruleset.Value);
 
-                LoadComponentAsync(Leaderboard = CreateLeaderboard(), Add);
+                LoadComponentAsync(LeaderboardProvider = CreateLeaderboardProvider(), Add);
+                Add(new DependencyProvidingContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = [(typeof(IGameplayLeaderboardProvider), LeaderboardProvider)],
+                    Child = Leaderboard = new DrawableGameplayLeaderboard
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                });
             });
 
             AddUntilStep("wait for load", () => Leaderboard!.IsLoaded);
 
-            AddStep("check watch requests were sent", () =>
+            AddUntilStep("check watch requests were sent", () =>
             {
-                foreach (var user in MultiplayerUsers)
-                    spectatorClient.Verify(s => s.WatchUser(user.UserID), Times.Once);
+                try
+                {
+                    foreach (var user in MultiplayerUsers)
+                        spectatorClient.Verify(s => s.WatchUser(user.UserID), Times.Once);
+
+                    return true;
+                }
+                catch (MockException)
+                {
+                    return false;
+                }
             });
         }
 
@@ -159,10 +182,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 return false;
             });
 
-            AddStep("check stop watching requests were sent", () =>
+            AddUntilStep("check stop watching requests were sent", () =>
             {
-                foreach (var user in MultiplayerUsers)
-                    spectatorClient.Verify(s => s.StopWatchingUser(user.UserID), Times.Once);
+                try
+                {
+                    foreach (var user in MultiplayerUsers)
+                        spectatorClient.Verify(s => s.StopWatchingUser(user.UserID), Times.Once);
+                    return true;
+                }
+                catch (MockException)
+                {
+                    return false;
+                }
             });
         }
 
@@ -204,12 +235,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
                         header.Combo++;
                         header.MaxCombo = Math.Max(header.MaxCombo, header.Combo);
                         header.Statistics[HitResult.Meh]++;
+                        header.TotalScore += 50;
                         break;
 
                     default:
                         header.Combo++;
                         header.MaxCombo = Math.Max(header.MaxCombo, header.Combo);
                         header.Statistics[HitResult.Great]++;
+                        header.TotalScore += 300;
                         break;
                 }
 
@@ -218,3 +251,4 @@ namespace osu.Game.Tests.Visual.Multiplayer
         }
     }
 }
+
diff --git a/osu.Game.Tests/Visual/Multiplayer/QueueModeTestScene.cs b/osu.Game.Tests/Visual/Multiplayer/QueueModeTestScene.cs
index 0e01751d76..0e8093f459 100644
--- a/osu.Game.Tests/Visual/Multiplayer/QueueModeTestScene.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/QueueModeTestScene.cs
@@ -61,6 +61,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("import beatmap", () =>
             {
                 beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+                Realm.Write(r =>
+                {
+                    foreach (var beatmapInfo in r.All<BeatmapInfo>())
+                        beatmapInfo.OnlineMD5Hash = beatmapInfo.MD5Hash;
+                });
                 importedSet = beatmaps.GetAllUsableBeatmapSets().First();
                 InitialBeatmap = importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0);
                 OtherBeatmap = importedSet.Beatmaps.Last(b => b.Ruleset.OnlineID == 0);
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableLoungeRoom.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableLoungeRoom.cs
index 459a90d096..abb491ca31 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableLoungeRoom.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableLoungeRoom.cs
@@ -13,6 +13,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.Lounge;
@@ -30,7 +31,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Cached]
         protected readonly OverlayColourProvider ColourProvider = new OverlayColourProvider(OverlayColourScheme.Pink);
 
-        private DrawableLoungeRoom drawableRoom = null!;
+        private LoungeRoomPanel panel = null!;
         private SearchTextBox searchTextBox = null!;
 
         private readonly ManualResetEventSlim allowResponseCallback = new ManualResetEventSlim();
@@ -40,14 +41,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             var mockLounge = new Mock<IOnlinePlayLounge>();
             mockLounge
-                .Setup(l => l.Join(It.IsAny<Room>(), It.IsAny<string>(), It.IsAny<Action<Room>>(), It.IsAny<Action<string>>()))
-                .Callback<Room, string, Action<Room>, Action<string>>((_, _, _, d) =>
+                .Setup(l => l.Join(It.IsAny<Room>(), It.IsAny<string>(), It.IsAny<Action<Room>>(), It.IsAny<Action<string, Exception?>>()))
+                .Callback<Room, string, Action<Room>, Action<string, Exception?>>((_, _, _, d) =>
                 {
                     Task.Run(() =>
                     {
                         allowResponseCallback.Wait(10000);
                         allowResponseCallback.Reset();
-                        Schedule(() => d?.Invoke("Incorrect password"));
+                        Schedule(() => d?.Invoke("Incorrect password", new InvalidPasswordException()));
                     });
                 });
 
@@ -73,7 +74,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                             Width = 500,
                             Depth = float.MaxValue
                         },
-                        drawableRoom = new DrawableLoungeRoom(room)
+                        panel = new LoungeRoomPanel(room)
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
@@ -87,16 +88,16 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestFocusViaKeyboardCommit()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? popover = null;
+            LoungeRoomPanel.PasswordEntryPopover? popover = null;
 
             AddAssert("search textbox has focus", () => checkFocus(searchTextBox));
             AddStep("click room twice", () =>
             {
-                InputManager.MoveMouseTo(drawableRoom);
+                InputManager.MoveMouseTo(panel);
                 InputManager.Click(MouseButton.Left);
                 InputManager.Click(MouseButton.Left);
             });
-            AddUntilStep("wait for popover", () => (popover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().SingleOrDefault()) != null);
+            AddUntilStep("wait for popover", () => (popover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().SingleOrDefault()) != null);
 
             AddAssert("textbox has focus", () => checkFocus(popover.ChildrenOfType<OsuPasswordTextBox>().Single()));
 
@@ -122,16 +123,16 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestFocusViaMouseCommit()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? popover = null;
+            LoungeRoomPanel.PasswordEntryPopover? popover = null;
 
             AddAssert("search textbox has focus", () => checkFocus(searchTextBox));
             AddStep("click room twice", () =>
             {
-                InputManager.MoveMouseTo(drawableRoom);
+                InputManager.MoveMouseTo(panel);
                 InputManager.Click(MouseButton.Left);
                 InputManager.Click(MouseButton.Left);
             });
-            AddUntilStep("wait for popover", () => (popover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().SingleOrDefault()) != null);
+            AddUntilStep("wait for popover", () => (popover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().SingleOrDefault()) != null);
 
             AddAssert("textbox has focus", () => checkFocus(popover.ChildrenOfType<OsuPasswordTextBox>().Single()));
 
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs
index 18cd720bf2..7e19f45a00 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs
@@ -105,6 +105,19 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
         }
 
+        [Test]
+        public void TestMarkCompleted()
+        {
+            createPlaylist();
+            AddStep("mark some items as complete", () =>
+            {
+                playlist.Items[0].MarkCompleted();
+                playlist.Items[2].MarkCompleted();
+                playlist.Items[3].MarkCompleted();
+                playlist.Items[5].MarkCompleted();
+            });
+        }
+
         [Test]
         public void TestSelectable()
         {
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneHostOnlyQueueMode.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneHostOnlyQueueMode.cs
index 55c9e8142f..7d3d30b9f9 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneHostOnlyQueueMode.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneHostOnlyQueueMode.cs
@@ -105,7 +105,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("select other beatmap", () => ((Screens.Select.SongSelect)CurrentSubScreen).FinaliseSelection(otherBeatmap = beatmap()));
 
             AddUntilStep("wait for return to match", () => CurrentSubScreen is MultiplayerMatchSubScreen);
-            AddUntilStep("selected item is new beatmap", () => (CurrentSubScreen as MultiplayerMatchSubScreen)?.SelectedItem.Value?.Beatmap.OnlineID == otherBeatmap.OnlineID);
+            AddUntilStep("selected item is new beatmap", () => Beatmap.Value.BeatmapInfo.OnlineID == otherBeatmap.OnlineID);
         }
 
         private void addItem(Func<BeatmapInfo> beatmap)
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs
index 60358dfbc4..806de68f07 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs
@@ -9,15 +9,16 @@ using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
-using osu.Game.Screens.OnlinePlay.Multiplayer.Spectate;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
     public partial class TestSceneMultiSpectatorLeaderboard : MultiplayerTestScene
     {
         private Dictionary<int, ManualClock> clocks = null!;
-        private MultiSpectatorLeaderboard? leaderboard;
+        private MultiSpectatorLeaderboardProvider? leaderboardProvider;
+        private DrawableGameplayLeaderboard leaderboard = null!;
 
         [SetUpSteps]
         public override void SetUpSteps()
@@ -29,7 +30,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("reset", () =>
             {
-                leaderboard?.RemoveAndDisposeImmediately();
+                Clear(true);
 
                 clocks = new Dictionary<int, ManualClock>
                 {
@@ -48,21 +49,27 @@ namespace osu.Game.Tests.Visual.Multiplayer
             {
                 Beatmap.Value = CreateWorkingBeatmap(Ruleset.Value);
 
-                LoadComponentAsync(leaderboard = new MultiSpectatorLeaderboard(clocks.Keys.Select(id => new MultiplayerRoomUser(id)).ToArray())
+                LoadComponentAsync(leaderboardProvider = new MultiSpectatorLeaderboardProvider(clocks.Keys.Select(id => new MultiplayerRoomUser(id)).ToArray()), Add);
+                Add(new DependencyProvidingContainer
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Expanded = { Value = true }
-                }, Add);
+                    RelativeSizeAxes = Axes.Both,
+                    CachedDependencies = [(typeof(IGameplayLeaderboardProvider), leaderboardProvider)],
+                    Child = leaderboard = new DrawableGameplayLeaderboard
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Expanded = { Value = true }
+                    }
+                });
             });
 
-            AddUntilStep("wait for load", () => leaderboard!.IsLoaded);
-            AddUntilStep("wait for user population", () => leaderboard.ChildrenOfType<GameplayLeaderboardScore>().Count() == 2);
+            AddUntilStep("wait for load", () => leaderboard.IsLoaded);
+            AddUntilStep("wait for user population", () => leaderboard.ChildrenOfType<DrawableGameplayLeaderboardScore>().Count() == 2);
 
             AddStep("add clock sources", () =>
             {
                 foreach ((int userId, var clock) in clocks)
-                    leaderboard!.AddClock(userId, clock);
+                    leaderboardProvider!.AddClock(userId, clock);
             });
         }
 
@@ -123,6 +130,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
             => AddStep($"set user {userId} time {time}", () => clocks[userId].CurrentTime = time);
 
         private void assertCombo(int userId, int expectedCombo)
-            => AddUntilStep($"player {userId} has {expectedCombo} combo", () => this.ChildrenOfType<GameplayLeaderboardScore>().Single(s => s.User?.OnlineID == userId).Combo.Value == expectedCombo);
+            => AddUntilStep($"player {userId} has {expectedCombo} combo", () => this.ChildrenOfType<DrawableGameplayLeaderboardScore>().Single(s => s.User?.OnlineID == userId).Combo.Value == expectedCombo);
     }
 }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
index aa98dc59db..6f6d7b31b5 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
@@ -560,7 +560,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private PlayerArea getInstance(int userId) => spectatorScreen.ChildrenOfType<PlayerArea>().Single(p => p.UserId == userId);
 
-        private GameplayLeaderboardScore getLeaderboardScore(int userId) => spectatorScreen.ChildrenOfType<GameplayLeaderboardScore>().Single(s => s.User?.OnlineID == userId);
+        private DrawableGameplayLeaderboardScore getLeaderboardScore(int userId) => spectatorScreen.ChildrenOfType<DrawableGameplayLeaderboardScore>().Single(s => s.User?.OnlineID == userId);
 
         private int[] getPlayerIds(int count) => Enumerable.Range(PLAYER_1_ID, count).ToArray();
     }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
index ae939c7b9e..03fe9b8b58 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
@@ -81,6 +81,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("import beatmap", () =>
             {
                 beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+                Realm.Write(r =>
+                {
+                    foreach (var beatmapInfo in r.All<BeatmapInfo>())
+                        beatmapInfo.OnlineMD5Hash = beatmapInfo.MD5Hash;
+                });
                 importedSet = beatmaps.GetAllUsableBeatmapSets().First();
             });
 
@@ -269,7 +274,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("refresh rooms", () => this.ChildrenOfType<LoungeSubScreen>().Single().UpdateFilter());
-            AddUntilStep("wait for room", () => this.ChildrenOfType<DrawableRoom>().Any());
+            AddUntilStep("wait for room", () => this.ChildrenOfType<RoomPanel>().Any());
 
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("join room and immediately exit select", () =>
@@ -298,7 +303,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("refresh rooms", () => this.ChildrenOfType<LoungeSubScreen>().Single().UpdateFilter());
-            AddUntilStep("wait for room", () => this.ChildrenOfType<DrawableRoom>().Any());
+            AddUntilStep("wait for room", () => this.ChildrenOfType<RoomPanel>().Any());
 
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("join room", () => InputManager.Key(Key.Enter));
@@ -349,13 +354,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("refresh rooms", () => this.ChildrenOfType<LoungeSubScreen>().Single().UpdateFilter());
-            AddUntilStep("wait for room", () => this.ChildrenOfType<DrawableRoom>().Any());
+            AddUntilStep("wait for room", () => this.ChildrenOfType<RoomPanel>().Any());
 
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("join room", () => InputManager.Key(Key.Enter));
 
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "password");
             AddStep("press join room button", () => passwordEntryPopover.ChildrenOfType<OsuButton>().First().TriggerClick());
 
@@ -438,7 +443,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("Enter song select", () =>
             {
                 var currentSubScreen = ((Screens.OnlinePlay.Multiplayer.Multiplayer)multiplayerComponents.CurrentScreen).CurrentSubScreen;
-                ((MultiplayerMatchSubScreen)currentSubScreen).OpenSongSelection(item);
+                ((MultiplayerMatchSubScreen)currentSubScreen).ShowSongSelect(item);
             });
 
             AddUntilStep("wait for song select", () => this.ChildrenOfType<MultiplayerMatchSongSelect>().FirstOrDefault()?.BeatmapSetsLoaded == true);
@@ -479,7 +484,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("Enter song select", () =>
             {
                 var currentSubScreen = ((Screens.OnlinePlay.Multiplayer.Multiplayer)multiplayerComponents.CurrentScreen).CurrentSubScreen;
-                ((MultiplayerMatchSubScreen)currentSubScreen).OpenSongSelection(item);
+                ((MultiplayerMatchSubScreen)currentSubScreen).ShowSongSelect(item);
             });
 
             AddUntilStep("wait for song select", () => this.ChildrenOfType<MultiplayerMatchSongSelect>().FirstOrDefault()?.BeatmapSetsLoaded == true);
@@ -520,7 +525,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("Enter song select", () =>
             {
                 var currentSubScreen = ((Screens.OnlinePlay.Multiplayer.Multiplayer)multiplayerComponents.CurrentScreen).CurrentSubScreen;
-                ((MultiplayerMatchSubScreen)currentSubScreen).OpenSongSelection(item);
+                ((MultiplayerMatchSubScreen)currentSubScreen).ShowSongSelect(item);
             });
 
             AddUntilStep("wait for song select", () => this.ChildrenOfType<MultiplayerMatchSongSelect>().FirstOrDefault()?.BeatmapSetsLoaded == true);
@@ -652,7 +657,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("invoke on back button", () => multiplayerComponents.OnBackButton());
 
-            AddAssert("mod overlay is hidden", () => this.ChildrenOfType<RoomSubScreen>().Single().UserModsSelectOverlay.State.Value == Visibility.Hidden);
+            AddAssert("mod overlay is hidden", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().State.Value == Visibility.Hidden);
 
             AddAssert("dialog overlay is hidden", () => DialogOverlay.State.Value == Visibility.Hidden);
 
@@ -802,7 +807,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddStep("refresh rooms", () => this.ChildrenOfType<LoungeSubScreen>().Single().UpdateFilter());
-            AddUntilStep("wait for room", () => this.ChildrenOfType<DrawableRoom>().Any());
+            AddUntilStep("wait for room", () => this.ChildrenOfType<RoomPanel>().Any());
             AddStep("select room", () => InputManager.Key(Key.Down));
 
             AddStep("disable polling", () => this.ChildrenOfType<LoungeListingPoller>().Single().TimeBetweenPolls.Value = 0);
@@ -823,11 +828,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for room open", () => this.ChildrenOfType<MultiplayerMatchSubScreen>().FirstOrDefault()?.IsLoaded == true);
             AddUntilStep("wait for join", () => multiplayerClient.RoomJoined);
 
-            AddAssert("local room has correct settings", () =>
-            {
-                var localRoom = this.ChildrenOfType<MultiplayerMatchSubScreen>().Single().Room;
-                return localRoom.Name == multiplayerClient.ServerSideRooms[0].Name && localRoom.Playlist.Single().ID == 2;
-            });
+            AddAssert("local room has correct name", () => this.ChildrenOfType<MultiplayerRoomPanel>().Single().Room.Name, () => Is.EqualTo(multiplayerClient.ServerSideRooms[0].Name));
+            AddAssert("local room has correct playlist", () => this.ChildrenOfType<MultiplayerQueueList>().Single().Items.Single().ID, () => Is.EqualTo(2));
         }
 
         [Test]
@@ -1054,6 +1056,45 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("hidden is selected", () => SelectedMods.Value, () => Has.One.TypeOf(typeof(OsuModHidden)));
         }
 
+        [FlakyTest]
+        [Test]
+        public void TestGlobalBeatmapDoesNotChangeAtResults()
+        {
+            createRoom(() => new Room
+            {
+                Name = "Test Room",
+                QueueMode = QueueMode.AllPlayers,
+                Playlist =
+                [
+                    new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0)).BeatmapInfo)
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
+                        AllowedMods = new[] { new APIMod { Acronym = "HD" } },
+                    },
+                    new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 1)).BeatmapInfo)
+                    {
+                        RulesetID = new TaikoRuleset().RulesetInfo.OnlineID,
+                        AllowedMods = new[] { new APIMod { Acronym = "HD" } },
+                    },
+                ]
+            });
+
+            enterGameplay();
+
+            // Gameplay runs in real-time, so we need to incrementally check if gameplay has finished in order to not time out.
+            for (double i = 1000; i < TestResources.QUICK_BEATMAP_LENGTH; i += 1000)
+            {
+                double time = i;
+                AddUntilStep($"wait for time > {i}", () => this.ChildrenOfType<GameplayClockContainer>().SingleOrDefault()?.CurrentTime > time);
+            }
+
+            AddUntilStep("wait for results", () => multiplayerComponents.CurrentScreen is ResultsScreen);
+
+            AddAssert("global beatmap still matches first playlist item", () => Beatmap.Value.BeatmapInfo.OnlineID, () => Is.EqualTo(multiplayerClient.ClientRoom!.Playlist[0].BeatmapID));
+            AddStep("return to match", () => multiplayerComponents.Exit());
+            AddAssert("global beatmap matches second playlist item", () => Beatmap.Value.BeatmapInfo.OnlineID, () => Is.EqualTo(multiplayerClient.ClientRoom!.Playlist[1].BeatmapID));
+        }
+
         private void enterGameplay()
         {
             pressReadyButton();
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboard.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboard.cs
index 2f232a6164..53e265decb 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboard.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboard.cs
@@ -9,7 +9,7 @@ using osu.Game.Online.API;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -25,27 +25,25 @@ namespace osu.Game.Tests.Visual.Multiplayer
             return user;
         }
 
-        protected override MultiplayerGameplayLeaderboard CreateLeaderboard()
-        {
-            return new TestLeaderboard(MultiplayerUsers.ToArray())
+        protected override MultiplayerLeaderboardProvider CreateLeaderboardProvider() =>
+            new TestLeaderboard(MultiplayerUsers.ToArray())
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             };
-        }
 
         [Test]
         public void TestPerUserMods()
         {
-            AddStep("first user has no mods", () => Assert.That(((TestLeaderboard)Leaderboard!).UserMods[0], Is.Empty));
+            AddStep("first user has no mods", () => Assert.That(((TestLeaderboard)LeaderboardProvider!).UserMods[0], Is.Empty));
             AddStep("last user has NF mod", () =>
             {
-                Assert.That(((TestLeaderboard)Leaderboard!).UserMods[TOTAL_USERS - 1], Has.One.Items);
-                Assert.That(((TestLeaderboard)Leaderboard).UserMods[TOTAL_USERS - 1].Single(), Is.TypeOf<OsuModNoFail>());
+                Assert.That(((TestLeaderboard)LeaderboardProvider!).UserMods[TOTAL_USERS - 1], Has.One.Items);
+                Assert.That(((TestLeaderboard)LeaderboardProvider).UserMods[TOTAL_USERS - 1].Single(), Is.TypeOf<OsuModNoFail>());
             });
         }
 
-        private partial class TestLeaderboard : MultiplayerGameplayLeaderboard
+        private partial class TestLeaderboard : MultiplayerLeaderboardProvider
         {
             public Dictionary<int, IReadOnlyList<Mod>> UserMods => UserScores.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ScoreProcessor.Mods);
 
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboardTeams.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboardTeams.cs
index 3f1db308c0..15efde7abe 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboardTeams.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboardTeams.cs
@@ -7,6 +7,7 @@ using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -24,8 +25,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
             return user;
         }
 
-        protected override MultiplayerGameplayLeaderboard CreateLeaderboard() =>
-            new MultiplayerGameplayLeaderboard(MultiplayerUsers.ToArray())
+        protected override MultiplayerLeaderboardProvider CreateLeaderboardProvider() =>
+            new MultiplayerLeaderboardProvider(MultiplayerUsers.ToArray())
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -39,17 +40,17 @@ namespace osu.Game.Tests.Visual.Multiplayer
             {
                 LoadComponentAsync(new MatchScoreDisplay
                 {
-                    Team1Score = { BindTarget = Leaderboard!.TeamScores[0] },
-                    Team2Score = { BindTarget = Leaderboard.TeamScores[1] }
+                    Team1Score = { BindTarget = LeaderboardProvider!.TeamScores[0] },
+                    Team2Score = { BindTarget = LeaderboardProvider.TeamScores[1] }
                 }, Add);
 
                 LoadComponentAsync(new GameplayMatchScoreDisplay
                 {
                     Anchor = Anchor.BottomCentre,
                     Origin = Anchor.BottomCentre,
-                    Team1Score = { BindTarget = Leaderboard.TeamScores[0] },
-                    Team2Score = { BindTarget = Leaderboard.TeamScores[1] },
-                    Expanded = { BindTarget = Leaderboard.Expanded },
+                    Team1Score = { BindTarget = LeaderboardProvider.TeamScores[0] },
+                    Team2Score = { BindTarget = LeaderboardProvider.TeamScores[1] },
+                    Expanded = { BindTarget = Leaderboard!.Expanded },
                 }, Add);
             });
         }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerLoungeSubScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerLoungeSubScreen.cs
index 56187f8778..f1915233e0 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerLoungeSubScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerLoungeSubScreen.cs
@@ -45,7 +45,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
 
-            AddUntilStep("password prompt appeared", () => InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+            AddUntilStep("password prompt appeared", () => InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().Any());
 
             AddAssert("textbox has focus", () => InputManager.FocusedDrawable is OsuPasswordTextBox);
 
@@ -53,7 +53,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("textbox lost focus", () => InputManager.FocusedDrawable is SearchTextBox);
 
             AddStep("hit escape", () => InputManager.Key(Key.Escape));
-            AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+            AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().Any());
 
             AddAssert("room not joined", () => !MultiplayerClient.RoomJoined);
         }
@@ -65,9 +65,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
 
-            AddUntilStep("password prompt appeared", () => InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+            AddUntilStep("password prompt appeared", () => InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().Any());
             AddStep("exit screen", () => Stack.Exit());
-            AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+            AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().Any());
 
             AddAssert("room not joined", () => !MultiplayerClient.RoomJoined);
         }
@@ -75,12 +75,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestJoinRoomWithIncorrectPasswordViaButton()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
 
             createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "wrong");
             AddStep("press join room button", () => passwordEntryPopover.ChildrenOfType<OsuButton>().First().TriggerClick());
 
@@ -94,12 +94,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestJoinRoomWithIncorrectPasswordViaEnter()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
 
             createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "wrong");
             AddStep("press enter", () => InputManager.Key(Key.Enter));
 
@@ -113,12 +113,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestJoinRoomWithCorrectPassword()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
 
             createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "password");
             AddStep("press join room button", () => passwordEntryPopover.ChildrenOfType<OsuButton>().First().TriggerClick());
 
@@ -128,12 +128,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestJoinRoomWithPasswordViaKeyboardOnly()
         {
-            DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
+            LoungeRoomPanel.PasswordEntryPopover? passwordEntryPopover = null;
 
             createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
-            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
+            AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<LoungeRoomPanel.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "password");
             AddStep("press enter", () => InputManager.Key(Key.Enter));
 
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
index e5e4921a17..2def7aeb1c 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
@@ -1,12 +1,14 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
@@ -185,7 +187,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("mod select contents loaded",
                 () => this.ChildrenOfType<ModColumn>().Any() && this.ChildrenOfType<ModColumn>().All(col => col.IsLoaded && col.ItemsLoaded));
             AddUntilStep("mod select contains only double time mod",
-                () => this.ChildrenOfType<RoomSubScreen>().Single().UserModsSelectOverlay
+                () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single()
                           .ChildrenOfType<ModPanel>()
                           .SingleOrDefault(panel => panel.Visible)?.Mod is OsuModDoubleTime);
         }
@@ -211,7 +213,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("press toggle mod select key", () => InputManager.Key(Key.F1));
 
-            AddUntilStep("mod select shown", () => this.ChildrenOfType<RoomSubScreen>().Single().UserModsSelectOverlay.State.Value == Visibility.Visible);
+            AddUntilStep("mod select shown", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().State.Value == Visibility.Visible);
         }
 
         [Test]
@@ -234,7 +236,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("press toggle mod select key", () => InputManager.Key(Key.F1));
 
             AddWaitStep("wait some", 3);
-            AddAssert("mod select not shown", () => this.ChildrenOfType<RoomSubScreen>().Single().UserModsSelectOverlay.State.Value == Visibility.Hidden);
+            AddAssert("mod select not shown", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().State.Value == Visibility.Hidden);
         }
 
         [Test]
@@ -306,10 +308,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("mod select shows unranked", () => this.ChildrenOfType<RankingInformationDisplay>().Single().Ranked.Value == false);
             AddAssert("score multiplier = 1.20", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.2).Within(0.01));
 
-            AddStep("select flashlight", () => screen.UserModsSelectOverlay.ChildrenOfType<ModPanel>().Single(m => m.Mod is ModFlashlight).TriggerClick());
+            AddStep("select flashlight", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().ChildrenOfType<ModPanel>().Single(m => m.Mod is ModFlashlight).TriggerClick());
             AddAssert("score multiplier = 1.35", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.35).Within(0.01));
 
-            AddStep("change flashlight setting", () => ((OsuModFlashlight)screen.UserModsSelectOverlay.SelectedMods.Value.Single()).FollowDelay.Value = 1200);
+            AddStep("change flashlight setting", () => ((OsuModFlashlight)this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().SelectedMods.Value.Single()).FollowDelay.Value = 1200);
             AddAssert("score multiplier = 1.20", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.2).Within(0.01));
         }
 
@@ -330,10 +332,98 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for join", () => RoomJoined);
 
-            AddUntilStep("button visible", () => this.ChildrenOfType<DrawableMatchRoom>().Single().ChangeSettingsButton?.Alpha, () => Is.GreaterThan(0));
+            AddUntilStep("button visible", () => this.ChildrenOfType<MultiplayerRoomPanel>().Single().ChangeSettingsButton.Alpha, () => Is.GreaterThan(0));
             AddStep("join other user", void () => MultiplayerClient.AddUser(new APIUser { Id = PLAYER_1_ID }));
             AddStep("make other user host", () => MultiplayerClient.TransferHost(PLAYER_1_ID));
-            AddAssert("button hidden", () => this.ChildrenOfType<DrawableMatchRoom>().Single().ChangeSettingsButton?.Alpha, () => Is.EqualTo(0));
+            AddAssert("button hidden", () => this.ChildrenOfType<MultiplayerRoomPanel>().Single().ChangeSettingsButton.Alpha, () => Is.EqualTo(0));
+        }
+
+        [Test]
+        public void TestUserModSelectUpdatesWhenNotVisible()
+        {
+            AddStep("add playlist item", () =>
+            {
+                room.Playlist =
+                [
+                    new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
+                        AllowedMods = [new APIMod(new OsuModFlashlight())]
+                    }
+                ];
+            });
+
+            ClickButtonWhenEnabled<MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>();
+            AddUntilStep("wait for join", () => RoomJoined);
+
+            // 1. Open the mod select overlay and enable flashlight
+
+            ClickButtonWhenEnabled<UserModSelectButton>();
+            AddUntilStep("mod select contents loaded", () => this.ChildrenOfType<ModColumn>().Any() && this.ChildrenOfType<ModColumn>().All(col => col.IsLoaded && col.ItemsLoaded));
+            AddStep("click flashlight panel", () =>
+            {
+                ModPanel panel = this.ChildrenOfType<ModPanel>().Single(p => p.Mod is OsuModFlashlight);
+                InputManager.MoveMouseTo(panel);
+                InputManager.Click(MouseButton.Left);
+            });
+            AddUntilStep("flashlight mod enabled", () => MultiplayerClient.ClientRoom!.Users[0].Mods.Any());
+
+            // 2. Close the mod select overlay, edit the playlist to disable allowed mods, and then edit it again to re-enable allowed mods.
+
+            AddStep("close mod select overlay", () => this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().Hide());
+            AddUntilStep("mod select overlay not present", () => !this.ChildrenOfType<MultiplayerUserModSelectOverlay>().Single().IsPresent);
+            AddStep("disable allowed mods", () => MultiplayerClient.EditPlaylistItem(new MultiplayerPlaylistItem(new PlaylistItem(MultiplayerClient.ServerRoom!.Playlist[0])
+            {
+                AllowedMods = []
+            })));
+            // This would normally be done as part of the above operation with an actual server.
+            AddStep("disable user mods", () => MultiplayerClient.ChangeUserMods(API.LocalUser.Value.OnlineID, Array.Empty<APIMod>()));
+            AddUntilStep("flashlight mod disabled", () => !MultiplayerClient.ClientRoom!.Users[0].Mods.Any());
+            AddStep("re-enable allowed mods", () => MultiplayerClient.EditPlaylistItem(new MultiplayerPlaylistItem(new PlaylistItem(MultiplayerClient.ServerRoom!.Playlist[0])
+            {
+                AllowedMods = [new APIMod(new OsuModFlashlight())]
+            })));
+            AddAssert("flashlight mod still disabled", () => !MultiplayerClient.ClientRoom!.Users[0].Mods.Any());
+
+            // 3. Open the mod select overlay, check that the flashlight mod panel is deactivated.
+
+            ClickButtonWhenEnabled<UserModSelectButton>();
+            AddUntilStep("mod select contents loaded", () => this.ChildrenOfType<ModColumn>().Any() && this.ChildrenOfType<ModColumn>().All(col => col.IsLoaded && col.ItemsLoaded));
+            AddAssert("flashlight mod still disabled", () => !MultiplayerClient.ClientRoom!.Users[0].Mods.Any());
+            AddAssert("flashlight mod panel not activated", () => !this.ChildrenOfType<ModPanel>().Single(p => p.Mod is OsuModFlashlight).Active.Value);
+        }
+
+        [Test]
+        public void TestStartCountdown()
+        {
+            AddStep("set playlist", () =>
+            {
+                room.Playlist =
+                [
+                    new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First()).BeatmapInfo)
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID
+                    }
+                ];
+            });
+
+            ClickButtonWhenEnabled<MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>();
+
+            AddUntilStep("wait for room join", () => RoomJoined);
+
+            AddStep("click countdown button", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<MultiplayerCountdownButton>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("start a countdown", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<Popover>().Single().ChildrenOfType<Button>().First());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddUntilStep("countdown started", () => MultiplayerClient.ServerRoom!.ActiveCountdowns.Any());
         }
 
         private partial class TestMultiplayerMatchSubScreen : MultiplayerMatchSubScreen
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs
index 1affa08813..c6a203c77a 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs
@@ -6,7 +6,6 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Platform;
@@ -32,7 +31,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private BeatmapManager beatmaps = null!;
         private BeatmapSetInfo importedSet = null!;
         private BeatmapInfo importedBeatmap = null!;
-        private Room room = null!;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
@@ -47,19 +45,17 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             base.SetUpSteps();
 
-            AddStep("create room", () => room = CreateDefaultRoom());
-            AddStep("join room", () => JoinRoom(room));
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom()));
             WaitForJoined();
 
             AddStep("create list", () =>
             {
-                Child = list = new MultiplayerPlaylist(room)
+                Child = list = new MultiplayerPlaylist
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
-                    Size = new Vector2(0.4f, 0.8f),
-                    SelectedItem = new Bindable<PlaylistItem?>()
+                    Size = new Vector2(0.4f, 0.8f)
                 };
             });
 
@@ -158,37 +154,36 @@ namespace osu.Game.Tests.Visual.Multiplayer
             assertQueueTabCount(0);
         }
 
-        [Ignore("Expired items are initially removed from the room.")]
         [Test]
         public void TestJoinRoomWithMixedItemsAddedInCorrectLists()
         {
             AddStep("leave room", () => MultiplayerClient.LeaveRoom());
             AddUntilStep("wait for room part", () => !RoomJoined);
 
-            AddStep("join room with items", () =>
+            AddStep("join room with expired items", () =>
             {
-                API.Queue(new CreateRoomRequest(new Room
-                {
-                    Name = "test name",
-                    Playlist =
-                    [
-                        new PlaylistItem(new TestBeatmap(Ruleset.Value).BeatmapInfo)
-                        {
-                            RulesetID = Ruleset.Value.OnlineID
-                        },
-                        new PlaylistItem(new TestBeatmap(Ruleset.Value).BeatmapInfo)
-                        {
-                            RulesetID = Ruleset.Value.OnlineID,
-                            Expired = true
-                        }
-                    ]
-                }));
+                Room room = CreateDefaultRoom();
+                room.Playlist =
+                [
+                    new PlaylistItem(new TestBeatmap(Ruleset.Value).BeatmapInfo)
+                    {
+                        RulesetID = Ruleset.Value.OnlineID
+                    },
+                    new PlaylistItem(new TestBeatmap(Ruleset.Value).BeatmapInfo)
+                    {
+                        RulesetID = Ruleset.Value.OnlineID,
+                        Expired = true
+                    }
+                ];
+
+                JoinRoom(room);
             });
 
-            AddUntilStep("wait for room join", () => RoomJoined);
+            WaitForJoined();
 
-            assertItemInQueueListStep(1, 0);
-            assertItemInHistoryListStep(2, 0);
+            // IDs are offset by 1 because we've joined two rooms in this test.
+            assertItemInQueueListStep(2, 0);
+            assertItemInHistoryListStep(3, 0);
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerQueueList.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerQueueList.cs
index 7283e3a1fe..d7659351bb 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerQueueList.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerQueueList.cs
@@ -49,13 +49,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create playlist", () =>
             {
-                Child = playlist = new MultiplayerQueueList(room)
+                Child = playlist = new MultiplayerQueueList
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = new Vector2(500, 300),
+                    Size = new Vector2(500, 300)
                 };
 
+                playlist.Items.ReplaceRange(0, playlist.Items.Count, MultiplayerClient.ClientAPIRoom!.Playlist);
+
                 MultiplayerClient.ClientAPIRoom!.PropertyChanged += (_, e) =>
                 {
                     if (e.PropertyName == nameof(Room.Playlist))
@@ -132,6 +134,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
             assertDeleteButtonVisibility(1, false);
         }
 
+        [Test]
+        public void TestChangeExistingItem()
+        {
+            AddStep("change beatmap", () => MultiplayerClient.EditPlaylistItem(new MultiplayerPlaylistItem
+            {
+                ID = playlist.Items[0].ID,
+                BeatmapID = 1337
+            }).WaitSafely());
+
+            AddUntilStep("first playlist item has new beatmap", () => playlist.Items[0].Beatmap.OnlineID, () => Is.EqualTo(1337));
+        }
+
         private void addPlaylistItem(Func<int> userId)
         {
             long itemId = -1;
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerUserModDisplay.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerUserModDisplay.cs
new file mode 100644
index 0000000000..02b97c6dd6
--- /dev/null
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerUserModDisplay.cs
@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Online.API;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.OnlinePlay.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public partial class TestSceneMultiplayerUserModDisplay : MultiplayerTestScene
+    {
+        private MultiplayerUserModDisplay modDisplay = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom()));
+            WaitForJoined();
+
+            AddStep("add display", () => Child = modDisplay = new MultiplayerUserModDisplay
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            });
+        }
+
+        [Test]
+        public void TestChangeMods()
+        {
+            AddStep("set DT", () => MultiplayerClient.ChangeUserMods([new OsuModDoubleTime()]).WaitSafely());
+            AddUntilStep("mod displayed", () => modDisplay.ChildrenOfType<ModIcon>().Count() == 1);
+
+            AddStep("set DT, HR", () => MultiplayerClient.ChangeUserMods([new OsuModDoubleTime(), new OsuModHardRock()]).WaitSafely());
+            AddUntilStep("mods displayed", () => modDisplay.ChildrenOfType<ModIcon>().Count() == 2);
+
+            AddStep("set no mods", () => MultiplayerClient.ChangeUserMods(Enumerable.Empty<APIMod>()).WaitSafely());
+            AddUntilStep("no mods displayed", () => !modDisplay.ChildrenOfType<ModIcon>().Any());
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
index 27c5758afa..58473f5fa2 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
@@ -201,6 +201,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private bool checkRoomSelected(Room? room) => selectedRoom.Value == room;
 
         private Room? getRoomInFlow(int index) =>
-            (container.ChildrenOfType<FillFlowContainer<DrawableLoungeRoom>>().First().FlowingChildren.ElementAt(index) as DrawableRoom)?.Room;
+            (container.ChildrenOfType<FillFlowContainer<LoungeRoomPanel>>().First().FlowingChildren.ElementAt(index) as RoomPanel)?.Room;
     }
 }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoom.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
similarity index 84%
rename from osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoom.cs
rename to osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
index 021c0abf1d..fee5e62958 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoom.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
@@ -18,13 +18,13 @@ using osu.Game.Overlays;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
-using osu.Game.Screens.OnlinePlay.Match;
+using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Tests.Beatmaps;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
-    public partial class TestSceneDrawableRoom : OsuTestScene
+    public partial class TestSceneRoomPanel : OsuTestScene
     {
         [Cached]
         protected readonly OverlayColourProvider ColourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
@@ -129,24 +129,24 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestEnableAndDisablePassword()
         {
-            DrawableRoom drawableRoom = null!;
+            RoomPanel panel = null!;
             Room room = null!;
 
-            AddStep("create room", () => Child = drawableRoom = createLoungeRoom(room = new Room
+            AddStep("create room", () => Child = panel = createLoungeRoom(room = new Room
             {
                 Name = "Room with password",
                 Type = MatchType.HeadToHead,
             }));
 
-            AddUntilStep("wait for panel load", () => drawableRoom.ChildrenOfType<DrawableRoomParticipantsList>().Any());
+            AddUntilStep("wait for panel load", () => panel.ChildrenOfType<DrawableRoomParticipantsList>().Any());
 
-            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, drawableRoom.ChildrenOfType<DrawableRoom.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
 
             AddStep("set password", () => room.Password = "password");
-            AddAssert("password icon visible", () => Precision.AlmostEquals(1, drawableRoom.ChildrenOfType<DrawableRoom.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon visible", () => Precision.AlmostEquals(1, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
 
             AddStep("unset password", () => room.Password = string.Empty);
-            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, drawableRoom.ChildrenOfType<DrawableRoom.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
         }
 
         [Test]
@@ -160,38 +160,29 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 Spacing = new Vector2(5),
                 Children = new[]
                 {
-                    new DrawableMatchRoom(new Room
+                    new MultiplayerRoomPanel(new Room
                     {
                         Name = "A host-only room",
                         QueueMode = QueueMode.HostOnly,
                         Type = MatchType.HeadToHead,
-                    })
-                    {
-                        SelectedItem = new Bindable<PlaylistItem?>()
-                    },
-                    new DrawableMatchRoom(new Room
+                    }),
+                    new MultiplayerRoomPanel(new Room
                     {
                         Name = "An all-players, team-versus room",
                         QueueMode = QueueMode.AllPlayers,
                         Type = MatchType.TeamVersus
-                    })
-                    {
-                        SelectedItem = new Bindable<PlaylistItem?>()
-                    },
-                    new DrawableMatchRoom(new Room
+                    }),
+                    new MultiplayerRoomPanel(new Room
                     {
                         Name = "A round-robin room",
                         QueueMode = QueueMode.AllPlayersRoundRobin,
                         Type = MatchType.HeadToHead
-                    })
-                    {
-                        SelectedItem = new Bindable<PlaylistItem?>()
-                    },
+                    }),
                 }
             });
         }
 
-        private DrawableRoom createLoungeRoom(Room room)
+        private RoomPanel createLoungeRoom(Room room)
         {
             room.Host ??= new APIUser { Username = "peppy", Id = 2 };
 
@@ -204,7 +195,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 }).ToArray();
             }
 
-            return new DrawableLoungeRoom(room)
+            return new LoungeRoomPanel(room)
             {
                 MatchingFilter = true,
                 SelectedRoom = selectedRoom
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
index 8c4fcc461c..312781ef1a 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
@@ -33,6 +33,10 @@ using osu.Game.Overlays.BeatmapListing;
 using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Overlays.Toolbar;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Mania.Configuration;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Scoring;
@@ -394,6 +398,60 @@ namespace osu.Game.Tests.Visual.Navigation
             }
         }
 
+        [Test]
+        public void TestScrollSpeedAdjustDuringGameplay()
+        {
+            Player player = null;
+
+            Screens.Select.SongSelect songSelect = null;
+            PushAndConfirm(() => songSelect = new TestPlaySongSelect());
+            AddUntilStep("wait for song select", () => songSelect.BeatmapSetsLoaded);
+
+            AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game).WaitSafely());
+
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("switch to mania ruleset", () =>
+            {
+                InputManager.PressKey(Key.LControl);
+                InputManager.Key(Key.Number4);
+                InputManager.ReleaseKey(Key.LControl);
+            });
+
+            AddStep("set mods", () => Game.SelectedMods.Value = new Mod[] { new OsuModNoFail() });
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
+
+            AddUntilStep("wait for player", () =>
+            {
+                DismissAnyNotifications();
+                player = Game.ScreenStack.CurrentScreen as Player;
+                return player?.IsLoaded == true;
+            });
+
+            AddUntilStep("wait for track playing", () => Game.Beatmap.Value.Track.IsRunning);
+            checkScrollSpeed(8, 8);
+
+            AddStep("adjust scroll speed via keyboard", () => InputManager.Key(Key.F4));
+            checkScrollSpeed(9, 9);
+
+            AddStep("seek beyond 10 seconds", () => player.ChildrenOfType<GameplayClockContainer>().First().Seek(10500));
+            AddUntilStep("wait for seek", () => player.ChildrenOfType<GameplayClockContainer>().First().CurrentTime, () => Is.GreaterThan(10600));
+            AddStep("attempt adjust offset via keyboard", () => InputManager.Key(Key.F4));
+            checkScrollSpeed(9, 9);
+
+            AddStep("attempt adjust offset via config change", () => getConfigManager().SetValue(ManiaRulesetSetting.ScrollSpeed, 10.0));
+            checkScrollSpeed(10, 9);
+
+            void checkScrollSpeed(double configValue, double gameplayValue)
+            {
+                AddUntilStep($"config value is {configValue}", () => getConfigManager().Get<double>(ManiaRulesetSetting.ScrollSpeed), () => Is.EqualTo(configValue));
+                AddUntilStep($"gameplay value is {gameplayValue}", () => this.ChildrenOfType<DrawableManiaRuleset>().Single().TargetTimeRange,
+                    () => Is.EqualTo(DrawableManiaRuleset.ComputeScrollTime(gameplayValue)));
+            }
+
+            ManiaRulesetConfigManager getConfigManager() => ((ManiaRulesetConfigManager)Game.Dependencies.Get<IRulesetConfigCache>().GetConfigFor(new ManiaRuleset())!);
+        }
+
         [Test]
         public void TestOffsetAdjustDuringGameplay()
         {
diff --git a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
index 822e5f26bd..5dc6f950a5 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
@@ -99,8 +99,35 @@ namespace osu.Game.Tests.Visual.Online
                                 Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6).ToArray(),
                                 Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6).ToArray(),
                             },
+                            TopTags =
+                            [
+                                new APIBeatmapTag { TagId = 4, VoteCount = 1 },
+                                new APIBeatmapTag { TagId = 2, VoteCount = 1 },
+                                new APIBeatmapTag { TagId = 23, VoteCount = 5 },
+                            ],
                         },
                     },
+                    RelatedTags =
+                    [
+                        new APITag
+                        {
+                            Id = 2,
+                            Name = "song representation/simple",
+                            Description = "Accessible and straightforward map design."
+                        },
+                        new APITag
+                        {
+                            Id = 4,
+                            Name = "style/clean",
+                            Description = "Visually uncluttered and organised patterns, often involving few overlaps and equal visual spacing between objects."
+                        },
+                        new APITag
+                        {
+                            Id = 23,
+                            Name = "aim/aim control",
+                            Description = "Patterns with velocity or direction changes which strongly go against a player's natural movement pattern."
+                        }
+                    ]
                 });
             });
 
diff --git a/osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs b/osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs
index ab9ee1d8cc..d0fc66252e 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs
@@ -215,6 +215,32 @@ namespace osu.Game.Tests.Visual.Online
             });
         }
 
+        [Test]
+        public void TestChannelCloseViaMiddleClick()
+        {
+            var testPMChannel = new Channel(testUser);
+
+            AddStep("Show overlay", () => chatOverlay.Show());
+            joinTestChannel(0);
+            joinChannel(testPMChannel);
+            AddStep("Select PM channel", () => clickDrawable(getChannelListItem(testPMChannel)));
+            AddStep("Middle click", () =>
+            {
+                var item = getChannelListItem(testPMChannel);
+                InputManager.MoveMouseTo(item);
+                InputManager.Click(MouseButton.Middle);
+            });
+            AddAssert("PM channel closed", () => !channelManager.JoinedChannels.Contains(testPMChannel));
+            AddStep("Select normal channel", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddStep("Click close button", () =>
+            {
+                var item = getChannelListItem(testChannel1);
+                InputManager.MoveMouseTo(item);
+                InputManager.Click(MouseButton.Middle);
+            });
+            AddAssert("Normal channel closed", () => !channelManager.JoinedChannels.Contains(testChannel1));
+        }
+
         [Test]
         public void TestChannelCloseButton()
         {
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs
index ceb3a32402..f2eeb5363a 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs
@@ -61,9 +61,9 @@ namespace osu.Game.Tests.Visual.Playlists
             AddUntilStep("last room is not masked", () => checkRoomVisible(roomListing.DrawableRooms[^1]));
         }
 
-        private bool checkRoomVisible(DrawableRoom room) =>
+        private bool checkRoomVisible(RoomPanel panel) =>
             loungeScreen.ChildrenOfType<OsuScrollContainer>().First().ScreenSpaceDrawQuad
-                        .Contains(room.ScreenSpaceDrawQuad.Centre);
+                        .Contains(panel.ScreenSpaceDrawQuad.Centre);
 
         private void createRooms(params Room[] rooms)
         {
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomCreation.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomCreation.cs
index a748d61d44..2e90f08d47 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomCreation.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomCreation.cs
@@ -176,6 +176,7 @@ namespace osu.Game.Tests.Visual.Playlists
                         RulesetID = new OsuRuleset().RulesetInfo.OnlineID
                     }
                 ];
+                room.EndDate = DateTimeOffset.Now.AddHours(1);
             });
 
             AddAssert("match has default beatmap", () => match.Beatmap.IsDefault);
@@ -212,6 +213,11 @@ namespace osu.Game.Tests.Visual.Playlists
 
             Debug.Assert(beatmap.BeatmapInfo.BeatmapSet != null);
             importedBeatmap = manager.Import(beatmap.BeatmapInfo.BeatmapSet)!.Value.Detach();
+            Realm.Write(r =>
+            {
+                foreach (var beatmapInfo in r.All<BeatmapInfo>())
+                    beatmapInfo.OnlineMD5Hash = beatmapInfo.MD5Hash;
+            });
         });
 
         private partial class TestPlaylistsRoomSubScreen : PlaylistsRoomSubScreen
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs
index e9c4b56e04..1841e2fd52 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs
@@ -65,7 +65,8 @@ namespace osu.Game.Tests.Visual.Playlists
                         OnlineID = 1,
                         DifficultyName = "Osu 1",
                         Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
-                        MD5Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
+                        MD5Hash = "11111111",
+                        OnlineMD5Hash = "11111111",
                         Ruleset = new OsuRuleset().RulesetInfo,
                         Metadata =
                         {
@@ -79,7 +80,8 @@ namespace osu.Game.Tests.Visual.Playlists
                         OnlineID = 2,
                         DifficultyName = "Osu 2",
                         Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
-                        MD5Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
+                        MD5Hash = "22222222",
+                        OnlineMD5Hash = "22222222",
                         Ruleset = new OsuRuleset().RulesetInfo,
                         Metadata =
                         {
@@ -93,7 +95,8 @@ namespace osu.Game.Tests.Visual.Playlists
                         OnlineID = 3,
                         DifficultyName = "Taiko 1",
                         Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
-                        MD5Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
+                        MD5Hash = "33333333",
+                        OnlineMD5Hash = "33333333",
                         Ruleset = new TaikoRuleset().RulesetInfo,
                         Metadata =
                         {
@@ -107,7 +110,8 @@ namespace osu.Game.Tests.Visual.Playlists
                         OnlineID = 4,
                         DifficultyName = "Taiko 2",
                         Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
-                        MD5Hash = Guid.NewGuid().ToString().ComputeMD5Hash(),
+                        MD5Hash = "44444444",
+                        OnlineMD5Hash = "44444444",
                         Ruleset = new TaikoRuleset().RulesetInfo,
                         Metadata =
                         {
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneHitEventTimingDistributionGraph.cs b/osu.Game.Tests/Visual/Ranking/TestSceneHitEventTimingDistributionGraph.cs
index 760210c370..bb4b785db0 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneHitEventTimingDistributionGraph.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneHitEventTimingDistributionGraph.cs
@@ -168,6 +168,19 @@ namespace osu.Game.Tests.Visual.Ranking
             };
         });
 
+        public static List<HitEvent> CreateHitEvents(double offset = 0, int count = 50)
+        {
+            var hitEvents = new List<HitEvent>();
+
+            for (int i = 0; i < count; i++)
+            {
+                for (int j = 0; j < count; j++)
+                    hitEvents.Add(new HitEvent(offset, 1.0, HitResult.Perfect, placeholder_object, placeholder_object, null));
+            }
+
+            return hitEvents;
+        }
+
         public static List<HitEvent> CreateDistributedHitEvents(double centre = 0, double range = 25)
         {
             var hitEvents = new List<HitEvent>();
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs b/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
index 814c0519a3..f92dc0313e 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneStatisticsPanel.cs
@@ -26,6 +26,7 @@ using osu.Game.Online;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania;
@@ -52,6 +53,9 @@ namespace osu.Game.Tests.Visual.Ranking
         private RulesetStore rulesetStore = null!;
         private BeatmapManager beatmapManager = null!;
 
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
             var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
@@ -214,14 +218,10 @@ namespace osu.Game.Tests.Visual.Ranking
                             {
                                 Tags =
                                 [
-                                    new APITag { Id = 1, Name = "tech", Description = "Tests uncommon skills.", },
-                                    new APITag
-                                    {
-                                        Id = 2, Name = "alt",
-                                        Description = "Colloquial term for maps which use rhythms that encourage the player to alternate notes. Typically distinct from burst or stream maps.",
-                                    },
-                                    new APITag { Id = 3, Name = "aim", Description = "Category for difficulty relating to cursor movement.", },
-                                    new APITag { Id = 4, Name = "tap", Description = "Category for difficulty relating to tapping input.", },
+                                    new APITag { Id = 1, Name = "song representation/simple", Description = "Accessible and straightforward map design.", },
+                                    new APITag { Id = 2, Name = "style/clean", Description = "Visually uncluttered and organised patterns, often involving few overlaps and equal visual spacing between objects.", },
+                                    new APITag { Id = 3, Name = "aim/aim control", Description = "Patterns with velocity or direction changes which strongly go against a player's natural movement pattern.", },
+                                    new APITag { Id = 4, Name = "tap/bursts", Description = "Patterns requiring continuous movement and alternating, typically 9 notes or less.", },
                                 ]
                             }), 500);
                             return true;
@@ -368,12 +368,16 @@ namespace osu.Game.Tests.Visual.Ranking
 
         private void loadPanel(ScoreInfo score) => AddStep("load panel", () =>
         {
-            Child = new StatisticsPanel
+            Child = new PopoverContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                State = { Value = Visibility.Visible },
-                Score = { Value = score },
-                AchievedScore = score,
+                Child = new StatisticsPanel
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    State = { Value = Visibility.Visible },
+                    Score = { Value = score },
+                    AchievedScore = score,
+                },
             };
         });
 
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs b/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
index d622df8d76..c546c9727c 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Testing;
@@ -9,21 +10,23 @@ using osu.Game.Beatmaps;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Taiko;
 using osu.Game.Screens.Ranking;
 
 namespace osu.Game.Tests.Visual.Ranking
 {
     public partial class TestSceneUserTagControl : OsuTestScene
     {
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
         private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
 
         [SetUpSteps]
         public void SetUpSteps()
         {
-            AddStep("set up working beatmap", () =>
-            {
-                Beatmap.Value.BeatmapInfo.OnlineID = 42;
-            });
             AddStep("set up network requests", () =>
             {
                 dummyAPI.HandleRequest = request =>
@@ -36,10 +39,19 @@ namespace osu.Game.Tests.Visual.Ranking
                             {
                                 Tags =
                                 [
-                                    new APITag { Id = 1, Name = "tech", Description = "Tests uncommon skills.", },
-                                    new APITag { Id = 2, Name = "alt", Description = "Colloquial term for maps which use rhythms that encourage the player to alternate notes. Typically distinct from burst or stream maps.", },
-                                    new APITag { Id = 3, Name = "aim", Description = "Category for difficulty relating to cursor movement.", },
-                                    new APITag { Id = 4, Name = "tap", Description = "Category for difficulty relating to tapping input.", },
+                                    new APITag { Id = 0, Name = "uncategorised tag", Description = "This probably isn't real but could be and should be handled.", },
+                                    new APITag { Id = 1, Name = "song representation/simple", Description = "Accessible and straightforward map design.", },
+                                    new APITag
+                                    {
+                                        Id = 2, Name = "style/clean",
+                                        Description = "Visually uncluttered and organised patterns, often involving few overlaps and equal visual spacing between objects.",
+                                    },
+                                    new APITag
+                                    {
+                                        Id = 3, Name = "aim/aim control", Description = "Patterns with velocity or direction changes which strongly go against a player's natural movement pattern.",
+                                    },
+                                    new APITag { Id = 4, Name = "tap/bursts", Description = "Patterns requiring continuous movement and alternating, typically 9 notes or less.", },
+                                    new APITag { Id = 5, Name = "style/mono-heavy", Description = "Features monos used in large amounts.", RulesetId = 1, },
                                 ]
                             }), 500);
                             return true;
@@ -67,19 +79,34 @@ namespace osu.Game.Tests.Visual.Ranking
                     return false;
                 };
             });
-            AddStep("create control", () =>
+            AddStep("show for osu! beatmap", () =>
             {
-                Child = new PopoverContainer
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Child = new UserTagControl(Beatmap.Value.BeatmapInfo)
-                    {
-                        Width = 500,
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                    }
-                };
+                var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                working.BeatmapInfo.OnlineID = 42;
+                Beatmap.Value = working;
+                recreateControl();
             });
+            AddStep("show for taiko beatmap", () =>
+            {
+                var working = CreateWorkingBeatmap(new TaikoRuleset().RulesetInfo);
+                working.BeatmapInfo.OnlineID = 44;
+                Beatmap.Value = working;
+                recreateControl();
+            });
+        }
+
+        private void recreateControl()
+        {
+            Child = new PopoverContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = new UserTagControl(Beatmap.Value.BeatmapInfo)
+                {
+                    Width = 700,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                }
+            };
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Settings/TestSceneAudioOffsetAdjustControl.cs b/osu.Game.Tests/Visual/Settings/TestSceneAudioOffsetAdjustControl.cs
index 85cde966b1..2fc5378ba1 100644
--- a/osu.Game.Tests/Visual/Settings/TestSceneAudioOffsetAdjustControl.cs
+++ b/osu.Game.Tests/Visual/Settings/TestSceneAudioOffsetAdjustControl.cs
@@ -1,11 +1,14 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Overlays.Settings.Sections.Audio;
@@ -70,16 +73,54 @@ namespace osu.Game.Tests.Visual.Settings
             AddStep("clear history", () => tracker.ClearHistory());
         }
 
+        [Test]
+        public void TestRounding()
+        {
+            AddStep("set new score", () => statics.SetValue(Static.LastLocalUserScore, new ScoreInfo
+            {
+                HitEvents = TestSceneHitEventTimingDistributionGraph.CreateHitEvents(0.6),
+                BeatmapInfo = Beatmap.Value.BeatmapInfo,
+            }));
+
+            checkButtonEnabled();
+            AddStep("click button", () => adjustControl.ChildrenOfType<Button>().Single().TriggerClick());
+            checkButtonDisabled();
+            AddAssert("global offset set correctly", () => localConfig.Get<double>(OsuSetting.AudioOffset), () => Is.EqualTo(-1));
+        }
+
+        [Test]
+        public void TestNegligibleChangeNotApplicable()
+        {
+            AddStep("set new score", () => statics.SetValue(Static.LastLocalUserScore, new ScoreInfo
+            {
+                HitEvents = TestSceneHitEventTimingDistributionGraph.CreateHitEvents(0.5),
+                BeatmapInfo = Beatmap.Value.BeatmapInfo,
+            }));
+            checkButtonDisabled();
+
+            AddStep("adjust global offset", () => localConfig.SetValue(OsuSetting.AudioOffset, 50.0));
+            checkButtonEnabled();
+
+            AddStep("click button", () => adjustControl.ChildrenOfType<Button>().Single().TriggerClick());
+            checkButtonDisabled();
+            AddAssert("global offset set correctly", () => localConfig.Get<double>(OsuSetting.AudioOffset), () => Is.EqualTo(0));
+            AddStep("clear history", () => tracker.ClearHistory());
+        }
+
         [Test]
         public void TestBehaviour()
         {
             AddStep("set score with -20ms", () => setScore(-20));
             AddAssert("suggested global offset is 20ms", () => adjustControl.SuggestedOffset.Value, () => Is.EqualTo(20));
+            checkButtonEnabled();
             AddStep("clear history", () => tracker.ClearHistory());
+            checkButtonDisabled();
 
             AddStep("set score with 40ms", () => setScore(40));
+            checkButtonEnabled();
             AddAssert("suggested global offset is -40ms", () => adjustControl.SuggestedOffset.Value, () => Is.EqualTo(-40));
             AddStep("clear history", () => tracker.ClearHistory());
+            checkButtonDisabled();
         }
 
         [Test]
@@ -111,6 +152,16 @@ namespace osu.Game.Tests.Visual.Settings
             AddStep("clear history", () => tracker.ClearHistory());
         }
 
+        private void checkButtonDisabled()
+        {
+            AddAssert("button is disabled", () => adjustControl.ChildrenOfType<Button>().Single().Enabled.Value, () => Is.False);
+        }
+
+        private void checkButtonEnabled()
+        {
+            AddAssert("button is enabled", () => adjustControl.ChildrenOfType<Button>().Single().Enabled.Value, () => Is.True);
+        }
+
         private void setScore(double averageHitError)
         {
             statics.SetValue(Static.LastLocalUserScore, new ScoreInfo
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs
index d8573b2d03..8132f8a841 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapInfoWedge.cs
@@ -69,7 +69,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             foreach (var rulesetInfo in rulesets.AvailableRulesets)
             {
                 var instance = rulesetInfo.CreateInstance();
-                var testBeatmap = createTestBeatmap(rulesetInfo);
+                var testBeatmap = CreateTestBeatmap(rulesetInfo);
 
                 beatmaps.Add(testBeatmap);
 
@@ -124,6 +124,12 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("reset mods", () => SelectedMods.SetDefault());
         }
 
+        [Test]
+        public void TestTruncation()
+        {
+            selectBeatmap(CreateLongMetadata());
+        }
+
         [Test]
         public void TestNullBeatmap()
         {
@@ -135,17 +141,11 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("check no info labels", () => !infoWedge.Info.ChildrenOfType<BeatmapInfoWedge.WedgeInfoText.InfoLabel>().Any());
         }
 
-        [Test]
-        public void TestTruncation()
-        {
-            selectBeatmap(createLongMetadata());
-        }
-
         [Test]
         public void TestBPMUpdates()
         {
             const double bpm = 120;
-            IBeatmap beatmap = createTestBeatmap(new OsuRuleset().RulesetInfo);
+            IBeatmap beatmap = CreateTestBeatmap(new OsuRuleset().RulesetInfo);
             beatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = 60 * 1000 / bpm });
 
             OsuModDoubleTime doubleTime = null!;
@@ -167,7 +167,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         [TestCase(120, 120.4, "DT", "180")]
         public void TestVaryingBPM(double commonBpm, double otherBpm, string? mod, string expectedDisplay)
         {
-            IBeatmap beatmap = createTestBeatmap(new OsuRuleset().RulesetInfo);
+            IBeatmap beatmap = CreateTestBeatmap(new OsuRuleset().RulesetInfo);
             beatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = 60 * 1000 / commonBpm });
             beatmap.ControlPointInfo.Add(100, new TimingControlPoint { BeatLength = 60 * 1000 / otherBpm });
             beatmap.ControlPointInfo.Add(200, new TimingControlPoint { BeatLength = 60 * 1000 / commonBpm });
@@ -191,7 +191,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         [TestCase]
         public void TestLengthUpdates()
         {
-            IBeatmap beatmap = createTestBeatmap(new OsuRuleset().RulesetInfo);
+            IBeatmap beatmap = CreateTestBeatmap(new OsuRuleset().RulesetInfo);
             double drain = beatmap.CalculateDrainLength();
             beatmap.BeatmapInfo.Length = drain;
 
@@ -248,7 +248,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddUntilStep("wait for async load", () => infoWedge.DisplayedContent != containerBefore);
         }
 
-        private IBeatmap createTestBeatmap(RulesetInfo ruleset)
+        public static IBeatmap CreateTestBeatmap(RulesetInfo ruleset)
         {
             List<HitObject> objects = new List<HitObject>();
             for (double i = 0; i < 50000; i += 1000)
@@ -274,7 +274,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             };
         }
 
-        private IBeatmap createLongMetadata()
+        public static IBeatmap CreateLongMetadata()
         {
             return new Beatmap
             {
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs
index 474d2ee6e3..44f64365f0 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs
@@ -43,6 +43,8 @@ namespace osu.Game.Tests.Visual.SongSelect
         private BeatmapManager beatmapManager = null!;
         private PlaySongSelect songSelect = null!;
 
+        private LeaderboardManager leaderboardManager = null!;
+
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
             var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
@@ -51,6 +53,8 @@ namespace osu.Game.Tests.Visual.SongSelect
             dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, Realm, null, dependencies.Get<AudioManager>(), Resources, dependencies.Get<GameHost>(), Beatmap.Default));
             dependencies.Cache(scoreManager = new ScoreManager(rulesetStore, () => beatmapManager, LocalStorage, Realm, API));
             dependencies.CacheAs<Screens.Select.SongSelect>(songSelect = new PlaySongSelect());
+            dependencies.Cache(leaderboardManager = new LeaderboardManager());
+
             Dependencies.Cache(Realm);
 
             return dependencies;
@@ -60,6 +64,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         private void load()
         {
             LoadComponent(songSelect);
+            LoadComponent(leaderboardManager);
         }
 
         public TestSceneBeatmapLeaderboard()
@@ -112,6 +117,27 @@ namespace osu.Game.Tests.Visual.SongSelect
             checkDisplayedCount(0);
         }
 
+        [Test]
+        public void TestLocalScoresDisplayWorksWhenStartingOffline()
+        {
+            BeatmapInfo beatmapInfo = null!;
+
+            AddStep("Log out", () => API.Logout());
+            AddStep(@"Set scope", () => leaderboard.Scope = BeatmapLeaderboardScope.Local);
+
+            AddStep(@"Set beatmap", () =>
+            {
+                beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+                beatmapInfo = beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps.First();
+
+                leaderboard.BeatmapInfo = beatmapInfo;
+            });
+
+            clearScores();
+            importMoreScores(() => beatmapInfo);
+            checkDisplayedCount(10);
+        }
+
         [Test]
         public void TestLocalScoresDisplayOnBeatmapEdit()
         {
@@ -180,8 +206,8 @@ namespace osu.Game.Tests.Visual.SongSelect
         public void TestGlobalScoresDisplay()
         {
             AddStep(@"Set scope", () => leaderboard.Scope = BeatmapLeaderboardScope.Global);
-            AddStep(@"New Scores", () => leaderboard.SetScores(generateSampleScores(new BeatmapInfo())));
-            AddStep(@"New Scores with teams", () => leaderboard.SetScores(generateSampleScores(new BeatmapInfo()).Select(s =>
+            AddStep(@"New Scores", () => leaderboard.SetScores(GenerateSampleScores(new BeatmapInfo())));
+            AddStep(@"New Scores with teams", () => leaderboard.SetScores(GenerateSampleScores(new BeatmapInfo()).Select(s =>
             {
                 s.User.Team = new APITeam();
                 return s;
@@ -286,7 +312,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             AddStep(@"Import new scores", () =>
             {
-                foreach (var score in generateSampleScores(beatmapInfo()))
+                foreach (var score in GenerateSampleScores(beatmapInfo()))
                     scoreManager.Import(score);
             });
         }
@@ -302,7 +328,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         private void checkStoredCount(int expected) =>
             AddUntilStep($"Total scores stored is {expected}", () => Realm.Run(r => r.All<ScoreInfo>().Count(s => !s.DeletePending)), () => Is.EqualTo(expected));
 
-        private static ScoreInfo[] generateSampleScores(BeatmapInfo beatmapInfo)
+        public static ScoreInfo[] GenerateSampleScores(BeatmapInfo beatmapInfo)
         {
             return new[]
             {
@@ -316,7 +342,6 @@ namespace osu.Game.Tests.Visual.SongSelect
                     Mods = new Mod[]
                     {
                         new OsuModHidden(),
-                        new OsuModHardRock(),
                         new OsuModFlashlight
                         {
                             FollowDelay = { Value = 200 },
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs
new file mode 100644
index 0000000000..fe2bf6ff5d
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs
@@ -0,0 +1,271 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+using osu.Game.Rulesets;
+using osu.Game.Tests.Resources;
+using osuTK.Input;
+using Realms;
+
+namespace osu.Game.Tests.Visual.SongSelect
+{
+    public partial class TestSceneCollectionDropdown : OsuManualInputManagerTestScene
+    {
+        private BeatmapManager beatmapManager = null!;
+        private CollectionDropdown dropdown = null!;
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host)
+        {
+            Dependencies.Cache(new RealmRulesetStore(Realm));
+            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, Realm, null, Audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(Realm);
+
+            beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+        }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            writeAndRefresh(r => r.RemoveAll<BeatmapCollection>());
+
+            Child = new Container
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Child = dropdown = new CollectionDropdown
+                {
+                    Width = 300,
+                    Y = 100,
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                },
+            };
+        });
+
+        [Test]
+        public void TestEmptyCollectionFilterContainsAllBeatmaps()
+        {
+            assertCollectionDropdownContains("All beatmaps");
+            assertCollectionHeaderDisplays("All beatmaps");
+        }
+
+        [Test]
+        public void TestCollectionAddedToDropdown()
+        {
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
+            assertCollectionDropdownContains("1");
+            assertCollectionDropdownContains("2");
+        }
+
+        [Test]
+        public void TestCollectionsCleared()
+        {
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "3"))));
+
+            AddAssert("check count 5", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(5));
+
+            AddStep("delete all collections", () => writeAndRefresh(r => r.RemoveAll<BeatmapCollection>()));
+
+            AddAssert("check count 2", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestCollectionRemovedFromDropdown()
+        {
+            BeatmapCollection first = null!;
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(first = new BeatmapCollection(name: "1"))));
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
+            AddStep("remove collection", () => writeAndRefresh(r => r.Remove(first)));
+
+            assertCollectionDropdownContains("1", false);
+            assertCollectionDropdownContains("2");
+        }
+
+        [Test]
+        public void TestCollectionRenamed()
+        {
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+            AddStep("select collection", () => dropdown.Current.Value = dropdown.ItemSource.ElementAt(1));
+
+            addExpandHeaderStep();
+
+            AddStep("change name", () => writeAndRefresh(_ => getFirstCollection().Name = "First"));
+
+            assertCollectionDropdownContains("First");
+            assertCollectionHeaderDisplays("First");
+        }
+
+        [Test]
+        public void TestAllBeatmapFilterDoesNotHaveAddButton()
+        {
+            addExpandHeaderStep();
+            AddStep("hover all beatmaps", () => InputManager.MoveMouseTo(getAddOrRemoveButton(0)));
+            AddAssert("'All beatmaps' filter does not have add button", () => !getAddOrRemoveButton(0).IsPresent);
+        }
+
+        [Test]
+        public void TestCollectionFilterHasAddButton()
+        {
+            addExpandHeaderStep();
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+            AddStep("hover collection", () => InputManager.MoveMouseTo(getAddOrRemoveButton(1)));
+            AddAssert("collection has add button", () => getAddOrRemoveButton(1).IsPresent);
+        }
+
+        [Test]
+        public void TestButtonDisabledAndEnabledWithBeatmapChanges()
+        {
+            addExpandHeaderStep();
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+
+            AddStep("select available beatmap", () => Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0]));
+            AddAssert("button enabled", () => getAddOrRemoveButton(1).Enabled.Value);
+
+            AddStep("set dummy beatmap", () => Beatmap.SetDefault());
+            AddAssert("button disabled", () => !getAddOrRemoveButton(1).Enabled.Value);
+        }
+
+        [Test]
+        public void TestButtonChangesWhenAddedAndRemovedFromCollection()
+        {
+            addExpandHeaderStep();
+
+            AddStep("select available beatmap", () => Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0]));
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+
+            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
+
+            AddStep("add beatmap to collection", () => writeAndRefresh(r => getFirstCollection().BeatmapMD5Hashes.Add(Beatmap.Value.BeatmapInfo.MD5Hash)));
+            assertFirstButtonIs(FontAwesome.Solid.MinusSquare);
+
+            AddStep("remove beatmap from collection", () => writeAndRefresh(r => getFirstCollection().BeatmapMD5Hashes.Clear()));
+            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
+        }
+
+        [Test]
+        public void TestButtonAddsAndRemovesBeatmap()
+        {
+            addExpandHeaderStep();
+
+            AddStep("select available beatmap", () => Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0]));
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
+
+            addClickAddOrRemoveButtonStep(1);
+            AddAssert("collection contains beatmap", () => getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            assertFirstButtonIs(FontAwesome.Solid.MinusSquare);
+
+            addClickAddOrRemoveButtonStep(1);
+            AddAssert("collection does not contain beatmap", () => !getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
+        }
+
+        [Test]
+        public void TestManageCollectionsFilterIsNotSelected()
+        {
+            bool received = false;
+
+            addExpandHeaderStep();
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1", new List<string> { "abc" }))));
+            assertCollectionDropdownContains("1");
+
+            AddStep("select collection", () =>
+            {
+                InputManager.MoveMouseTo(getCollectionDropdownItemAt(1));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            addExpandHeaderStep();
+
+            AddStep("watch for filter requests", () =>
+            {
+                received = false;
+                dropdown.ChildrenOfType<CollectionDropdown>().First().RequestFilter = () => received = true;
+            });
+
+            AddStep("click manage collections filter", () =>
+            {
+                int lastItemIndex = dropdown.ChildrenOfType<CollectionDropdown>().Single().Items.Count() - 1;
+                InputManager.MoveMouseTo(getCollectionDropdownItemAt(lastItemIndex));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("collection filter still selected", () => dropdown.Current.Value.CollectionName == "1");
+
+            AddAssert("filter request not fired", () => !received);
+        }
+
+        private void writeAndRefresh(Action<Realm> action) => Realm.Write(r =>
+        {
+            action(r);
+            r.Refresh();
+        });
+
+        private BeatmapCollection getFirstCollection() => Realm.Run(r => r.All<BeatmapCollection>().First());
+
+        private void assertCollectionHeaderDisplays(string collectionName, bool shouldDisplay = true)
+            => AddUntilStep($"collection dropdown header displays '{collectionName}'",
+                () => shouldDisplay == dropdown.ChildrenOfType<CollectionDropdown.OsuDropdownHeader>().Any(h => h.ChildrenOfType<SpriteText>().Any(t => t.Text == collectionName)));
+
+        private void assertFirstButtonIs(IconUsage icon) => AddUntilStep($"button is {icon.Icon.ToString()}", () => getAddOrRemoveButton(1).Icon.Equals(icon));
+
+        private void assertCollectionDropdownContains(string collectionName, bool shouldContain = true) =>
+            AddUntilStep($"collection dropdown {(shouldContain ? "contains" : "does not contain")} '{collectionName}'",
+                // A bit of a roundabout way of going about this, see: https://github.com/ppy/osu-framework/issues/3871 + https://github.com/ppy/osu-framework/issues/3872
+                () => shouldContain == dropdown.ChildrenOfType<Menu.DrawableMenuItem>().Any(i => i.ChildrenOfType<CompositeDrawable>().OfType<IHasText>().First().Text == collectionName));
+
+        private IconButton getAddOrRemoveButton(int index)
+            => getCollectionDropdownItemAt(index).ChildrenOfType<IconButton>().Single();
+
+        private void addExpandHeaderStep() => AddStep("expand header", () =>
+        {
+            InputManager.MoveMouseTo(dropdown.ChildrenOfType<CollectionDropdown.OsuDropdownHeader>().Single());
+            InputManager.Click(MouseButton.Left);
+        });
+
+        private void addClickAddOrRemoveButtonStep(int index) => AddStep("click add or remove button", () =>
+        {
+            InputManager.MoveMouseTo(getAddOrRemoveButton(index));
+            InputManager.Click(MouseButton.Left);
+        });
+
+        private Menu.DrawableMenuItem getCollectionDropdownItemAt(int index)
+        {
+            // todo: we should be able to use Items, but apparently that's not guaranteed to be ordered... see: https://github.com/ppy/osu-framework/pull/6079
+            CollectionFilterMenuItem item = dropdown.ChildrenOfType<CollectionDropdown>().Single().ItemSource.ElementAt(index);
+            return dropdown.ChildrenOfType<Menu.DrawableMenuItem>().Single(i => i.Item.Text.Value == item.CollectionName);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneFilterControl.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneFilterControl.cs
index a639d50eee..41e44357d7 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneFilterControl.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneFilterControl.cs
@@ -1,57 +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 System;
-using System.Collections.Generic;
-using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Extensions;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Platform;
-using osu.Framework.Testing;
-using osu.Game.Beatmaps;
-using osu.Game.Collections;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Rulesets;
 using osu.Game.Screens.Select;
-using osu.Game.Tests.Resources;
-using osuTK.Input;
-using Realms;
 
 namespace osu.Game.Tests.Visual.SongSelect
 {
     public partial class TestSceneFilterControl : OsuManualInputManagerTestScene
     {
-        protected override Container<Drawable> Content { get; } = new Container { RelativeSizeAxes = Axes.Both };
-
-        private BeatmapManager beatmapManager = null!;
-        private FilterControl control = null!;
-
-        [BackgroundDependencyLoader]
-        private void load(GameHost host)
-        {
-            Dependencies.Cache(new RealmRulesetStore(Realm));
-            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, Realm, null, Audio, Resources, host, Beatmap.Default));
-            Dependencies.Cache(Realm);
-
-            beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
-
-            base.Content.AddRange(new Drawable[]
-            {
-                Content
-            });
-        }
-
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
-            writeAndRefresh(r => r.RemoveAll<BeatmapCollection>());
-
-            Child = control = new FilterControl
+            Child = new FilterControl
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -59,216 +20,5 @@ namespace osu.Game.Tests.Visual.SongSelect
                 Height = FilterControl.HEIGHT,
             };
         });
-
-        [Test]
-        public void TestEmptyCollectionFilterContainsAllBeatmaps()
-        {
-            assertCollectionDropdownContains("All beatmaps");
-            assertCollectionHeaderDisplays("All beatmaps");
-        }
-
-        [Test]
-        public void TestCollectionAddedToDropdown()
-        {
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
-            assertCollectionDropdownContains("1");
-            assertCollectionDropdownContains("2");
-        }
-
-        [Test]
-        public void TestCollectionsCleared()
-        {
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "3"))));
-
-            AddAssert("check count 5", () => control.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(5));
-
-            AddStep("delete all collections", () => writeAndRefresh(r => r.RemoveAll<BeatmapCollection>()));
-
-            AddAssert("check count 2", () => control.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(2));
-        }
-
-        [Test]
-        public void TestCollectionRemovedFromDropdown()
-        {
-            BeatmapCollection first = null!;
-
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(first = new BeatmapCollection(name: "1"))));
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
-            AddStep("remove collection", () => writeAndRefresh(r => r.Remove(first)));
-
-            assertCollectionDropdownContains("1", false);
-            assertCollectionDropdownContains("2");
-        }
-
-        [Test]
-        public void TestCollectionRenamed()
-        {
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
-            assertCollectionDropdownContains("1");
-            AddStep("select collection", () =>
-            {
-                var dropdown = control.ChildrenOfType<CollectionDropdown>().Single();
-                dropdown.Current.Value = dropdown.ItemSource.ElementAt(1);
-            });
-
-            addExpandHeaderStep();
-
-            AddStep("change name", () => writeAndRefresh(_ => getFirstCollection().Name = "First"));
-
-            assertCollectionDropdownContains("First");
-            assertCollectionHeaderDisplays("First");
-        }
-
-        [Test]
-        public void TestAllBeatmapFilterDoesNotHaveAddButton()
-        {
-            addExpandHeaderStep();
-            AddStep("hover all beatmaps", () => InputManager.MoveMouseTo(getAddOrRemoveButton(0)));
-            AddAssert("'All beatmaps' filter does not have add button", () => !getAddOrRemoveButton(0).IsPresent);
-        }
-
-        [Test]
-        public void TestCollectionFilterHasAddButton()
-        {
-            addExpandHeaderStep();
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
-            assertCollectionDropdownContains("1");
-            AddStep("hover collection", () => InputManager.MoveMouseTo(getAddOrRemoveButton(1)));
-            AddAssert("collection has add button", () => getAddOrRemoveButton(1).IsPresent);
-        }
-
-        [Test]
-        public void TestButtonDisabledAndEnabledWithBeatmapChanges()
-        {
-            addExpandHeaderStep();
-
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
-            assertCollectionDropdownContains("1");
-
-            AddStep("select available beatmap", () => Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0]));
-            AddAssert("button enabled", () => getAddOrRemoveButton(1).Enabled.Value);
-
-            AddStep("set dummy beatmap", () => Beatmap.SetDefault());
-            AddAssert("button disabled", () => !getAddOrRemoveButton(1).Enabled.Value);
-        }
-
-        [Test]
-        public void TestButtonChangesWhenAddedAndRemovedFromCollection()
-        {
-            addExpandHeaderStep();
-
-            AddStep("select available beatmap", () => Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0]));
-
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
-            assertCollectionDropdownContains("1");
-
-            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
-
-            AddStep("add beatmap to collection", () => writeAndRefresh(r => getFirstCollection().BeatmapMD5Hashes.Add(Beatmap.Value.BeatmapInfo.MD5Hash)));
-            assertFirstButtonIs(FontAwesome.Solid.MinusSquare);
-
-            AddStep("remove beatmap from collection", () => writeAndRefresh(r => getFirstCollection().BeatmapMD5Hashes.Clear()));
-            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
-        }
-
-        [Test]
-        public void TestButtonAddsAndRemovesBeatmap()
-        {
-            addExpandHeaderStep();
-
-            AddStep("select available beatmap", () => Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0]));
-
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
-            assertCollectionDropdownContains("1");
-            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
-
-            addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection contains beatmap", () => getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
-            assertFirstButtonIs(FontAwesome.Solid.MinusSquare);
-
-            addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection does not contain beatmap", () => !getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
-            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
-        }
-
-        [Test]
-        public void TestManageCollectionsFilterIsNotSelected()
-        {
-            bool received = false;
-
-            addExpandHeaderStep();
-
-            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1", new List<string> { "abc" }))));
-            assertCollectionDropdownContains("1");
-
-            AddStep("select collection", () =>
-            {
-                InputManager.MoveMouseTo(getCollectionDropdownItemAt(1));
-                InputManager.Click(MouseButton.Left);
-            });
-
-            addExpandHeaderStep();
-
-            AddStep("watch for filter requests", () =>
-            {
-                received = false;
-                control.ChildrenOfType<CollectionDropdown>().First().RequestFilter = () => received = true;
-            });
-
-            AddStep("click manage collections filter", () =>
-            {
-                int lastItemIndex = control.ChildrenOfType<CollectionDropdown>().Single().Items.Count() - 1;
-                InputManager.MoveMouseTo(getCollectionDropdownItemAt(lastItemIndex));
-                InputManager.Click(MouseButton.Left);
-            });
-
-            AddAssert("collection filter still selected", () => control.CreateCriteria().CollectionBeatmapMD5Hashes?.Any() == true);
-
-            AddAssert("filter request not fired", () => !received);
-        }
-
-        private void writeAndRefresh(Action<Realm> action) => Realm.Write(r =>
-        {
-            action(r);
-            r.Refresh();
-        });
-
-        private BeatmapCollection getFirstCollection() => Realm.Run(r => r.All<BeatmapCollection>().First());
-
-        private void assertCollectionHeaderDisplays(string collectionName, bool shouldDisplay = true)
-            => AddUntilStep($"collection dropdown header displays '{collectionName}'",
-                () => shouldDisplay == (control.ChildrenOfType<CollectionDropdown.CollectionDropdownHeader>().Single().ChildrenOfType<SpriteText>().First().Text == collectionName));
-
-        private void assertFirstButtonIs(IconUsage icon) => AddUntilStep($"button is {icon.Icon.ToString()}", () => getAddOrRemoveButton(1).Icon.Equals(icon));
-
-        private void assertCollectionDropdownContains(string collectionName, bool shouldContain = true) =>
-            AddUntilStep($"collection dropdown {(shouldContain ? "contains" : "does not contain")} '{collectionName}'",
-                // A bit of a roundabout way of going about this, see: https://github.com/ppy/osu-framework/issues/3871 + https://github.com/ppy/osu-framework/issues/3872
-                () => shouldContain == control.ChildrenOfType<Menu.DrawableMenuItem>().Any(i => i.ChildrenOfType<CompositeDrawable>().OfType<IHasText>().First().Text == collectionName));
-
-        private IconButton getAddOrRemoveButton(int index)
-            => getCollectionDropdownItemAt(index).ChildrenOfType<IconButton>().Single();
-
-        private void addExpandHeaderStep() => AddStep("expand header", () =>
-        {
-            InputManager.MoveMouseTo(control.ChildrenOfType<CollectionDropdown.CollectionDropdownHeader>().Single());
-            InputManager.Click(MouseButton.Left);
-        });
-
-        private void addClickAddOrRemoveButtonStep(int index) => AddStep("click add or remove button", () =>
-        {
-            InputManager.MoveMouseTo(getAddOrRemoveButton(index));
-            InputManager.Click(MouseButton.Left);
-        });
-
-        private Menu.DrawableMenuItem getCollectionDropdownItemAt(int index)
-        {
-            // todo: we should be able to use Items, but apparently that's not guaranteed to be ordered... see: https://github.com/ppy/osu-framework/pull/6079
-            CollectionFilterMenuItem item = control.ChildrenOfType<CollectionDropdown>().Single().ItemSource.ElementAt(index);
-            return control.ChildrenOfType<Menu.DrawableMenuItem>().Single(i => i.Item.Text.Value == item.CollectionName);
-        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Collections/TestSceneManageCollectionsDialog.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneManageCollectionsDialog.cs
similarity index 99%
rename from osu.Game.Tests/Visual/Collections/TestSceneManageCollectionsDialog.cs
rename to osu.Game.Tests/Visual/SongSelect/TestSceneManageCollectionsDialog.cs
index 60675018e9..4c895faf27 100644
--- a/osu.Game.Tests/Visual/Collections/TestSceneManageCollectionsDialog.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneManageCollectionsDialog.cs
@@ -20,7 +20,7 @@ using osu.Game.Tests.Resources;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Tests.Visual.Collections
+namespace osu.Game.Tests.Visual.SongSelect
 {
     public partial class TestSceneManageCollectionsDialog : OsuManualInputManagerTestScene
     {
diff --git a/osu.Game.Tests/Visual/SongSelect/BeatmapCarouselV2TestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
similarity index 97%
rename from osu.Game.Tests/Visual/SongSelect/BeatmapCarouselV2TestScene.cs
rename to osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
index 2c902a466f..28a0948696 100644
--- a/osu.Game.Tests/Visual/SongSelect/BeatmapCarouselV2TestScene.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
@@ -16,6 +16,7 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Containers;
 using osu.Game.Overlays;
 using osu.Game.Screens.Select;
@@ -27,9 +28,9 @@ using osuTK.Graphics;
 using osuTK.Input;
 using BeatmapCarousel = osu.Game.Screens.SelectV2.BeatmapCarousel;
 
-namespace osu.Game.Tests.Visual.SongSelect
+namespace osu.Game.Tests.Visual.SongSelectV2
 {
-    public abstract partial class BeatmapCarouselV2TestScene : OsuManualInputManagerTestScene
+    public abstract partial class BeatmapCarouselTestScene : OsuManualInputManagerTestScene
     {
         protected readonly BindableList<BeatmapSetInfo> BeatmapSets = new BindableList<BeatmapSetInfo>();
 
@@ -47,7 +48,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
         private int beatmapCount;
 
-        protected BeatmapCarouselV2TestScene()
+        protected BeatmapCarouselTestScene()
         {
             store = new TestBeatmapStore
             {
@@ -96,6 +97,8 @@ namespace osu.Game.Tests.Visual.SongSelect
                             {
                                 Carousel = new BeatmapCarousel
                                 {
+                                    BleedTop = 50,
+                                    BleedBottom = 50,
                                     Anchor = Anchor.Centre,
                                     Origin = Anchor.Centre,
                                     Width = 800,
@@ -189,7 +192,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                         .Where(p => ((ICarouselPanel)p).Item?.IsVisible == true)
                         .OrderBy(p => p.Y)
                         .ElementAt(index)
-                        .ChildrenOfType<PanelBase>().Single()
+                        .ChildrenOfType<Panel>().Single()
                         .TriggerClick();
             });
         }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/SongSelectComponentsTestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/SongSelectComponentsTestScene.cs
index 8694722acc..f86ca869e1 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/SongSelectComponentsTestScene.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/SongSelectComponentsTestScene.cs
@@ -4,7 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Testing;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Overlays;
@@ -20,33 +20,32 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             RelativeSizeAxes = Axes.X,
             AutoSizeAxes = Axes.Y,
-            Padding = new MarginPadding(10),
         };
 
         private Container? resizeContainer;
         private float relativeWidth;
 
+        protected virtual Anchor ComponentAnchor => Anchor.TopLeft;
+        protected virtual float InitialRelativeWidth => 0.5f;
+
         [BackgroundDependencyLoader]
         private void load()
         {
-            base.Content.Child = resizeContainer = new Container
+            base.Content.Child = new PopoverContainer
             {
-                RelativeSizeAxes = Axes.X,
-                AutoSizeAxes = Axes.Y,
-                Padding = new MarginPadding(10),
-                Width = relativeWidth,
-                Children = new Drawable[]
+                RelativeSizeAxes = Axes.Both,
+                Child = resizeContainer = new Container
                 {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = ColourProvider.Background5,
-                    },
-                    Content
+                    Anchor = ComponentAnchor,
+                    Origin = ComponentAnchor,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Width = relativeWidth,
+                    Child = Content
                 }
             };
 
-            AddSliderStep("change relative width", 0, 1f, 1f, v =>
+            AddSliderStep("change relative width", 0, 1f, InitialRelativeWidth, v =>
             {
                 if (resizeContainer != null)
                     resizeContainer.Width = v;
@@ -55,6 +54,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             });
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            ChangeBackgroundColour(ColourProvider.Background6);
+        }
+
         [SetUpSteps]
         public virtual void SetUpSteps()
         {
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarousel.cs
similarity index 95%
rename from osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarousel.cs
index 30ca26ce68..5fd921645b 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarousel.cs
@@ -10,13 +10,13 @@ using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Tests.Resources;
 
-namespace osu.Game.Tests.Visual.SongSelect
+namespace osu.Game.Tests.Visual.SongSelectV2
 {
     /// <summary>
     /// Covers common steps which can be used for manual testing.
     /// </summary>
     [TestFixture]
-    public partial class TestSceneBeatmapCarouselV2 : BeatmapCarouselV2TestScene
+    public partial class TestSceneBeatmapCarousel : BeatmapCarouselTestScene
     {
         [Test]
         [Explicit]
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2ArtistGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
similarity index 98%
rename from osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2ArtistGrouping.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
index c378871eac..f0caa796b6 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2ArtistGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
@@ -9,10 +9,10 @@ using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
 
-namespace osu.Game.Tests.Visual.SongSelect
+namespace osu.Game.Tests.Visual.SongSelectV2
 {
     [TestFixture]
-    public partial class TestSceneBeatmapCarouselV2ArtistGrouping : BeatmapCarouselV2TestScene
+    public partial class TestSceneBeatmapCarouselArtistGrouping : BeatmapCarouselTestScene
     {
         [SetUpSteps]
         public void SetUpSteps()
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2DifficultyGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
similarity index 97%
rename from osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2DifficultyGrouping.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
index 239c693ee1..a4cdf8abcb 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2DifficultyGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
@@ -5,15 +5,16 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
 using osuTK;
 
-namespace osu.Game.Tests.Visual.SongSelect
+namespace osu.Game.Tests.Visual.SongSelectV2
 {
     [TestFixture]
-    public partial class TestSceneBeatmapCarouselV2DifficultyGrouping : BeatmapCarouselV2TestScene
+    public partial class TestSceneBeatmapCarouselDifficultyGrouping : BeatmapCarouselTestScene
     {
         [SetUpSteps]
         public void SetUpSteps()
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2NoGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
similarity index 97%
rename from osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2NoGrouping.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
index b4048a5355..ac02d7a3a9 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2NoGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
@@ -5,16 +5,17 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Tests.Visual.SongSelect
+namespace osu.Game.Tests.Visual.SongSelectV2
 {
     [TestFixture]
-    public partial class TestSceneBeatmapCarouselV2NoGrouping : BeatmapCarouselV2TestScene
+    public partial class TestSceneBeatmapCarouselNoGrouping : BeatmapCarouselTestScene
     {
         [SetUpSteps]
         public void SetUpSteps()
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2Scrolling.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
similarity index 94%
rename from osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2Scrolling.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
index 890e1dd6e3..da3fc98c19 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapCarouselV2Scrolling.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
@@ -8,10 +8,10 @@ using osu.Framework.Testing;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.SelectV2;
 
-namespace osu.Game.Tests.Visual.SongSelect
+namespace osu.Game.Tests.Visual.SongSelectV2
 {
     [TestFixture]
-    public partial class TestSceneBeatmapCarouselV2Scrolling : BeatmapCarouselV2TestScene
+    public partial class TestSceneBeatmapCarouselScrolling : BeatmapCarouselTestScene
     {
         [SetUpSteps]
         public void SetUpSteps()
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2GroupPanel.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2GroupPanel.cs
deleted file mode 100644
index 9b07f01e52..0000000000
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2GroupPanel.cs
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Screens.SelectV2;
-using osu.Game.Tests.Visual.UserInterface;
-using osuTK;
-
-namespace osu.Game.Tests.Visual.SongSelectV2
-{
-    public partial class TestSceneBeatmapCarouselV2GroupPanel : ThemeComparisonTestScene
-    {
-        public TestSceneBeatmapCarouselV2GroupPanel()
-            : base(false)
-        {
-        }
-
-        protected override Drawable CreateContent()
-        {
-            return new FillFlowContainer
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Width = 0.5f,
-                RelativeSizeAxes = Axes.X,
-                AutoSizeAxes = Axes.Y,
-                Direction = FillDirection.Vertical,
-                Spacing = new Vector2(0f, 5f),
-                Children = new Drawable[]
-                {
-                    new PanelGroup
-                    {
-                        Item = new CarouselItem(new GroupDefinition('A', "Group A"))
-                    },
-                    new PanelGroup
-                    {
-                        Item = new CarouselItem(new GroupDefinition('A', "Group A")),
-                        KeyboardSelected = { Value = true }
-                    },
-                    new PanelGroup
-                    {
-                        Item = new CarouselItem(new GroupDefinition('A', "Group A")),
-                        Expanded = { Value = true }
-                    },
-                    new PanelGroup
-                    {
-                        Item = new CarouselItem(new GroupDefinition('A', "Group A")),
-                        KeyboardSelected = { Value = true },
-                        Expanded = { Value = true }
-                    },
-                    new PanelGroupStarDifficulty
-                    {
-                        Item = new CarouselItem(new GroupDefinition(1, "1"))
-                    },
-                    new PanelGroupStarDifficulty
-                    {
-                        Item = new CarouselItem(new GroupDefinition(3, "3")),
-                        Expanded = { Value = true }
-                    },
-                    new PanelGroupStarDifficulty
-                    {
-                        Item = new CarouselItem(new GroupDefinition(5, "5")),
-                    },
-                    new PanelGroupStarDifficulty
-                    {
-                        Item = new CarouselItem(new GroupDefinition(7, "7")),
-                        Expanded = { Value = true }
-                    },
-                    new PanelGroupStarDifficulty
-                    {
-                        Item = new CarouselItem(new GroupDefinition(8, "8")),
-                    },
-                    new PanelGroupStarDifficulty
-                    {
-                        Item = new CarouselItem(new GroupDefinition(9, "9")),
-                        Expanded = { Value = true }
-                    },
-                }
-            };
-        }
-    }
-}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapInfoWedge.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapInfoWedge.cs
deleted file mode 100644
index 5b717887e2..0000000000
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapInfoWedge.cs
+++ /dev/null
@@ -1,213 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.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.Screens.Select;
-using osu.Game.Screens.SelectV2;
-
-namespace osu.Game.Tests.Visual.SongSelectV2
-{
-    public partial class TestSceneBeatmapInfoWedge : SongSelectComponentsTestScene
-    {
-        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;
-        }
-
-        public override void SetUpSteps()
-        {
-            base.SetUpSteps();
-
-            AddStep("reset mods", () => SelectedMods.SetDefault());
-        }
-
-        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");
-        }
-
-        [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;
-    }
-}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs
new file mode 100644
index 0000000000..f3c96861ed
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs
@@ -0,0 +1,272 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+using osu.Game.Rulesets;
+using osu.Game.Tests.Resources;
+using osuTK.Input;
+using Realms;
+using CollectionDropdown = osu.Game.Screens.SelectV2.CollectionDropdown;
+
+namespace osu.Game.Tests.Visual.SongSelectV2
+{
+    public partial class TestSceneCollectionDropdown : OsuManualInputManagerTestScene
+    {
+        private BeatmapManager beatmapManager = null!;
+        private CollectionDropdown dropdown = null!;
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host)
+        {
+            Dependencies.Cache(new RealmRulesetStore(Realm));
+            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, Realm, null, Audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(Realm);
+
+            beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+        }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            writeAndRefresh(r => r.RemoveAll<BeatmapCollection>());
+
+            Child = new Container
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Child = dropdown = new CollectionDropdown
+                {
+                    Width = 300,
+                    Y = 100,
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                },
+            };
+        });
+
+        [Test]
+        public void TestEmptyCollectionFilterContainsAllBeatmaps()
+        {
+            assertCollectionDropdownContains("All beatmaps");
+            assertCollectionHeaderDisplays("All beatmaps");
+        }
+
+        [Test]
+        public void TestCollectionAddedToDropdown()
+        {
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
+            assertCollectionDropdownContains("1");
+            assertCollectionDropdownContains("2");
+        }
+
+        [Test]
+        public void TestCollectionsCleared()
+        {
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "3"))));
+
+            AddAssert("check count 5", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(5));
+
+            AddStep("delete all collections", () => writeAndRefresh(r => r.RemoveAll<BeatmapCollection>()));
+
+            AddAssert("check count 2", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestCollectionRemovedFromDropdown()
+        {
+            BeatmapCollection first = null!;
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(first = new BeatmapCollection(name: "1"))));
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "2"))));
+            AddStep("remove collection", () => writeAndRefresh(r => r.Remove(first)));
+
+            assertCollectionDropdownContains("1", false);
+            assertCollectionDropdownContains("2");
+        }
+
+        [Test]
+        public void TestCollectionRenamed()
+        {
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+            AddStep("select collection", () => dropdown.Current.Value = dropdown.ItemSource.ElementAt(1));
+
+            addExpandHeaderStep();
+
+            AddStep("change name", () => writeAndRefresh(_ => getFirstCollection().Name = "First"));
+
+            assertCollectionDropdownContains("First");
+            assertCollectionHeaderDisplays("First");
+        }
+
+        [Test]
+        public void TestAllBeatmapFilterDoesNotHaveAddButton()
+        {
+            addExpandHeaderStep();
+            AddStep("hover all beatmaps", () => InputManager.MoveMouseTo(getAddOrRemoveButton(0)));
+            AddAssert("'All beatmaps' filter does not have add button", () => !getAddOrRemoveButton(0).IsPresent);
+        }
+
+        [Test]
+        public void TestCollectionFilterHasAddButton()
+        {
+            addExpandHeaderStep();
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+            AddStep("hover collection", () => InputManager.MoveMouseTo(getAddOrRemoveButton(1)));
+            AddAssert("collection has add button", () => getAddOrRemoveButton(1).IsPresent);
+        }
+
+        [Test]
+        public void TestButtonDisabledAndEnabledWithBeatmapChanges()
+        {
+            addExpandHeaderStep();
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+
+            AddStep("select available beatmap", () => Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0]));
+            AddAssert("button enabled", () => getAddOrRemoveButton(1).Enabled.Value);
+
+            AddStep("set dummy beatmap", () => Beatmap.SetDefault());
+            AddAssert("button disabled", () => !getAddOrRemoveButton(1).Enabled.Value);
+        }
+
+        [Test]
+        public void TestButtonChangesWhenAddedAndRemovedFromCollection()
+        {
+            addExpandHeaderStep();
+
+            AddStep("select available beatmap", () => Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0]));
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+
+            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
+
+            AddStep("add beatmap to collection", () => writeAndRefresh(r => getFirstCollection().BeatmapMD5Hashes.Add(Beatmap.Value.BeatmapInfo.MD5Hash)));
+            assertFirstButtonIs(FontAwesome.Solid.MinusSquare);
+
+            AddStep("remove beatmap from collection", () => writeAndRefresh(r => getFirstCollection().BeatmapMD5Hashes.Clear()));
+            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
+        }
+
+        [Test]
+        public void TestButtonAddsAndRemovesBeatmap()
+        {
+            addExpandHeaderStep();
+
+            AddStep("select available beatmap", () => Beatmap.Value = beatmapManager.GetWorkingBeatmap(beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0]));
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1"))));
+            assertCollectionDropdownContains("1");
+            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
+
+            addClickAddOrRemoveButtonStep(1);
+            AddAssert("collection contains beatmap", () => getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            assertFirstButtonIs(FontAwesome.Solid.MinusSquare);
+
+            addClickAddOrRemoveButtonStep(1);
+            AddAssert("collection does not contain beatmap", () => !getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
+        }
+
+        [Test]
+        public void TestManageCollectionsFilterIsNotSelected()
+        {
+            bool received = false;
+
+            addExpandHeaderStep();
+
+            AddStep("add collection", () => writeAndRefresh(r => r.Add(new BeatmapCollection(name: "1", new List<string> { "abc" }))));
+            assertCollectionDropdownContains("1");
+
+            AddStep("select collection", () =>
+            {
+                InputManager.MoveMouseTo(getCollectionDropdownItemAt(1));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            addExpandHeaderStep();
+
+            AddStep("watch for filter requests", () =>
+            {
+                received = false;
+                dropdown.ChildrenOfType<CollectionDropdown>().First().RequestFilter = () => received = true;
+            });
+
+            AddStep("click manage collections filter", () =>
+            {
+                int lastItemIndex = dropdown.ChildrenOfType<CollectionDropdown>().Single().Items.Count() - 1;
+                InputManager.MoveMouseTo(getCollectionDropdownItemAt(lastItemIndex));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("collection filter still selected", () => dropdown.Current.Value.CollectionName == "1");
+
+            AddAssert("filter request not fired", () => !received);
+        }
+
+        private void writeAndRefresh(Action<Realm> action) => Realm.Write(r =>
+        {
+            action(r);
+            r.Refresh();
+        });
+
+        private BeatmapCollection getFirstCollection() => Realm.Run(r => r.All<BeatmapCollection>().First());
+
+        private void assertCollectionHeaderDisplays(string collectionName, bool shouldDisplay = true)
+            => AddUntilStep($"collection dropdown header displays '{collectionName}'",
+                () => shouldDisplay == dropdown.ChildrenOfType<CollectionDropdown.ShearedDropdownHeader>().Any(h => h.ChildrenOfType<SpriteText>().Any(t => t.Text == collectionName)));
+
+        private void assertFirstButtonIs(IconUsage icon) => AddUntilStep($"button is {icon.Icon.ToString()}", () => getAddOrRemoveButton(1).Icon.Equals(icon));
+
+        private void assertCollectionDropdownContains(string collectionName, bool shouldContain = true) =>
+            AddUntilStep($"collection dropdown {(shouldContain ? "contains" : "does not contain")} '{collectionName}'",
+                // A bit of a roundabout way of going about this, see: https://github.com/ppy/osu-framework/issues/3871 + https://github.com/ppy/osu-framework/issues/3872
+                () => shouldContain == dropdown.ChildrenOfType<Menu.DrawableMenuItem>().Any(i => i.ChildrenOfType<CompositeDrawable>().OfType<IHasText>().First().Text == collectionName));
+
+        private IconButton getAddOrRemoveButton(int index)
+            => getCollectionDropdownItemAt(index).ChildrenOfType<IconButton>().Single();
+
+        private void addExpandHeaderStep() => AddStep("expand header", () =>
+        {
+            InputManager.MoveMouseTo(dropdown.ChildrenOfType<CollectionDropdown.ShearedDropdownHeader>().Single());
+            InputManager.Click(MouseButton.Left);
+        });
+
+        private void addClickAddOrRemoveButtonStep(int index) => AddStep("click add or remove button", () =>
+        {
+            InputManager.MoveMouseTo(getAddOrRemoveButton(index));
+            InputManager.Click(MouseButton.Left);
+        });
+
+        private Menu.DrawableMenuItem getCollectionDropdownItemAt(int index)
+        {
+            // todo: we should be able to use Items, but apparently that's not guaranteed to be ordered... see: https://github.com/ppy/osu-framework/pull/6079
+            CollectionFilterMenuItem item = dropdown.ChildrenOfType<CollectionDropdown>().Single().ItemSource.ElementAt(index);
+            return dropdown.ChildrenOfType<Menu.DrawableMenuItem>().Single(i => i.Item.Text.Value == item.CollectionName);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyNameContent.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyNameContent.cs
deleted file mode 100644
index 49e7e2bc1a..0000000000
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneDifficultyNameContent.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Localisation;
-using osu.Framework.Testing;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Screens.SelectV2.Wedge;
-
-namespace osu.Game.Tests.Visual.SongSelectV2
-{
-    public partial class TestSceneDifficultyNameContent : SongSelectComponentsTestScene
-    {
-        private DifficultyNameContent? difficultyNameContent;
-
-        [Test]
-        public void TestLocalBeatmap()
-        {
-            AddStep("set component", () => Child = difficultyNameContent = new LocalDifficultyNameContent());
-
-            AddAssert("difficulty name is not set", () => LocalisableString.IsNullOrEmpty(difficultyNameContent.ChildrenOfType<TruncatingSpriteText>().Single().Text));
-            AddAssert("author is not set", () => LocalisableString.IsNullOrEmpty(difficultyNameContent.ChildrenOfType<OsuHoverContainer>().Single().ChildrenOfType<OsuSpriteText>().Single().Text));
-
-            AddStep("set beatmap", () => Beatmap.Value = CreateWorkingBeatmap(new Beatmap
-            {
-                BeatmapInfo = new BeatmapInfo
-                {
-                    DifficultyName = "really long difficulty name that gets truncated",
-                    Metadata = new BeatmapMetadata
-                    {
-                        Author = { Username = "really long username that is autosized" },
-                    },
-                    OnlineID = 1,
-                }
-            }));
-
-            AddAssert("difficulty name is set", () => !LocalisableString.IsNullOrEmpty(difficultyNameContent.ChildrenOfType<TruncatingSpriteText>().Single().Text));
-            AddAssert("author is set", () => !LocalisableString.IsNullOrEmpty(difficultyNameContent.ChildrenOfType<OsuHoverContainer>().Single().ChildrenOfType<OsuSpriteText>().Single().Text));
-        }
-    }
-}
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneFooterButtonMods.cs
similarity index 92%
rename from osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestSceneFooterButtonMods.cs
index e86f83ee15..5c2c6eaf1d 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneFooterButtonMods.cs
@@ -13,19 +13,19 @@ using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Screens.SelectV2.Footer;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Utils;
 
-namespace osu.Game.Tests.Visual.UserInterface
+namespace osu.Game.Tests.Visual.SongSelectV2
 {
-    public partial class TestSceneScreenFooterButtonMods : OsuTestScene
+    public partial class TestSceneFooterButtonMods : OsuTestScene
     {
         private readonly TestScreenFooterButtonMods footerButtonMods;
 
         [Cached]
         private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
 
-        public TestSceneScreenFooterButtonMods()
+        public TestSceneFooterButtonMods()
         {
             Add(footerButtonMods = new TestScreenFooterButtonMods(new TestModSelectOverlay())
             {
@@ -98,9 +98,9 @@ namespace osu.Game.Tests.Visual.UserInterface
         public void TestUnrankedBadge()
         {
             AddStep(@"Add unranked mod", () => changeMods(new[] { new OsuModDeflate() }));
-            AddUntilStep("Unranked badge shown", () => footerButtonMods.ChildrenOfType<ScreenFooterButtonMods.UnrankedBadge>().Single().Alpha == 1);
+            AddUntilStep("Unranked badge shown", () => footerButtonMods.ChildrenOfType<FooterButtonMods.UnrankedBadge>().Single().Alpha == 1);
             AddStep(@"Clear selected mod", () => changeMods(Array.Empty<Mod>()));
-            AddUntilStep("Unranked badge not shown", () => footerButtonMods.ChildrenOfType<ScreenFooterButtonMods.UnrankedBadge>().Single().Alpha == 0);
+            AddUntilStep("Unranked badge not shown", () => footerButtonMods.ChildrenOfType<FooterButtonMods.UnrankedBadge>().Single().Alpha == 0);
         }
 
         private void changeMods(IReadOnlyList<Mod> mods) => footerButtonMods.Current.Value = mods;
@@ -122,7 +122,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             }
         }
 
-        private partial class TestScreenFooterButtonMods : ScreenFooterButtonMods
+        private partial class TestScreenFooterButtonMods : FooterButtonMods
         {
             public new OsuSpriteText MultiplierText => base.MultiplierText;
 
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneLeaderboardScore.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneLeaderboardScore.cs
index 26d39c9203..b59a31c173 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneLeaderboardScore.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneLeaderboardScore.cs
@@ -20,7 +20,7 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
-using osu.Game.Screens.SelectV2.Leaderboards;
+using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
 using osu.Game.Users;
 using osuTK;
@@ -53,14 +53,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
                         Spacing = new Vector2(0f, 2f),
-                        Shear = new Vector2(OsuGame.SHEAR, 0)
+                        Shear = OsuGame.SHEAR,
                     },
                     drawWidthText = new OsuSpriteText(),
                 };
 
                 foreach (var scoreInfo in getTestScores())
                 {
-                    fillFlow.Add(new LeaderboardScoreV2(scoreInfo)
+                    fillFlow.Add(new BeatmapLeaderboardScore(scoreInfo)
                     {
                         Rank = scoreInfo.Position,
                         IsPersonalBest = scoreInfo.User.Id == 2,
@@ -93,7 +93,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
                 foreach (var scoreInfo in getTestScores())
                 {
-                    fillFlow.Add(new LeaderboardScoreV2(scoreInfo)
+                    fillFlow.Add(new BeatmapLeaderboardScore(scoreInfo)
                     {
                         Rank = scoreInfo.Position,
                         IsPersonalBest = scoreInfo.User.Id == 2,
@@ -108,7 +108,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Test]
         public void TestUseTheseModsDoesNotCopySystemMods()
         {
-            LeaderboardScoreV2 score = null!;
+            BeatmapLeaderboardScore score = null!;
 
             AddStep("create content", () =>
             {
@@ -121,7 +121,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
                         Spacing = new Vector2(0f, 2f),
-                        Shear = new Vector2(OsuGame.SHEAR, 0)
+                        Shear = OsuGame.SHEAR,
                     },
                     drawWidthText = new OsuSpriteText(),
                 };
@@ -146,7 +146,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     Date = DateTimeOffset.Now.AddYears(-2),
                 };
 
-                fillFlow.Add(score = new LeaderboardScoreV2(scoreInfo)
+                fillFlow.Add(score = new BeatmapLeaderboardScore(scoreInfo)
                 {
                     Rank = scoreInfo.Position,
                     Shear = Vector2.Zero,
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2DifficultyPanel.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs
similarity index 82%
rename from osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2DifficultyPanel.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs
index 1947721d5d..c0a77553c2 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2DifficultyPanel.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs
@@ -1,16 +1,23 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Carousel;
+using osu.Game.Online.Leaderboards;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Scoring;
 using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual.UserInterface;
@@ -18,14 +25,14 @@ using osuTK;
 
 namespace osu.Game.Tests.Visual.SongSelectV2
 {
-    public partial class TestSceneBeatmapCarouselV2DifficultyPanel : ThemeComparisonTestScene
+    public partial class TestScenePanelBeatmap : ThemeComparisonTestScene
     {
         [Resolved]
         private BeatmapManager beatmaps { get; set; } = null!;
 
         private BeatmapInfo beatmap = null!;
 
-        public TestSceneBeatmapCarouselV2DifficultyPanel()
+        public TestScenePanelBeatmap()
             : base(false)
         {
         }
@@ -65,6 +72,19 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddToggleStep("mania ruleset", v => Ruleset.Value = v ? new ManiaRuleset().RulesetInfo : new OsuRuleset().RulesetInfo);
         }
 
+        [Test]
+        public void TestLocalRank()
+        {
+            foreach (var rank in Enum.GetValues<ScoreRank>())
+            {
+                AddStep($"set {rank.GetDescription()} rank", () => this.ChildrenOfType<UpdateableRank>().ForEach(p =>
+                {
+                    p.Show();
+                    p.Rank = rank;
+                }));
+            }
+        }
+
         protected override Drawable CreateContent()
         {
             return new FillFlowContainer
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2StandalonePanel.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs
similarity index 81%
rename from osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2StandalonePanel.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs
index 2dbe9e6cd1..93e495320f 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2StandalonePanel.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs
@@ -1,16 +1,23 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Carousel;
+using osu.Game.Online.Leaderboards;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Scoring;
 using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual.UserInterface;
@@ -18,14 +25,14 @@ using osuTK;
 
 namespace osu.Game.Tests.Visual.SongSelectV2
 {
-    public partial class TestSceneBeatmapCarouselV2StandalonePanel : ThemeComparisonTestScene
+    public partial class TestScenePanelBeatmapStandalone : ThemeComparisonTestScene
     {
         [Resolved]
         private BeatmapManager beatmaps { get; set; } = null!;
 
         private BeatmapInfo beatmap = null!;
 
-        public TestSceneBeatmapCarouselV2StandalonePanel()
+        public TestScenePanelBeatmapStandalone()
             : base(false)
         {
         }
@@ -65,6 +72,19 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddToggleStep("mania ruleset", v => Ruleset.Value = v ? new ManiaRuleset().RulesetInfo : new OsuRuleset().RulesetInfo);
         }
 
+        [Test]
+        public void TestLocalRank()
+        {
+            foreach (var rank in Enum.GetValues<ScoreRank>())
+            {
+                AddStep($"set {rank.GetDescription()} rank", () => this.ChildrenOfType<UpdateableRank>().ForEach(p =>
+                {
+                    p.Show();
+                    p.Rank = rank;
+                }));
+            }
+        }
+
         protected override Drawable CreateContent()
         {
             return new FillFlowContainer
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelGroup.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelGroup.cs
new file mode 100644
index 0000000000..54c6cb1c0e
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelGroup.cs
@@ -0,0 +1,120 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays;
+using osu.Game.Graphics.Carousel;
+using osu.Game.Screens.SelectV2;
+using osu.Game.Tests.Visual.UserInterface;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.SongSelectV2
+{
+    public partial class TestScenePanelGroup : ThemeComparisonTestScene
+    {
+        public TestScenePanelGroup()
+            : base(false)
+        {
+        }
+
+        [Test]
+        public void TestGeneral()
+        {
+            AddStep("general", () => CreateThemedContent(OverlayColourScheme.Aquamarine));
+        }
+
+        [Test]
+        public void TestStars()
+        {
+            for (int i = 0; i <= 10; i++)
+            {
+                int star = i;
+
+                AddStep($"display {i} star(s)", () =>
+                {
+                    ContentContainer.Child = new DependencyProvidingContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        CachedDependencies = new (Type, object)[]
+                        {
+                            (typeof(OverlayColourProvider), new OverlayColourProvider(OverlayColourScheme.Aquamarine))
+                        },
+                        Child = new FillFlowContainer
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Width = 0.5f,
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Vertical,
+                            Spacing = new Vector2(0f, 5f),
+                            Children = new[]
+                            {
+                                new PanelGroupStarDifficulty
+                                {
+                                    Item = new CarouselItem(new GroupDefinition(star, star.ToString()))
+                                },
+                                new PanelGroupStarDifficulty
+                                {
+                                    Item = new CarouselItem(new GroupDefinition(star, star.ToString())),
+                                    KeyboardSelected = { Value = true },
+                                },
+                                new PanelGroupStarDifficulty
+                                {
+                                    Item = new CarouselItem(new GroupDefinition(star, star.ToString())),
+                                    Expanded = { Value = true },
+                                },
+                                new PanelGroupStarDifficulty
+                                {
+                                    Item = new CarouselItem(new GroupDefinition(star, star.ToString())),
+                                    Expanded = { Value = true },
+                                    KeyboardSelected = { Value = true },
+                                },
+                            },
+                        }
+                    };
+                });
+            }
+        }
+
+        protected override Drawable CreateContent()
+        {
+            return new FillFlowContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Width = 0.5f,
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(0f, 5f),
+                Children = new Drawable[]
+                {
+                    new PanelGroup
+                    {
+                        Item = new CarouselItem(new GroupDefinition('A', "Group A"))
+                    },
+                    new PanelGroup
+                    {
+                        Item = new CarouselItem(new GroupDefinition('A', "Group A")),
+                        KeyboardSelected = { Value = true }
+                    },
+                    new PanelGroup
+                    {
+                        Item = new CarouselItem(new GroupDefinition('A', "Group A")),
+                        Expanded = { Value = true }
+                    },
+                    new PanelGroup
+                    {
+                        Item = new CarouselItem(new GroupDefinition('A', "Group A")),
+                        KeyboardSelected = { Value = true },
+                        Expanded = { Value = true }
+                    },
+                }
+            };
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2SetPanel.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs
similarity index 95%
rename from osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2SetPanel.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs
index ef34394e12..16f6b2cc9c 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselV2SetPanel.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs
@@ -8,6 +8,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Overlays;
 using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Resources;
@@ -16,14 +17,14 @@ using osuTK;
 
 namespace osu.Game.Tests.Visual.SongSelectV2
 {
-    public partial class TestSceneBeatmapCarouselV2SetPanel : ThemeComparisonTestScene
+    public partial class TestScenePanelSet : ThemeComparisonTestScene
     {
         [Resolved]
         private BeatmapManager beatmaps { get; set; } = null!;
 
         private BeatmapSetInfo beatmapSet = null!;
 
-        public TestSceneBeatmapCarouselV2SetPanel()
+        public TestScenePanelSet()
             : base(false)
         {
         }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneUpdateBeatmapSetButtonV2.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelUpdateBeatmapButton.cs
similarity index 90%
rename from osu.Game.Tests/Visual/SongSelectV2/TestSceneUpdateBeatmapSetButtonV2.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestScenePanelUpdateBeatmapButton.cs
index ba3f2635b0..781691d3db 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneUpdateBeatmapSetButtonV2.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelUpdateBeatmapButton.cs
@@ -9,14 +9,14 @@ using osu.Game.Screens.SelectV2;
 
 namespace osu.Game.Tests.Visual.SongSelectV2
 {
-    public partial class TestSceneUpdateBeatmapSetButtonV2 : OsuTestScene
+    public partial class TestScenePanelUpdateBeatmapButton : OsuTestScene
     {
-        private UpdateBeatmapSetButton button = null!;
+        private PanelUpdateBeatmapButton button = null!;
 
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
-            Child = button = new UpdateBeatmapSetButton
+            Child = button = new PanelUpdateBeatmapButton
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneScreenFooter.cs
similarity index 98%
rename from osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs
rename to osu.Game.Tests/Visual/SongSelectV2/TestSceneScreenFooter.cs
index 054bbb39d1..bdecebd64f 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneScreenFooter.cs
@@ -15,9 +15,9 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Screens.Footer;
-using osu.Game.Screens.SelectV2.Footer;
+using osu.Game.Screens.SelectV2;
 
-namespace osu.Game.Tests.Visual.UserInterface
+namespace osu.Game.Tests.Visual.SongSelectV2
 {
     public partial class TestSceneScreenFooter : OsuManualInputManagerTestScene
     {
@@ -51,9 +51,9 @@ namespace osu.Game.Tests.Visual.UserInterface
 
             screenFooter.SetButtons(new ScreenFooterButton[]
             {
-                new ScreenFooterButtonMods(modOverlay) { Current = SelectedMods },
-                new ScreenFooterButtonRandom(),
-                new ScreenFooterButtonOptions(),
+                new FooterButtonMods(modOverlay) { Current = SelectedMods },
+                new FooterButtonRandom(),
+                new FooterButtonOptions(),
             });
         });
 
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
index 630f3c95ee..986ad6fc46 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
@@ -22,7 +22,7 @@ using osu.Game.Rulesets.Taiko;
 using osu.Game.Screens;
 using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.SelectV2.Footer;
+using osu.Game.Screens.SelectV2;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.SongSelectV2
@@ -78,7 +78,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             base.SetUpSteps();
 
-            AddStep("load screen", () => Stack.Push(new Screens.SelectV2.SoloSongSelect()));
+            AddStep("load screen", () => Stack.Push(new SoloSongSelect()));
             AddUntilStep("wait for load", () => Stack.CurrentScreen is Screens.SelectV2.SongSelect songSelect && songSelect.IsLoaded);
         }
 
@@ -199,7 +199,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             AddStep("Press F1", () =>
             {
-                InputManager.MoveMouseTo(this.ChildrenOfType<ScreenFooterButtonMods>().Single());
+                InputManager.MoveMouseTo(this.ChildrenOfType<FooterButtonMods>().Single());
                 InputManager.Click(MouseButton.Left);
             });
             AddAssert("Overlay visible", () => this.ChildrenOfType<ModSelectOverlay>().Single().State.Value == Visibility.Visible);
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs
index 499b28fb49..017d246461 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs
@@ -1003,6 +1003,35 @@ namespace osu.Game.Tests.Visual.UserInterface
                 AddAssert("search still not focused", () => !this.ChildrenOfType<ShearedSearchTextBox>().Single().HasFocus);
         }
 
+        /// <summary>
+        /// Tests that recreating the mod panels (by setting the global available mods) also refreshes the active states.
+        /// </summary>
+        [Test]
+        public void TestActiveStatesRefreshedOnPanelsCreated()
+        {
+            createScreen();
+            changeRuleset(0);
+
+            Bindable<IReadOnlyList<Mod>> selectedMods = null!;
+
+            AddStep("bind mods to local bindable", () =>
+            {
+                selectedMods = new Bindable<IReadOnlyList<Mod>>([]);
+
+                modSelectOverlay.SelectedMods.UnbindFrom(SelectedMods);
+                modSelectOverlay.SelectedMods.BindTo(selectedMods);
+            });
+
+            AddStep("activate PF", () => selectedMods.Value = [new OsuModPerfect()]);
+            AddAssert("OsuModPerfect panel active", () => getPanelForMod(typeof(OsuModPerfect)).Active.Value);
+
+            changeRuleset(1);
+            AddAssert("TaikoModPerfect panel not active", () => !getPanelForMod(typeof(TaikoModPerfect)).Active.Value);
+
+            changeRuleset(0);
+            AddAssert("OsuModPerfect panel active", () => getPanelForMod(typeof(OsuModPerfect)).Active.Value);
+        }
+
         private void waitForColumnLoad() => AddUntilStep("all column content loaded", () =>
             modSelectOverlay.ChildrenOfType<ModColumn>().Any()
             && modSelectOverlay.ChildrenOfType<ModColumn>().All(column => column.IsLoaded && column.ItemsLoaded)
diff --git a/osu.Game.Tests/Visual/UserInterface/TestScenePlaylistOverlay.cs b/osu.Game.Tests/Visual/UserInterface/TestScenePlaylistOverlay.cs
index c723988d6a..2672854e19 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestScenePlaylistOverlay.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestScenePlaylistOverlay.cs
@@ -8,15 +8,12 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Platform;
-using osu.Framework.Testing;
 using osu.Game.Beatmaps;
-using osu.Game.Collections;
 using osu.Game.Database;
 using osu.Game.Overlays.Music;
 using osu.Game.Rulesets;
 using osu.Game.Tests.Resources;
 using osuTK;
-using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
@@ -24,8 +21,6 @@ namespace osu.Game.Tests.Visual.UserInterface
     {
         protected override bool UseFreshStoragePerRun => true;
 
-        private PlaylistOverlay playlistOverlay = null!;
-
         private BeatmapManager beatmapManager = null!;
 
         private const int item_count = 20;
@@ -48,7 +43,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 Size = new Vector2(300, 500),
-                Child = playlistOverlay = new PlaylistOverlay
+                Child = new PlaylistOverlay
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -67,116 +62,5 @@ namespace osu.Game.Tests.Visual.UserInterface
             // Ensure all the initial imports are present before running any tests.
             Realm.Run(r => r.Refresh());
         });
-
-        [Test]
-        public void TestRearrangeItems()
-        {
-            AddUntilStep("wait for load complete", () =>
-            {
-                return this
-                       .ChildrenOfType<PlaylistItem>()
-                       .Count(i => i.ChildrenOfType<DelayedLoadWrapper>().First().DelayedLoadCompleted) > 6;
-            });
-
-            AddUntilStep("wait for animations to complete", () => !playlistOverlay.Transforms.Any());
-
-            PlaylistItem firstItem = null!;
-
-            AddStep("hold 1st item handle", () =>
-            {
-                firstItem = this.ChildrenOfType<PlaylistItem>().First();
-                var handle = firstItem.ChildrenOfType<PlaylistItem.PlaylistItemHandle>().First();
-
-                InputManager.MoveMouseTo(handle.ScreenSpaceDrawQuad.Centre);
-                InputManager.PressButton(MouseButton.Left);
-            });
-
-            AddStep("drag to 5th", () =>
-            {
-                var item = this.ChildrenOfType<PlaylistItem>().ElementAt(4);
-                InputManager.MoveMouseTo(item.ScreenSpaceDrawQuad.BottomLeft);
-            });
-
-            AddAssert("first is moved", () => playlistOverlay.ChildrenOfType<Playlist>().Single().Items.ElementAt(4).Value.Equals(firstItem.Model.Value));
-
-            AddStep("release handle", () => InputManager.ReleaseButton(MouseButton.Left));
-        }
-
-        [Test]
-        public void TestFiltering()
-        {
-            AddStep("set filter to \"10\"", () =>
-            {
-                var filterControl = playlistOverlay.ChildrenOfType<FilterControl>().Single();
-                filterControl.Search.Current.Value = "10";
-            });
-
-            AddAssert("results filtered correctly",
-                () => playlistOverlay.ChildrenOfType<PlaylistItem>()
-                                     .Where(item => item.MatchingFilter)
-                                     .All(item => item.FilterTerms.Any(term => term.ToString().Contains("10"))));
-
-            AddStep("Import new non-matching beatmap", () =>
-            {
-                var testBeatmapSetInfo = TestResources.CreateTestBeatmapSetInfo(1);
-                testBeatmapSetInfo.Beatmaps.Single().Metadata.Title = "no guid";
-                beatmapManager.Import(testBeatmapSetInfo);
-            });
-
-            AddStep("Force realm refresh", () => Realm.Run(r => r.Refresh()));
-
-            AddAssert("results filtered correctly",
-                () => playlistOverlay.ChildrenOfType<PlaylistItem>()
-                                     .Where(item => item.MatchingFilter)
-                                     .All(item => item.FilterTerms.Any(term => term.ToString().Contains("10"))));
-        }
-
-        [Test]
-        public void TestCollectionFiltering()
-        {
-            NowPlayingCollectionDropdown collectionDropdown() => playlistOverlay.ChildrenOfType<NowPlayingCollectionDropdown>().Single();
-
-            AddStep("Add collection", () =>
-            {
-                Realm.Write(r =>
-                {
-                    r.RemoveAll<BeatmapCollection>();
-                    r.Add(new BeatmapCollection("wang"));
-                });
-            });
-
-            AddUntilStep("wait for dropdown to have new collection", () => collectionDropdown().Items.Count() == 2);
-
-            AddStep("Filter to collection", () =>
-            {
-                collectionDropdown().Current.Value = collectionDropdown().Items.Last();
-            });
-
-            AddUntilStep("No items present", () => !playlistOverlay.ChildrenOfType<PlaylistItem>().Any(i => i.MatchingFilter));
-
-            AddStep("Import new non-matching beatmap", () =>
-            {
-                beatmapManager.Import(TestResources.CreateTestBeatmapSetInfo(1));
-            });
-
-            AddStep("Force realm refresh", () => Realm.Run(r => r.Refresh()));
-
-            AddUntilStep("No items matching", () => !playlistOverlay.ChildrenOfType<PlaylistItem>().Any(i => i.MatchingFilter));
-
-            BeatmapSetInfo collectionAddedBeatmapSet = null!;
-
-            AddStep("Import new matching beatmap", () =>
-            {
-                collectionAddedBeatmapSet = TestResources.CreateTestBeatmapSetInfo(1);
-
-                beatmapManager.Import(collectionAddedBeatmapSet);
-                Realm.Write(r => r.All<BeatmapCollection>().First().BeatmapMD5Hashes.Add(collectionAddedBeatmapSet.Beatmaps.First().MD5Hash));
-            });
-
-            AddStep("Force realm refresh", () => Realm.Run(r => r.Refresh()));
-
-            AddUntilStep("Only matching item",
-                () => playlistOverlay.ChildrenOfType<PlaylistItem>().Where(i => i.MatchingFilter).Select(i => i.Model.ID), () => Is.EquivalentTo(new[] { collectionAddedBeatmapSet.ID }));
-        }
     }
 }
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneShearAligningWrapper.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneShearAligningWrapper.cs
new file mode 100644
index 0000000000..eb65de8fdc
--- /dev/null
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneShearAligningWrapper.cs
@@ -0,0 +1,132 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Testing;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Overlays;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public partial class TestSceneShearAligningWrapper : OsuTestScene
+    {
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
+        private ShearedBox first = null!;
+        private ShearedBox second = null!;
+        private ShearedBox third = null!;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            Child = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Width = 200f,
+                AutoSizeAxes = Axes.Y,
+                Shear = OsuGame.SHEAR,
+                CornerRadius = 10f,
+                Masking = true,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colourProvider.Background6,
+                    },
+                    new FillFlowContainer
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(0f, 10f),
+                        Children = new Drawable[]
+                        {
+                            new ShearAligningWrapper(first = new ShearedBox("Text 1", OsuColour.Gray(0.4f))
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                Height = 30,
+                            }),
+                            new ShearAligningWrapper(second = new ShearedBox("Text 2", OsuColour.Gray(0.3f))
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                Height = 30,
+                            }),
+                            new ShearAligningWrapper(third = new ShearedBox("Text 3", OsuColour.Gray(0.2f))
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                Height = 30,
+                            }),
+                        }
+                    }
+                },
+            };
+        });
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddSliderStep("box 1 height", 0, 100, 30, h =>
+            {
+                if (first.IsNotNull())
+                    first.Height = h;
+            });
+            AddSliderStep("box 2 height", 0, 100, 30, h =>
+            {
+                if (second.IsNotNull())
+                    second.Height = h;
+            });
+            AddSliderStep("box 3 height", 0, 100, 30, h =>
+            {
+                if (third.IsNotNull())
+                    third.Height = h;
+            });
+        }
+
+        public partial class ShearedBox : Container
+        {
+            private readonly string text;
+            private readonly Color4 boxColour;
+
+            public ShearedBox(string text, Color4 boxColour)
+            {
+                this.text = text;
+                this.boxColour = boxColour;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                CornerRadius = 10;
+                Masking = true;
+
+                InternalChildren = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = boxColour,
+                    },
+                    new OsuSpriteText
+                    {
+                        Text = text,
+                        Colour = Color4.White,
+                        Shear = -OsuGame.SHEAR,
+                        Font = OsuFont.Torus.With(size: 24),
+                        Margin = new MarginPadding { Left = 50 },
+                    }
+                };
+            }
+        }
+    }
+}
diff --git a/osu.Game.Tests/osu.Game.Tests.csproj b/osu.Game.Tests/osu.Game.Tests.csproj
index a1f43505f0..c86f05c257 100644
--- a/osu.Game.Tests/osu.Game.Tests.csproj
+++ b/osu.Game.Tests/osu.Game.Tests.csproj
@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
+    <PackageReference Include="Bogus" Version="35.6.2" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="DeepEqual" Version="4.2.1" />
     <PackageReference Include="Nito.AsyncEx" Version="5.1.2" />
diff --git a/osu.Game.Tournament/Models/TournamentMatch.cs b/osu.Game.Tournament/Models/TournamentMatch.cs
index 0a700eb4d6..1d91febd1a 100644
--- a/osu.Game.Tournament/Models/TournamentMatch.cs
+++ b/osu.Game.Tournament/Models/TournamentMatch.cs
@@ -19,6 +19,7 @@ namespace osu.Game.Tournament.Models
     {
         public int ID;
 
+        [JsonIgnore]
         public List<string> Acronyms
         {
             get
diff --git a/osu.Game.Tournament/TournamentGameBase.cs b/osu.Game.Tournament/TournamentGameBase.cs
index eecd097a97..2be7c4aff3 100644
--- a/osu.Game.Tournament/TournamentGameBase.cs
+++ b/osu.Game.Tournament/TournamentGameBase.cs
@@ -53,6 +53,14 @@ namespace osu.Game.Tournament
             return new ProductionEndpointConfiguration();
         }
 
+        public override void SetHost(GameHost host)
+        {
+            base.SetHost(host);
+
+            if (host.Window != null)
+                host.Window.Title = $"{Name} [tournament client]";
+        }
+
         private TournamentSpriteText initialisationText = null!;
 
         [BackgroundDependencyLoader]
diff --git a/osu.Game/Beatmaps/BeatmapManager.cs b/osu.Game/Beatmaps/BeatmapManager.cs
index 1e66b28b15..2c17908487 100644
--- a/osu.Game/Beatmaps/BeatmapManager.cs
+++ b/osu.Game/Beatmaps/BeatmapManager.cs
@@ -298,7 +298,21 @@ namespace osu.Game.Beatmaps
         /// <param name="query">The query.</param>
         /// <returns>The first result for the provided query, or null if no results were found.</returns>
         public BeatmapInfo? QueryBeatmap(Expression<Func<BeatmapInfo, bool>> query) => Realm.Run(r =>
-            r.All<BeatmapInfo>().Filter($"{nameof(BeatmapInfo.BeatmapSet)}.{nameof(BeatmapSetInfo.DeletePending)} == false").FirstOrDefault(query)?.Detach());
+            r.All<BeatmapInfo>().Filter($@"{nameof(BeatmapInfo.BeatmapSet)}.{nameof(BeatmapSetInfo.DeletePending)} == false").FirstOrDefault(query)?.Detach());
+
+        /// <summary>
+        /// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
+        /// Use this overload instead of <see cref="QueryBeatmap(System.Linq.Expressions.Expression{System.Func{osu.Game.Beatmaps.BeatmapInfo,bool}})"/>
+        /// when Realm is unable to transform an expression to the internal Realm query syntax.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <param name="arguments">The arguments for the query.</param>
+        /// <returns>The first result for the provided query, or null if no results were found.</returns>
+        public BeatmapInfo? QueryBeatmap(string query, params QueryArgument[] arguments) => Realm.Run(r =>
+            r.All<BeatmapInfo>()
+             .Filter($@"{nameof(BeatmapInfo.BeatmapSet)}.{nameof(BeatmapSetInfo.DeletePending)} == false")
+             .Filter(query, arguments)
+             .FirstOrDefault()?.Detach());
 
         /// <summary>
         /// A default representation of a WorkingBeatmap to use when no beatmap is available.
diff --git a/osu.Game/Beatmaps/BeatmapOnlineStatus.cs b/osu.Game/Beatmaps/BeatmapOnlineStatus.cs
index 41393a8a39..d489aeda3f 100644
--- a/osu.Game/Beatmaps/BeatmapOnlineStatus.cs
+++ b/osu.Game/Beatmaps/BeatmapOnlineStatus.cs
@@ -14,10 +14,10 @@ namespace osu.Game.Beatmaps
         /// This is a special status given when local changes are made via the editor.
         /// Once in this state, online status changes should be ignored unless the beatmap is reverted or submitted.
         /// </summary>
-        [Description("Local")]
         [LocalisableDescription(typeof(SongSelectStrings), nameof(SongSelectStrings.LocallyModified))]
         LocallyModified = -4,
 
+        [Description("Unknown")]
         None = -3,
 
         [LocalisableDescription(typeof(BeatmapsetsStrings), nameof(BeatmapsetsStrings.ShowStatusGraveyard))]
diff --git a/osu.Game/Beatmaps/BeatmapStatistic.cs b/osu.Game/Beatmaps/BeatmapStatistic.cs
index 13e0e4ad5e..64e42f3f02 100644
--- a/osu.Game/Beatmaps/BeatmapStatistic.cs
+++ b/osu.Game/Beatmaps/BeatmapStatistic.cs
@@ -16,7 +16,19 @@ namespace osu.Game.Beatmaps
         /// </summary>
         public Func<Drawable> CreateIcon;
 
-        public string Content;
+        /// <summary>
+        /// The name of this statistic.
+        /// </summary>
         public LocalisableString Name;
+
+        /// <summary>
+        /// The text representing the value of this statistic.
+        /// </summary>
+        public string Content;
+
+        /// <summary>
+        /// The length of a bar which visually represents this statistic's relevance in the beatmap.
+        /// </summary>
+        public float? BarDisplayLength;
     }
 }
diff --git a/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs b/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs
index 7b99ad40de..c6a3c7db3c 100644
--- a/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs
+++ b/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs
@@ -19,9 +19,10 @@ namespace osu.Game.Beatmaps.Drawables
 {
     public partial class BeatmapSetOnlineStatusPill : CircularContainer, IHasTooltip
     {
-        private const double animation_duration = 400;
-
-        private BeatmapOnlineStatus status;
+        /// <summary>
+        /// Whether to show <see cref="BeatmapOnlineStatus.None"/> as "unknown" instead of fading out.
+        /// </summary>
+        public bool ShowUnknownStatus { get; init; }
 
         public BeatmapOnlineStatus Status
         {
@@ -34,30 +35,27 @@ namespace osu.Game.Beatmaps.Drawables
                 status = value;
 
                 if (IsLoaded)
-                {
-                    AutoSizeDuration = (float)animation_duration;
-                    AutoSizeEasing = Easing.OutQuint;
-
                     updateState();
-                }
             }
         }
 
+        private BeatmapOnlineStatus status;
+
         public float TextSize
         {
-            get => statusText.Font.Size;
-            set => statusText.Font = statusText.Font.With(size: value);
+            init => statusText.Font = statusText.Font.With(size: value);
         }
 
         public MarginPadding TextPadding
         {
-            get => statusText.Padding;
-            set => statusText.Padding = value;
+            init => statusText.Padding = value;
         }
 
         private readonly OsuSpriteText statusText;
         private readonly Box background;
 
+        private const double animation_duration = 400;
+
         [Resolved]
         private OsuColour colours { get; set; } = null!;
 
@@ -66,6 +64,7 @@ namespace osu.Game.Beatmaps.Drawables
 
         public BeatmapSetOnlineStatusPill()
         {
+            AutoSizeAxes = Axes.Both;
             Masking = true;
 
             Alpha = 0;
@@ -99,14 +98,27 @@ namespace osu.Game.Beatmaps.Drawables
 
         private void updateState()
         {
-            if (Status == BeatmapOnlineStatus.None)
+            if (Status == BeatmapOnlineStatus.None && !ShowUnknownStatus)
             {
-                Hide();
+                this.FadeOut(animation_duration, Easing.OutQuint);
                 return;
             }
 
+            // The autosize animation on this component is intended to animate horizontal sizing only.
+            // To avoid vertical autosize animating from zero to non-zero, only apply the duration
+            // after we have a valid size.
+            if (Height > 0)
+            {
+                AutoSizeDuration = (float)animation_duration;
+                AutoSizeEasing = Easing.OutQuint;
+            }
+
             this.FadeIn(animation_duration, Easing.OutQuint);
 
+            // Handle the case where transition from hidden to non-hidden may cause
+            // a fade from a colour that doesn't make sense (due to not being able to see the previous colour).
+            double duration = Alpha > 0 ? animation_duration : 0;
+
             Color4 statusTextColour;
 
             if (colourProvider != null)
@@ -114,8 +126,8 @@ namespace osu.Game.Beatmaps.Drawables
             else
                 statusTextColour = status == BeatmapOnlineStatus.Graveyard ? colours.GreySeaFoamLight : Color4.Black;
 
-            statusText.FadeColour(statusTextColour, animation_duration, Easing.OutQuint);
-            background.FadeColour(OsuColour.ForBeatmapSetOnlineStatus(Status) ?? colourProvider?.Light1 ?? colours.GreySeaFoamLighter, animation_duration, Easing.OutQuint);
+            statusText.FadeColour(statusTextColour, duration, Easing.OutQuint);
+            background.FadeColour(OsuColour.ForBeatmapSetOnlineStatus(Status) ?? colourProvider?.Light1 ?? colours.GreySeaFoamLighter, duration, Easing.OutQuint);
 
             statusText.Text = Status.GetLocalisableDescription().ToUpper();
         }
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtraInfoRow.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtraInfoRow.cs
index 41513ec7a2..ee2f682708 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtraInfoRow.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtraInfoRow.cs
@@ -30,7 +30,6 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                 {
                     new BeatmapSetOnlineStatusPill
                     {
-                        AutoSizeAxes = Axes.Both,
                         Status = beatmapSet.Status,
                         Anchor = Anchor.CentreLeft,
                         Origin = Anchor.CentreLeft,
diff --git a/osu.Game/Beatmaps/Drawables/Cards/Buttons/BeatmapCardIconButton.cs b/osu.Game/Beatmaps/Drawables/Cards/Buttons/BeatmapCardIconButton.cs
index e78fd651fe..e4bcae281c 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/Buttons/BeatmapCardIconButton.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/Buttons/BeatmapCardIconButton.cs
@@ -43,61 +43,43 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
             }
         }
 
-        private float iconSize;
+        protected SpriteIcon Icon { get; private set; } = null!;
 
-        public float IconSize
+        private Container content = null!;
+        private Container hover = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
         {
-            get => iconSize;
-            set
-            {
-                iconSize = value;
-                Icon.Size = new Vector2(iconSize);
-            }
-        }
+            RelativeSizeAxes = Axes.Both;
 
-        protected readonly SpriteIcon Icon;
-
-        protected override Container<Drawable> Content => content;
-
-        private readonly Container content;
-        private readonly Box hover;
-
-        protected BeatmapCardIconButton()
-        {
-            Origin = Anchor.Centre;
-            Anchor = Anchor.Centre;
-
-            base.Content.Add(content = new Container
+            Add(content = new Container
             {
                 RelativeSizeAxes = Axes.Both,
                 Masking = true,
-                CornerRadius = BeatmapCard.CORNER_RADIUS,
                 Scale = new Vector2(0.8f),
                 Origin = Anchor.Centre,
                 Anchor = Anchor.Centre,
                 Children = new Drawable[]
                 {
-                    hover = new Box
+                    hover = new Container
                     {
                         RelativeSizeAxes = Axes.Both,
+                        CornerRadius = BeatmapCard.CORNER_RADIUS,
+                        Masking = true,
                         Colour = Color4.White.Opacity(0.1f),
                         Blending = BlendingParameters.Additive,
+                        Child = new Box { RelativeSizeAxes = Axes.Both, }
                     },
                     Icon = new SpriteIcon
                     {
                         Origin = Anchor.Centre,
                         Anchor = Anchor.Centre,
-                        Scale = new Vector2(1.2f),
+                        Size = new Vector2(14),
                     },
                 }
             });
 
-            IconSize = 12;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colourProvider)
-        {
             IdleColour = colourProvider.Light1;
             HoverColour = colourProvider.Content1;
         }
@@ -127,8 +109,14 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
             bool isHovered = IsHovered && Enabled.Value;
 
             hover.FadeTo(isHovered ? 1f : 0f, 500, Easing.OutQuint);
-            content.ScaleTo(isHovered ? 1 : 0.8f, 500, Easing.OutQuint);
+            content.ScaleTo(isHovered ? 0.9f : 0.8f, 500, Easing.OutQuint);
             Icon.FadeColour(isHovered ? HoverColour : IdleColour, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
         }
+
+        protected void SetLoading(bool isLoading)
+        {
+            Icon.FadeTo(isLoading ? 0.2f : 1, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
+            Enabled.Value = !isLoading;
+        }
     }
 }
diff --git a/osu.Game/Beatmaps/Drawables/Cards/Buttons/DownloadButton.cs b/osu.Game/Beatmaps/Drawables/Cards/Buttons/DownloadButton.cs
index 7f23b46150..96ec9d0731 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/Buttons/DownloadButton.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/Buttons/DownloadButton.cs
@@ -8,10 +8,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Online;
 using osu.Game.Resources.Localisation.Web;
-using osuTK;
 
 namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
 {
@@ -23,17 +21,11 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
 
         private Bindable<bool> preferNoVideo = null!;
 
-        private readonly LoadingSpinner spinner;
-
         [Resolved]
         private BeatmapModelDownloader beatmaps { get; set; } = null!;
 
         public DownloadButton(APIBeatmapSet beatmapSet)
         {
-            Icon.Icon = FontAwesome.Solid.Download;
-
-            Content.Add(spinner = new LoadingSpinner { Size = new Vector2(IconSize) });
-
             this.beatmapSet = beatmapSet;
         }
 
@@ -41,6 +33,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
         private void load(OsuConfigManager config)
         {
             preferNoVideo = config.GetBindable<bool>(OsuSetting.PreferNoVideo);
+            Icon.Icon = FontAwesome.Solid.Download;
         }
 
         protected override void LoadComplete()
@@ -64,8 +57,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
                 case DownloadState.Importing:
                     Action = null;
                     TooltipText = string.Empty;
-                    spinner.Show();
-                    Icon.Hide();
+                    SetLoading(true);
                     break;
 
                 case DownloadState.LocallyAvailable:
@@ -84,8 +76,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
 
                     Action = () => beatmaps.Download(beatmapSet, preferNoVideo.Value);
                     this.FadeIn(BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
-                    spinner.Hide();
-                    Icon.Show();
+                    SetLoading(false);
 
                     if (!beatmapSet.HasVideo)
                         TooltipText = BeatmapsetsStrings.PanelDownloadAll;
diff --git a/osu.Game/Beatmaps/Drawables/Cards/Buttons/FavouriteButton.cs b/osu.Game/Beatmaps/Drawables/Cards/Buttons/FavouriteButton.cs
index f698185863..0b2aaf0bc3 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/Buttons/FavouriteButton.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/Buttons/FavouriteButton.cs
@@ -53,19 +53,20 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
             favouriteRequest?.Cancel();
             favouriteRequest = new PostBeatmapFavouriteRequest(beatmapSet.OnlineID, actionType);
 
-            Enabled.Value = false;
+            SetLoading(true);
+
             favouriteRequest.Success += () =>
             {
                 bool favourited = actionType == BeatmapFavouriteAction.Favourite;
 
                 current.Value = new BeatmapSetFavouriteState(favourited, current.Value.FavouriteCount + (favourited ? 1 : -1));
 
-                Enabled.Value = true;
+                SetLoading(false);
             };
             favouriteRequest.Failure += e =>
             {
                 Logger.Error(e, $"Failed to {actionType.ToString().ToLowerInvariant()} beatmap: {e.Message}");
-                Enabled.Value = true;
+                SetLoading(false);
             };
 
             api.Queue(favouriteRequest);
diff --git a/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs b/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs
index 3df94bf233..e95ac94457 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs
@@ -20,15 +20,14 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
         public GoToBeatmapButton(APIBeatmapSet beatmapSet)
         {
             this.beatmapSet = beatmapSet;
-
-            Icon.Icon = FontAwesome.Solid.AngleDoubleRight;
-            TooltipText = "Go to beatmap";
         }
 
         [BackgroundDependencyLoader(true)]
         private void load(OsuGame? game)
         {
             Action = () => game?.PresentBeatmap(beatmapSet);
+            Icon.Icon = FontAwesome.Solid.AngleDoubleRight;
+            TooltipText = "Go to beatmap";
         }
 
         protected override void LoadComplete()
diff --git a/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs b/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs
index a29724032e..5ab6e1a218 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs
@@ -95,9 +95,6 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                     Child = buttons = new Container<BeatmapCardIconButton>
                     {
                         RelativeSizeAxes = Axes.Both,
-                        // Padding of 4 avoids touching the card borders when in the expanded (ie. showing difficulties) state.
-                        // Left override allows the buttons to visually be wider and look better.
-                        Padding = new MarginPadding(4) { Left = 2 },
                         Children = new BeatmapCardIconButton[]
                         {
                             new FavouriteButton(beatmapSet)
@@ -106,7 +103,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                                 Anchor = Anchor.TopCentre,
                                 Origin = Anchor.TopCentre,
                                 RelativeSizeAxes = Axes.Both,
-                                Height = 0.48f,
+                                Height = 0.5f,
                             },
                             new DownloadButton(beatmapSet)
                             {
@@ -114,7 +111,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                                 Origin = Anchor.BottomCentre,
                                 State = { BindTarget = downloadTracker.State },
                                 RelativeSizeAxes = Axes.Both,
-                                Height = 0.48f,
+                                Height = 0.5f,
                             },
                             new GoToBeatmapButton(beatmapSet)
                             {
@@ -122,7 +119,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                                 Origin = Anchor.BottomCentre,
                                 State = { BindTarget = downloadTracker.State },
                                 RelativeSizeAxes = Axes.Both,
-                                Height = 0.48f,
+                                Height = 0.5f,
                             }
                         }
                     }
diff --git a/osu.Game/Beatmaps/Drawables/DifficultySpectrumDisplay.cs b/osu.Game/Beatmaps/Drawables/DifficultySpectrumDisplay.cs
index fc41c7c6dc..b7f4d4ca61 100644
--- a/osu.Game/Beatmaps/Drawables/DifficultySpectrumDisplay.cs
+++ b/osu.Game/Beatmaps/Drawables/DifficultySpectrumDisplay.cs
@@ -141,7 +141,7 @@ namespace osu.Game.Beatmaps.Drawables
 
                 Add(countText = new OsuSpriteText
                 {
-                    Font = OsuFont.Default.With(size: 12),
+                    Font = OsuFont.Style.Caption1,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Padding = new MarginPadding { Bottom = 1 }
diff --git a/osu.Game/Beatmaps/Drawables/StarRatingDisplay.cs b/osu.Game/Beatmaps/Drawables/StarRatingDisplay.cs
index 4119ffb636..050a78a6b4 100644
--- a/osu.Game/Beatmaps/Drawables/StarRatingDisplay.cs
+++ b/osu.Game/Beatmaps/Drawables/StarRatingDisplay.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;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
@@ -39,8 +38,6 @@ namespace osu.Game.Beatmaps.Drawables
 
         private readonly Bindable<double> displayedStars = new BindableDouble();
 
-        private readonly Container textContainer;
-
         /// <summary>
         /// The currently displayed stars of this display wrapped in a bindable.
         /// This bindable gets transformed on change rather than instantaneous, if animation is enabled.
@@ -119,19 +116,14 @@ namespace osu.Game.Beatmaps.Drawables
                                     Size = new Vector2(8f),
                                 },
                                 Empty(),
-                                textContainer = new Container
+                                starsText = new OsuSpriteText
                                 {
-                                    AutoSizeAxes = Axes.Y,
-                                    Child = starsText = new OsuSpriteText
-                                    {
-                                        Anchor = Anchor.Centre,
-                                        Origin = Anchor.Centre,
-                                        Margin = new MarginPadding { Bottom = 1.5f },
-                                        // todo: this should be size: 12f, but to match up with the design, it needs to be 14.4f
-                                        // see https://github.com/ppy/osu-framework/issues/3271.
-                                        Font = OsuFont.Torus.With(size: 14.4f, weight: FontWeight.Bold),
-                                        Shadow = false,
-                                    },
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Margin = new MarginPadding { Bottom = 1.5f },
+                                    Spacing = new Vector2(-1.4f),
+                                    Font = OsuFont.Torus.With(size: 14.4f, weight: FontWeight.Bold, fixedWidth: true),
+                                    Shadow = false,
                                 },
                             }
                         }
@@ -162,11 +154,6 @@ namespace osu.Game.Beatmaps.Drawables
 
                 starIcon.Colour = s.NewValue >= 6.5 ? colours.Orange1 : colourProvider?.Background5 ?? Color4Extensions.FromHex("303d47");
                 starsText.Colour = s.NewValue >= 6.5 ? colours.Orange1 : colourProvider?.Background5 ?? Color4.Black.Opacity(0.75f);
-
-                // In order to avoid autosize throwing the width of these displays all over the place,
-                // let's lock in some sane defaults for the text width based on how many digits we're
-                // displaying.
-                textContainer.Width = 24 + Math.Max(starsText.Text.ToString().Length - 4, 0) * 6;
             }, true);
         }
     }
diff --git a/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs b/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs
index 765f2be345..e3ac0e1a3d 100644
--- a/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs
@@ -36,6 +36,11 @@ namespace osu.Game.Beatmaps.Formats
         /// </remarks>
         public const double CONTROL_POINT_LENIENCY = 5;
 
+        /// <summary>
+        /// The maximum allowed number of keys in mania beatmaps.
+        /// </summary>
+        public const int MAX_MANIA_KEY_COUNT = 18;
+
         internal static RulesetStore? RulesetStore;
 
         private Beatmap beatmap = null!;
@@ -116,7 +121,7 @@ namespace osu.Game.Beatmaps.Formats
             // mania uses "circle size" for key count, thus different allowable range
             difficulty.CircleSize = beatmap.BeatmapInfo.Ruleset.OnlineID != 3
                 ? Math.Clamp(difficulty.CircleSize, 0, 10)
-                : Math.Clamp(difficulty.CircleSize, 1, 18);
+                : Math.Clamp(difficulty.CircleSize, 1, MAX_MANIA_KEY_COUNT);
 
             difficulty.OverallDifficulty = Math.Clamp(difficulty.OverallDifficulty, 0, 10);
             difficulty.ApproachRate = Math.Clamp(difficulty.ApproachRate, 0, 10);
diff --git a/osu.Game/Beatmaps/WorkingBeatmap.cs b/osu.Game/Beatmaps/WorkingBeatmap.cs
index 8df57fd0c8..b0f6082406 100644
--- a/osu.Game/Beatmaps/WorkingBeatmap.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmap.cs
@@ -213,12 +213,12 @@ namespace osu.Game.Beatmaps
                     if (ae.InnerExceptions.FirstOrDefault() is TaskCanceledException)
                         return null;
 
-                    Logger.Error(ae, "Beatmap failed to load");
+                    Logger.Error(ae, $"Beatmap failed to load ({BeatmapInfo})");
                     return null;
                 }
                 catch (Exception e)
                 {
-                    Logger.Error(e, "Beatmap failed to load");
+                    Logger.Error(e, $"Beatmap failed to load ({BeatmapInfo})");
                     return null;
                 }
             }
diff --git a/osu.Game/Configuration/OsuConfigManager.cs b/osu.Game/Configuration/OsuConfigManager.cs
index 76d06f3665..0399f50ded 100644
--- a/osu.Game/Configuration/OsuConfigManager.cs
+++ b/osu.Game/Configuration/OsuConfigManager.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Diagnostics;
 using osu.Framework;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
@@ -263,10 +262,6 @@ namespace osu.Game.Configuration
 
         public override TrackedSettings CreateTrackedSettings()
         {
-            // these need to be assigned in normal game startup scenarios.
-            Debug.Assert(LookupKeyBindings != null);
-            Debug.Assert(LookupSkinName != null);
-
             return new TrackedSettings
             {
                 new TrackedSetting<bool>(OsuSetting.ShowFpsDisplay, state => new SettingDescription(
@@ -330,8 +325,7 @@ namespace osu.Game.Configuration
         }
 
         public Func<Guid, string> LookupSkinName { private get; set; } = _ => @"unknown";
-
-        public Func<GlobalAction, LocalisableString> LookupKeyBindings { get; set; } = _ => @"unknown";
+        public Func<GlobalAction, LocalisableString> LookupKeyBindings { private get; set; } = _ => @"unknown";
 
         IBindable<float> IGameplaySettings.ComboColourNormalisationAmount => GetOriginalBindable<float>(OsuSetting.ComboColourNormalisationAmount);
         IBindable<float> IGameplaySettings.PositionalHitsoundsLevel => GetOriginalBindable<float>(OsuSetting.PositionalHitsoundsLevel);
diff --git a/osu.Game/Configuration/SessionAverageHitErrorTracker.cs b/osu.Game/Configuration/SessionAverageHitErrorTracker.cs
index cd21eb6fa8..49f7657f91 100644
--- a/osu.Game/Configuration/SessionAverageHitErrorTracker.cs
+++ b/osu.Game/Configuration/SessionAverageHitErrorTracker.cs
@@ -40,10 +40,10 @@ namespace osu.Game.Configuration
             if (newScore.Mods.Any(m => !m.UserPlayable || m is IHasNoTimedInputs))
                 return;
 
-            if (newScore.HitEvents.Count < 10)
+            if (newScore.HitEvents.Count < 50)
                 return;
 
-            if (newScore.HitEvents.CalculateAverageHitError() is not double averageError)
+            if (newScore.HitEvents.CalculateMedianHitError() is not double medianError)
                 return;
 
             // keep a sane maximum number of entries.
@@ -51,7 +51,7 @@ namespace osu.Game.Configuration
                 averageHitErrorHistory.RemoveAt(0);
 
             double globalOffset = configManager.Get<double>(OsuSetting.AudioOffset);
-            averageHitErrorHistory.Add(new DataPoint(averageError, globalOffset));
+            averageHitErrorHistory.Add(new DataPoint(medianError, globalOffset));
         }
 
         public void ClearHistory() => averageHitErrorHistory.Clear();
diff --git a/osu.Game/Database/RealmArchiveModelImporter.cs b/osu.Game/Database/RealmArchiveModelImporter.cs
index e538530b79..a3cdc2dc77 100644
--- a/osu.Game/Database/RealmArchiveModelImporter.cs
+++ b/osu.Game/Database/RealmArchiveModelImporter.cs
@@ -139,9 +139,14 @@ namespace osu.Game.Database
                             notification.Progress = (float)current / tasks.Length;
                         }
                     }
-                    catch (OperationCanceledException)
+                    catch (OperationCanceledException cancelled)
                     {
-                        throw;
+                        // We don't want to abort the full import process based off difficulty calculator's internal cancellation
+                        // see https://github.com/ppy/osu/blob/91f3be5feaab0c73c17e1a8c270516aa9bee1e14/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs#L65.
+                        if (cancelled.CancellationToken == notification.CancellationToken)
+                            throw;
+
+                        Logger.Error(cancelled, $@"Timed out importing ({task})", LoggingTarget.Database);
                     }
                     catch (Exception e)
                     {
diff --git a/osu.Game/Database/RealmDetachedBeatmapStore.cs b/osu.Game/Database/RealmDetachedBeatmapStore.cs
index b05e07ef31..6954bb320a 100644
--- a/osu.Game/Database/RealmDetachedBeatmapStore.cs
+++ b/osu.Game/Database/RealmDetachedBeatmapStore.cs
@@ -30,7 +30,8 @@ namespace osu.Game.Database
         public override IBindableList<BeatmapSetInfo> GetBeatmapSets(CancellationToken? cancellationToken)
         {
             loaded.Wait(cancellationToken ?? CancellationToken.None);
-            return detachedBeatmapSets.GetBoundCopy();
+            lock (detachedBeatmapSets)
+                return detachedBeatmapSets.GetBoundCopy();
         }
 
         [BackgroundDependencyLoader]
@@ -65,8 +66,11 @@ namespace osu.Game.Database
                         {
                             var detached = frozenSets.Detach();
 
-                            detachedBeatmapSets.Clear();
-                            detachedBeatmapSets.AddRange(detached);
+                            lock (detachedBeatmapSets)
+                            {
+                                detachedBeatmapSets.Clear();
+                                detachedBeatmapSets.AddRange(detached);
+                            }
                         });
                     }
                     finally
@@ -116,22 +120,28 @@ namespace osu.Game.Database
             if (!loaded.IsSet)
                 return;
 
-            // If this ever leads to performance issues, we could dequeue a limited number of operations per update frame.
-            while (pendingOperations.TryDequeue(out var op))
+            if (pendingOperations.Count == 0)
+                return;
+
+            lock (detachedBeatmapSets)
             {
-                switch (op.Type)
+                // If this ever leads to performance issues, we could dequeue a limited number of operations per update frame.
+                while (pendingOperations.TryDequeue(out var op))
                 {
-                    case OperationType.Insert:
-                        detachedBeatmapSets.Insert(op.Index, op.BeatmapSet!);
-                        break;
+                    switch (op.Type)
+                    {
+                        case OperationType.Insert:
+                            detachedBeatmapSets.Insert(op.Index, op.BeatmapSet!);
+                            break;
 
-                    case OperationType.Update:
-                        detachedBeatmapSets.ReplaceRange(op.Index, 1, new[] { op.BeatmapSet! });
-                        break;
+                        case OperationType.Update:
+                            detachedBeatmapSets.ReplaceRange(op.Index, 1, new[] { op.BeatmapSet! });
+                            break;
 
-                    case OperationType.Remove:
-                        detachedBeatmapSets.RemoveAt(op.Index);
-                        break;
+                        case OperationType.Remove:
+                            detachedBeatmapSets.RemoveAt(op.Index);
+                            break;
+                    }
                 }
             }
         }
diff --git a/osu.Game/Extensions/NumberFormattingExtensions.cs b/osu.Game/Extensions/NumberFormattingExtensions.cs
new file mode 100644
index 0000000000..618b086a5b
--- /dev/null
+++ b/osu.Game/Extensions/NumberFormattingExtensions.cs
@@ -0,0 +1,51 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Globalization;
+using System.Numerics;
+using osu.Game.Utils;
+
+namespace osu.Game.Extensions
+{
+    public static class NumberFormattingExtensions
+    {
+        /// <summary>
+        /// For a given numeric type, return a formatted string in the standard format we use for display everywhere.
+        /// </summary>
+        /// <param name="value">The numeric value.</param>
+        /// <param name="maxDecimalDigits">The maximum number of decimals to be considered in the original value.</param>
+        /// <param name="asPercentage">Whether the output should be a percentage. For integer types, 0-100 is mapped to 0-100%; for other types 0-1 is mapped to 0-100%.</param>
+        /// <returns>The formatted output.</returns>
+        public static string ToStandardFormattedString<T>(this T value, int maxDecimalDigits, bool asPercentage) where T : struct, INumber<T>, IMinMaxValue<T>
+        {
+            double floatValue = double.CreateTruncating(value);
+
+            decimal decimalPrecision = normalise(decimal.CreateTruncating(value), maxDecimalDigits);
+
+            // Find the number of significant digits (we could have less than maxDecimalDigits after normalize())
+            int significantDigits = FormatUtils.FindPrecision(decimalPrecision);
+
+            if (asPercentage)
+            {
+                if (value is int)
+                    floatValue /= 100;
+
+                return floatValue.ToString($@"0.{new string('0', Math.Max(0, significantDigits - 2))}%", CultureInfo.InvariantCulture);
+            }
+
+            string negativeSign = Math.Round(floatValue, significantDigits) < 0 ? "-" : string.Empty;
+
+            return FormattableString.Invariant($"{negativeSign}{Math.Abs(floatValue).ToString($"N{significantDigits}")}");
+        }
+
+        /// <summary>
+        /// Removes all non-significant digits, keeping at most a requested number of decimal digits.
+        /// </summary>
+        /// <param name="d">The decimal to normalize.</param>
+        /// <param name="sd">The maximum number of decimal digits to keep. The final result may have fewer decimal digits than this value.</param>
+        /// <returns>The normalised decimal.</returns>
+        private static decimal normalise(decimal d, int sd)
+            => decimal.Parse(Math.Round(d, sd).ToString(string.Concat("0.", new string('#', sd)), CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
+    }
+}
diff --git a/osu.Game/Screens/SelectV2/Carousel.cs b/osu.Game/Graphics/Carousel/Carousel.cs
similarity index 98%
rename from osu.Game/Screens/SelectV2/Carousel.cs
rename to osu.Game/Graphics/Carousel/Carousel.cs
index 5339b5358b..3a02eb7119 100644
--- a/osu.Game/Screens/SelectV2/Carousel.cs
+++ b/osu.Game/Graphics/Carousel/Carousel.cs
@@ -24,7 +24,7 @@ using osu.Game.Input.Bindings;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Screens.SelectV2
+namespace osu.Game.Graphics.Carousel
 {
     /// <summary>
     /// A highly efficient vertical list display that is used primarily for the song select screen,
@@ -38,12 +38,12 @@ namespace osu.Game.Screens.SelectV2
         /// <summary>
         /// Height of the area above the carousel that should be treated as visible due to transparency of elements in front of it.
         /// </summary>
-        public float BleedTop { get; set; } = 0;
+        public float BleedTop { get; set; }
 
         /// <summary>
         /// Height of the area below the carousel that should be treated as visible due to transparency of elements in front of it.
         /// </summary>
-        public float BleedBottom { get; set; } = 0;
+        public float BleedBottom { get; set; }
 
         /// <summary>
         /// The number of pixels outside the carousel's vertical bounds to manifest drawables.
@@ -228,6 +228,7 @@ namespace osu.Game.Screens.SelectV2
         {
             InternalChild = Scroll = new CarouselScrollContainer
             {
+                Masking = false,
                 RelativeSizeAxes = Axes.Both,
             };
 
@@ -505,7 +506,7 @@ namespace osu.Game.Screens.SelectV2
         private void scrollToSelection()
         {
             if (currentKeyboardSelection.CarouselItem != null)
-                Scroll.ScrollTo(currentKeyboardSelection.CarouselItem.CarouselYPosition - visibleHalfHeight);
+                Scroll.ScrollTo(currentKeyboardSelection.CarouselItem.CarouselYPosition - visibleHalfHeight + BleedTop);
         }
 
         #endregion
@@ -519,17 +520,17 @@ namespace osu.Game.Screens.SelectV2
         /// <summary>
         /// The position of the lower visible bound with respect to the current scroll position.
         /// </summary>
-        private float visibleBottomBound => (float)(Scroll.Current + DrawHeight + BleedBottom);
+        private float visibleBottomBound;
 
         /// <summary>
         /// The position of the upper visible bound with respect to the current scroll position.
         /// </summary>
-        private float visibleUpperBound => (float)(Scroll.Current - BleedTop);
+        private float visibleUpperBound;
 
         /// <summary>
         /// Half the height of the visible content.
         /// </summary>
-        private float visibleHalfHeight => (DrawHeight + BleedBottom + BleedTop) / 2;
+        private float visibleHalfHeight;
 
         protected override void Update()
         {
@@ -538,6 +539,10 @@ namespace osu.Game.Screens.SelectV2
             if (carouselItems == null)
                 return;
 
+            visibleBottomBound = (float)(Scroll.Current + DrawHeight + BleedBottom);
+            visibleUpperBound = (float)(Scroll.Current - BleedTop);
+            visibleHalfHeight = (DrawHeight + BleedBottom + BleedTop) / 2;
+
             if (!selectionValid.IsValid)
             {
                 refreshAfterSelection();
@@ -582,7 +587,7 @@ namespace osu.Game.Screens.SelectV2
         protected virtual float GetPanelXOffset(Drawable panel)
         {
             Vector2 posInScroll = Scroll.ToLocalSpace(panel.ScreenSpaceDrawQuad.Centre);
-            float dist = Math.Abs(1f - posInScroll.Y / visibleHalfHeight);
+            float dist = Math.Abs(1f - (posInScroll.Y + BleedTop) / visibleHalfHeight);
 
             return offsetX(dist, visibleHalfHeight);
         }
diff --git a/osu.Game/Screens/SelectV2/CarouselItem.cs b/osu.Game/Graphics/Carousel/CarouselItem.cs
similarity index 86%
rename from osu.Game/Screens/SelectV2/CarouselItem.cs
rename to osu.Game/Graphics/Carousel/CarouselItem.cs
index 36dc48a497..741e4d32fc 100644
--- a/osu.Game/Screens/SelectV2/CarouselItem.cs
+++ b/osu.Game/Graphics/Carousel/CarouselItem.cs
@@ -3,7 +3,7 @@
 
 using System;
 
-namespace osu.Game.Screens.SelectV2
+namespace osu.Game.Graphics.Carousel
 {
     /// <summary>
     /// Represents a single display item for display in a <see cref="Carousel{T}"/>.
@@ -11,7 +11,7 @@ namespace osu.Game.Screens.SelectV2
     /// </summary>
     public sealed class CarouselItem : IComparable<CarouselItem>
     {
-        public const float DEFAULT_HEIGHT = 50;
+        public const float DEFAULT_HEIGHT = 45;
 
         /// <summary>
         /// The model this item is representing.
@@ -44,6 +44,11 @@ namespace osu.Game.Screens.SelectV2
         /// </summary>
         public bool IsExpanded { get; set; }
 
+        /// <summary>
+        /// The number of nested items underneath this header. Should only be used for headers of groups.
+        /// </summary>
+        public int NestedItemCount { get; set; }
+
         public CarouselItem(object model)
         {
             Model = model;
diff --git a/osu.Game/Screens/SelectV2/ICarouselFilter.cs b/osu.Game/Graphics/Carousel/ICarouselFilter.cs
similarity index 95%
rename from osu.Game/Screens/SelectV2/ICarouselFilter.cs
rename to osu.Game/Graphics/Carousel/ICarouselFilter.cs
index f510a7cd4b..570f480aab 100644
--- a/osu.Game/Screens/SelectV2/ICarouselFilter.cs
+++ b/osu.Game/Graphics/Carousel/ICarouselFilter.cs
@@ -5,7 +5,7 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace osu.Game.Screens.SelectV2
+namespace osu.Game.Graphics.Carousel
 {
     /// <summary>
     /// An interface representing a filter operation which can be run on a <see cref="Carousel{T}"/>.
diff --git a/osu.Game/Screens/SelectV2/ICarouselPanel.cs b/osu.Game/Graphics/Carousel/ICarouselPanel.cs
similarity index 97%
rename from osu.Game/Screens/SelectV2/ICarouselPanel.cs
rename to osu.Game/Graphics/Carousel/ICarouselPanel.cs
index 4fba0d2827..5f0ebc263c 100644
--- a/osu.Game/Screens/SelectV2/ICarouselPanel.cs
+++ b/osu.Game/Graphics/Carousel/ICarouselPanel.cs
@@ -5,7 +5,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Pooling;
 
-namespace osu.Game.Screens.SelectV2
+namespace osu.Game.Graphics.Carousel
 {
     /// <summary>
     /// An interface to be attached to any <see cref="Drawable"/>s which are used for display inside a <see cref="Carousel{T}"/>.
diff --git a/osu.Game/Graphics/Containers/LinkFlowContainer.cs b/osu.Game/Graphics/Containers/LinkFlowContainer.cs
index 6022ea6bd6..fd5ca39dac 100644
--- a/osu.Game/Graphics/Containers/LinkFlowContainer.cs
+++ b/osu.Game/Graphics/Containers/LinkFlowContainer.cs
@@ -134,7 +134,7 @@ namespace osu.Game.Graphics.Containers
 
         protected virtual DrawableLinkCompiler CreateLinkCompiler(ITextPart textPart) => new DrawableLinkCompiler(textPart);
 
-        protected override FillFlowContainer CreateFlow() => new LinkFlow();
+        protected override InnerFlow CreateFlow() => new LinkFlow();
 
         private partial class LinkFlow : InnerFlow
         {
diff --git a/osu.Game/Graphics/Containers/ShearAligningWrapper.cs b/osu.Game/Graphics/Containers/ShearAligningWrapper.cs
new file mode 100644
index 0000000000..d720120b4f
--- /dev/null
+++ b/osu.Game/Graphics/Containers/ShearAligningWrapper.cs
@@ -0,0 +1,49 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Layout;
+using osuTK;
+
+namespace osu.Game.Graphics.Containers
+{
+    /// <summary>
+    /// Adds left padding based on direct parent to make sheared pieces in a vertical flow aligned appropriately.
+    /// </summary>
+    /// <remarks>
+    /// See associated test scene for further demonstration.
+    /// </remarks>
+    public partial class ShearAligningWrapper : CompositeDrawable
+    {
+        private readonly LayoutValue layout = new LayoutValue(Invalidation.MiscGeometry);
+
+        public ShearAligningWrapper(Drawable drawable)
+        {
+            RelativeSizeAxes = drawable.RelativeSizeAxes;
+            AutoSizeAxes = Axes.Both & ~drawable.RelativeSizeAxes;
+
+            InternalChild = drawable;
+
+            AddLayout(layout);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (!layout.IsValid)
+            {
+                updateLayout();
+                layout.Validate();
+            }
+        }
+
+        private void updateLayout()
+        {
+            float shearWidth = OsuGame.SHEAR.X * Parent!.DrawHeight;
+            float relativeY = Parent!.DrawHeight == 0 ? 0 : InternalChild.ToSpaceOfOtherDrawable(Vector2.Zero, Parent).Y / Parent!.DrawHeight;
+            Padding = new MarginPadding { Left = shearWidth * relativeY };
+        }
+    }
+}
diff --git a/osu.Game/Graphics/OsuColour.cs b/osu.Game/Graphics/OsuColour.cs
index 2c43876fb2..dd5e19e167 100644
--- a/osu.Game/Graphics/OsuColour.cs
+++ b/osu.Game/Graphics/OsuColour.cs
@@ -20,10 +20,7 @@ namespace osu.Game.Graphics
         public static Color4 Gray(float amt) => new Color4(amt, amt, amt, 1f);
         public static Color4 Gray(byte amt) => new Color4(amt, amt, amt, 255);
 
-        /// <summary>
-        /// Retrieves the colour for a given point in the star range.
-        /// </summary>
-        public Color4 ForStarDifficulty(double starDifficulty) => ColourUtils.SampleFromLinearGradient(new[]
+        public static readonly (float, Color4)[] STAR_DIFFICULTY_SPECTRUM =
         {
             (0.1f, Color4Extensions.FromHex("aaaaaa")),
             (0.1f, Color4Extensions.FromHex("4290fb")),
@@ -37,7 +34,13 @@ namespace osu.Game.Graphics
             (6.7f, Color4Extensions.FromHex("6563de")),
             (7.7f, Color4Extensions.FromHex("18158e")),
             (9.0f, Color4.Black),
-        }, (float)Math.Round(starDifficulty, 2, MidpointRounding.AwayFromZero));
+            (10.0f, Color4.Black),
+        };
+
+        /// <summary>
+        /// Retrieves the colour for a given point in the star range.
+        /// </summary>
+        public Color4 ForStarDifficulty(double starDifficulty) => ColourUtils.SampleFromLinearGradient(STAR_DIFFICULTY_SPECTRUM, (float)Math.Round(starDifficulty, 2, MidpointRounding.AwayFromZero));
 
         /// <summary>
         /// Retrieves the colour for a <see cref="ScoreRank"/>.
@@ -120,6 +123,9 @@ namespace osu.Game.Graphics
         {
             switch (status)
             {
+                case BeatmapOnlineStatus.None:
+                    return Color4.RosyBrown;
+
                 case BeatmapOnlineStatus.LocallyModified:
                     return Color4.OrangeRed;
 
@@ -403,6 +409,12 @@ namespace osu.Game.Graphics
         public readonly Color4 Orange3 = Color4Extensions.FromHex(@"cca633");
         public readonly Color4 Orange4 = Color4Extensions.FromHex(@"6b5c2e");
 
+        public readonly Color4 DarkOrange0 = Color4Extensions.FromHex(@"ffbb99");
+        public readonly Color4 DarkOrange1 = Color4Extensions.FromHex(@"ff9966");
+        public readonly Color4 DarkOrange2 = Color4Extensions.FromHex(@"eb7e47");
+        public readonly Color4 DarkOrange3 = Color4Extensions.FromHex(@"cc6633");
+        public readonly Color4 DarkOrange4 = Color4Extensions.FromHex(@"6b422e");
+
         public readonly Color4 Red0 = Color4Extensions.FromHex(@"ff9b9b");
         public readonly Color4 Red1 = Color4Extensions.FromHex(@"ff6666");
         public readonly Color4 Red2 = Color4Extensions.FromHex(@"eb4747");
diff --git a/osu.Game/Graphics/OsuFont.cs b/osu.Game/Graphics/OsuFont.cs
index 7aa98ece95..b314c602f5 100644
--- a/osu.Game/Graphics/OsuFont.cs
+++ b/osu.Game/Graphics/OsuFont.cs
@@ -15,15 +15,65 @@ namespace osu.Game.Graphics
         /// </summary>
         public const float DEFAULT_FONT_SIZE = 16;
 
+        /// <summary>
+        /// Template font styles which should be preferred whenever possible for UI elements.
+        /// </summary>
+        public static class Style
+        {
+            /// <summary>
+            /// Equivalent to Torus with 32px size and semi-bold weight.
+            /// </summary>
+            public static FontUsage Title => GetFont(Typeface.TorusAlternate, size: 32, weight: FontWeight.Regular);
+
+            /// <summary>
+            /// Torus with 28px size and semi-bold weight.
+            /// </summary>
+            public static FontUsage Subtitle => GetFont(size: 28, weight: FontWeight.Regular);
+
+            /// <summary>
+            /// Torus with 22px size and bold weight.
+            /// </summary>
+            public static FontUsage Heading1 => GetFont(size: 22, weight: FontWeight.Bold);
+
+            /// <summary>
+            /// Torus with 18px size and semi-bold weight.
+            /// </summary>
+            public static FontUsage Heading2 => GetFont(size: 18, weight: FontWeight.SemiBold);
+
+            /// <summary>
+            /// Torus with 16px size and regular weight.
+            /// </summary>
+            public static FontUsage Body => GetFont(size: DEFAULT_FONT_SIZE, weight: FontWeight.Regular);
+
+            /// <summary>
+            /// Torus with 14px size and regular weight.
+            /// </summary>
+            public static FontUsage Caption1 => GetFont(size: 14, weight: FontWeight.Regular);
+
+            /// <summary>
+            /// Torus with 12px size and regular weight.
+            /// </summary>
+            public static FontUsage Caption2 => GetFont(size: 12, weight: FontWeight.Regular);
+        }
+
         /// <summary>
         /// The default font.
         /// </summary>
-        public static FontUsage Default => GetFont();
+        public static FontUsage Default => GetFont(weight: FontWeight.Medium);
 
+        /// <summary>
+        /// Font face for numeric display.
+        /// </summary>
         public static FontUsage Numeric => GetFont(Typeface.Venera, weight: FontWeight.Bold);
 
+        /// <summary>
+        /// Default font face for UI and game elements.
+        /// </summary>
         public static FontUsage Torus => GetFont(Typeface.Torus, weight: FontWeight.Regular);
 
+        /// <summary>
+        /// Default font face with alternate character set for headings and flair text.
+        /// </summary>
         public static FontUsage TorusAlternate => GetFont(Typeface.TorusAlternate, weight: FontWeight.Regular);
 
         public static FontUsage Inter => GetFont(Typeface.Inter, weight: FontWeight.Regular);
diff --git a/osu.Game/Graphics/OsuIcon.cs b/osu.Game/Graphics/OsuIcon.cs
index 9879ef5d14..84ff86a5e5 100644
--- a/osu.Game/Graphics/OsuIcon.cs
+++ b/osu.Game/Graphics/OsuIcon.cs
@@ -115,6 +115,7 @@ namespace osu.Game.Graphics
         public static IconUsage ChangelogB => get(OsuIconMapping.ChangelogB);
         public static IconUsage Chat => get(OsuIconMapping.Chat);
         public static IconUsage CheckCircle => get(OsuIconMapping.CheckCircle);
+        public static IconUsage Clock => get(OsuIconMapping.Clock);
         public static IconUsage CollapseA => get(OsuIconMapping.CollapseA);
         public static IconUsage Collections => get(OsuIconMapping.Collections);
         public static IconUsage Cross => get(OsuIconMapping.Cross);
@@ -141,6 +142,7 @@ namespace osu.Game.Graphics
         public static IconUsage Input => get(OsuIconMapping.Input);
         public static IconUsage Maintenance => get(OsuIconMapping.Maintenance);
         public static IconUsage Megaphone => get(OsuIconMapping.Megaphone);
+        public static IconUsage Metronome => get(OsuIconMapping.Metronome);
         public static IconUsage Music => get(OsuIconMapping.Music);
         public static IconUsage News => get(OsuIconMapping.News);
         public static IconUsage Next => get(OsuIconMapping.Next);
@@ -204,6 +206,9 @@ namespace osu.Game.Graphics
             [Description(@"check-circle")]
             CheckCircle,
 
+            [Description(@"clock")]
+            Clock,
+
             [Description(@"collapse-a")]
             CollapseA,
 
@@ -282,6 +287,9 @@ namespace osu.Game.Graphics
             [Description(@"megaphone")]
             Megaphone,
 
+            [Description(@"metronome")]
+            Metronome,
+
             [Description(@"music")]
             Music,
 
diff --git a/osu.Game/Graphics/UserInterface/DialogButton.cs b/osu.Game/Graphics/UserInterface/DialogButton.cs
index c39f41bf72..423d9637b8 100644
--- a/osu.Game/Graphics/UserInterface/DialogButton.cs
+++ b/osu.Game/Graphics/UserInterface/DialogButton.cs
@@ -129,7 +129,7 @@ namespace osu.Game.Graphics.UserInterface
                                 Radius = 5,
                             },
                             Colour = ButtonColour,
-                            Shear = new Vector2(0.2f, 0),
+                            Shear = OsuGame.SHEAR,
                             Children = new Drawable[]
                             {
                                 new Box
@@ -149,7 +149,7 @@ namespace osu.Game.Graphics.UserInterface
                                             RelativeSizeAxes = Axes.Both,
                                             TriangleScale = 4,
                                             ColourDark = OsuColour.Gray(0.88f),
-                                            Shear = new Vector2(-0.2f, 0),
+                                            Shear = -OsuGame.SHEAR,
                                             ClampAxes = Axes.Y
                                         },
                                     },
diff --git a/osu.Game/Graphics/UserInterface/OsuAnimatedButton.cs b/osu.Game/Graphics/UserInterface/OsuAnimatedButton.cs
index 0eec04541c..48d225de41 100644
--- a/osu.Game/Graphics/UserInterface/OsuAnimatedButton.cs
+++ b/osu.Game/Graphics/UserInterface/OsuAnimatedButton.cs
@@ -25,6 +25,8 @@ namespace osu.Game.Graphics.UserInterface
 
         private Color4 hoverColour = Color4.White.Opacity(0.1f);
 
+        protected float ScaleOnMouseDown { get; init; } = 0.75f;
+
         /// <summary>
         /// The background colour of the <see cref="OsuAnimatedButton"/> while it is hovered.
         /// </summary>
@@ -119,7 +121,7 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override bool OnMouseDown(MouseDownEvent e)
         {
-            Content.ScaleTo(0.75f, 2000, Easing.OutQuint);
+            Content.ScaleTo(ScaleOnMouseDown, 2000, Easing.OutQuint);
             return base.OnMouseDown(e);
         }
 
diff --git a/osu.Game/Graphics/UserInterface/OsuDropdown.cs b/osu.Game/Graphics/UserInterface/OsuDropdown.cs
index 5a1fbaa3a4..af335efdc4 100644
--- a/osu.Game/Graphics/UserInterface/OsuDropdown.cs
+++ b/osu.Game/Graphics/UserInterface/OsuDropdown.cs
@@ -252,6 +252,7 @@ namespace osu.Game.Graphics.UserInterface
                                 Size = new Vector2(8),
                                 Alpha = 0,
                                 X = chevron_offset,
+                                Y = 1,
                                 Margin = new MarginPadding { Left = 3, Right = 3 },
                                 Origin = Anchor.CentreLeft,
                                 Anchor = Anchor.CentreLeft,
diff --git a/osu.Game/Graphics/UserInterface/OsuSliderBar.cs b/osu.Game/Graphics/UserInterface/OsuSliderBar.cs
index 4b52ac4a3a..ca95d45042 100644
--- a/osu.Game/Graphics/UserInterface/OsuSliderBar.cs
+++ b/osu.Game/Graphics/UserInterface/OsuSliderBar.cs
@@ -1,9 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Numerics;
-using System.Globalization;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -11,7 +9,7 @@ using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
 using osu.Framework.Utils;
-using osu.Game.Utils;
+using osu.Game.Extensions;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -85,35 +83,6 @@ namespace osu.Game.Graphics.UserInterface
             channel.Play();
         }
 
-        public LocalisableString GetDisplayableValue(T value)
-        {
-            if (CurrentNumber.IsInteger)
-                return int.CreateTruncating(value).ToString("N0");
-
-            double floatValue = double.CreateTruncating(value);
-
-            decimal decimalPrecision = normalise(decimal.CreateTruncating(CurrentNumber.Precision), max_decimal_digits);
-
-            // Find the number of significant digits (we could have less than 5 after normalize())
-            int significantDigits = FormatUtils.FindPrecision(decimalPrecision);
-
-            if (DisplayAsPercentage)
-            {
-                return floatValue.ToString($@"P{Math.Max(0, significantDigits - 2)}");
-            }
-
-            string negativeSign = Math.Round(floatValue, significantDigits) < 0 ? "-" : string.Empty;
-
-            return $"{negativeSign}{Math.Abs(floatValue).ToString($"N{significantDigits}")}";
-        }
-
-        /// <summary>
-        /// Removes all non-significant digits, keeping at most a requested number of decimal digits.
-        /// </summary>
-        /// <param name="d">The decimal to normalize.</param>
-        /// <param name="sd">The maximum number of decimal digits to keep. The final result may have fewer decimal digits than this value.</param>
-        /// <returns>The normalised decimal.</returns>
-        private decimal normalise(decimal d, int sd)
-            => decimal.Parse(Math.Round(d, sd).ToString(string.Concat("0.", new string('#', sd)), CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
+        public LocalisableString GetDisplayableValue(T value) => value.ToStandardFormattedString(max_decimal_digits, DisplayAsPercentage);
     }
 }
diff --git a/osu.Game/Graphics/UserInterface/ShearedButton.cs b/osu.Game/Graphics/UserInterface/ShearedButton.cs
index 87d269ccd4..a059490aa8 100644
--- a/osu.Game/Graphics/UserInterface/ShearedButton.cs
+++ b/osu.Game/Graphics/UserInterface/ShearedButton.cs
@@ -11,7 +11,6 @@ using osu.Framework.Localisation;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
-using osuTK;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -66,8 +65,6 @@ namespace osu.Game.Graphics.UserInterface
         private readonly Box background;
         private readonly OsuSpriteText text;
 
-        private const float shear = OsuGame.SHEAR;
-
         private Colour4? darkerColour;
         private Colour4? lighterColour;
         private Colour4? textColour;
@@ -91,10 +88,10 @@ namespace osu.Game.Graphics.UserInterface
         public ShearedButton(float? width = null, float height = DEFAULT_HEIGHT)
         {
             Height = height;
-            Padding = new MarginPadding { Horizontal = shear * height };
+            Padding = new MarginPadding { Horizontal = OsuGame.SHEAR.X * height };
 
             Content.CornerRadius = CORNER_RADIUS;
-            Content.Shear = new Vector2(shear, 0);
+            Content.Shear = OsuGame.SHEAR;
             Content.Masking = true;
             Content.Anchor = Content.Origin = Anchor.Centre;
 
@@ -117,7 +114,7 @@ namespace osu.Game.Graphics.UserInterface
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
                             AutoSizeAxes = Axes.Both,
-                            Shear = new Vector2(-shear, 0),
+                            Shear = -OsuGame.SHEAR,
                             Child = text = new OsuSpriteText
                             {
                                 Font = OsuFont.TorusAlternate.With(size: 17),
diff --git a/osu.Game/Graphics/UserInterface/ShearedNub.cs b/osu.Game/Graphics/UserInterface/ShearedNub.cs
index 7485f68525..17b50b5d58 100644
--- a/osu.Game/Graphics/UserInterface/ShearedNub.cs
+++ b/osu.Game/Graphics/UserInterface/ShearedNub.cs
@@ -26,8 +26,6 @@ namespace osu.Game.Graphics.UserInterface
         public const int HEIGHT = 30;
         public const float EXPANDED_SIZE = 50;
 
-        public static readonly Vector2 SHEAR = new Vector2(0.15f, 0);
-
         private readonly Box fill;
         private readonly Container main;
 
@@ -40,7 +38,7 @@ namespace osu.Game.Graphics.UserInterface
             Size = new Vector2(EXPANDED_SIZE, HEIGHT);
             InternalChild = main = new Container
             {
-                Shear = SHEAR,
+                Shear = OsuGame.SHEAR,
                 BorderColour = Colour4.White,
                 BorderThickness = BORDER_WIDTH,
                 Masking = true,
diff --git a/osu.Game/Graphics/UserInterface/ShearedSearchTextBox.cs b/osu.Game/Graphics/UserInterface/ShearedSearchTextBox.cs
index c6565726b5..f5fbb3411f 100644
--- a/osu.Game/Graphics/UserInterface/ShearedSearchTextBox.cs
+++ b/osu.Game/Graphics/UserInterface/ShearedSearchTextBox.cs
@@ -52,7 +52,7 @@ namespace osu.Game.Graphics.UserInterface
         public ShearedSearchTextBox()
         {
             Height = 42;
-            Shear = new Vector2(OsuGame.SHEAR, 0);
+            Shear = OsuGame.SHEAR;
             Masking = true;
             CornerRadius = corner_radius;
 
@@ -115,7 +115,7 @@ namespace osu.Game.Graphics.UserInterface
                 PlaceholderText = CommonStrings.InputSearch;
 
                 CornerRadius = corner_radius;
-                TextContainer.Shear = new Vector2(-OsuGame.SHEAR, 0);
+                TextContainer.Shear = -OsuGame.SHEAR;
             }
 
             protected override SpriteText CreatePlaceholder() => new SearchPlaceholder();
diff --git a/osu.Game/Graphics/UserInterface/ShearedSliderBar.cs b/osu.Game/Graphics/UserInterface/ShearedSliderBar.cs
index a36b9c7a4c..e7b57f5c9e 100644
--- a/osu.Game/Graphics/UserInterface/ShearedSliderBar.cs
+++ b/osu.Game/Graphics/UserInterface/ShearedSliderBar.cs
@@ -58,7 +58,7 @@ namespace osu.Game.Graphics.UserInterface
 
         public ShearedSliderBar()
         {
-            Shear = SHEAR;
+            Shear = OsuGame.SHEAR;
             Height = HEIGHT;
             RangePadding = EXPANDED_SIZE / 2;
             Children = new Drawable[]
@@ -98,11 +98,11 @@ namespace osu.Game.Graphics.UserInterface
                 },
                 nubContainer = new Container
                 {
-                    Shear = -SHEAR,
+                    Shear = -OsuGame.SHEAR,
                     RelativeSizeAxes = Axes.Both,
                     Child = Nub = new ShearedNub
                     {
-                        X = -SHEAR.X * HEIGHT / 2f,
+                        X = -OsuGame.SHEAR.X * HEIGHT / 2f,
                         Origin = Anchor.TopCentre,
                         RelativePositionAxes = Axes.X,
                         Current = { Value = true },
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormSliderBar.cs b/osu.Game/Graphics/UserInterfaceV2/FormSliderBar.cs
index 4e43b133c7..1304c298fb 100644
--- a/osu.Game/Graphics/UserInterfaceV2/FormSliderBar.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/FormSliderBar.cs
@@ -68,6 +68,11 @@ namespace osu.Game.Graphics.UserInterfaceV2
         /// </summary>
         public LocalisableString HintText { get; init; }
 
+        /// <summary>
+        /// A custom step value for each key press which actuates a change on this control.
+        /// </summary>
+        public float KeyboardStep { get; init; }
+
         private Box background = null!;
         private Box flashLayer = null!;
         private FormTextBox.InnerTextBox textBox = null!;
@@ -140,6 +145,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
                             Origin = Anchor.CentreRight,
                             RelativeSizeAxes = Axes.X,
                             Width = 0.5f,
+                            KeyboardStep = KeyboardStep,
                             Current = currentNumberInstantaneous,
                             OnCommit = () => current.Value = currentNumberInstantaneous.Value,
                         }
@@ -306,6 +312,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
                 Height = 40;
                 RelativeSizeAxes = Axes.X;
                 RangePadding = nub_width / 2;
+
                 Children = new Drawable[]
                 {
                     new Container
diff --git a/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs b/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs
index 0b9c5f294c..d77b9be2da 100644
--- a/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs
@@ -36,16 +36,6 @@ namespace osu.Game.Graphics.UserInterfaceV2
             }
         }
 
-        protected override void Update()
-        {
-            base.Update();
-
-            var header = (ShearedDropdownHeader)Header;
-            var menu = (ShearedDropdownMenu)Menu;
-
-            menu.Padding = new MarginPadding { Left = header.LabelContainer.DrawWidth - 10f, Right = 6f };
-        }
-
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
             if (e.Repeat) return false;
@@ -62,18 +52,15 @@ namespace osu.Game.Graphics.UserInterfaceV2
 
         protected partial class ShearedDropdownMenu : OsuDropdown<T>.OsuDropdownMenu
         {
-            private readonly Vector2 shear = new Vector2(OsuGame.SHEAR, 0);
-
-            public new MarginPadding Padding
-            {
-                get => base.Padding;
-                set => base.Padding = value;
-            }
-
             public ShearedDropdownMenu()
             {
-                Shear = shear;
+                Shear = OsuGame.SHEAR;
                 Margin = new MarginPadding { Top = 5f };
+                Padding = new MarginPadding
+                {
+                    Left = -6f,
+                    Right = 6f
+                };
             }
 
             protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new ShearedMenuItem(item)
@@ -84,20 +71,16 @@ namespace osu.Game.Graphics.UserInterfaceV2
 
             public partial class ShearedMenuItem : DrawableOsuDropdownMenuItem
             {
-                private readonly Vector2 shear = new Vector2(OsuGame.SHEAR, 0);
-
                 public ShearedMenuItem(MenuItem item)
                     : base(item)
                 {
-                    Foreground.Shear = -shear;
+                    Foreground.Shear = -OsuGame.SHEAR;
                 }
             }
         }
 
         public partial class ShearedDropdownHeader : DropdownHeader
         {
-            private const float corner_radius = 5f;
-
             private LocalisableString label;
 
             protected override LocalisableString Label
@@ -125,15 +108,13 @@ namespace osu.Game.Graphics.UserInterfaceV2
             public ShearedDropdown<T> Dropdown = null!;
             private ShearedDropdownSearchBar searchBar = null!;
 
-            private readonly Vector2 shear = new Vector2(OsuGame.SHEAR, 0);
-
             [Resolved]
             private OverlayColourProvider colourProvider { get; set; } = null!;
 
             public ShearedDropdownHeader()
             {
-                Shear = shear;
-                CornerRadius = corner_radius;
+                Shear = OsuGame.SHEAR;
+                CornerRadius = ShearedButton.CORNER_RADIUS;
                 Masking = true;
 
                 Foreground.Children = new Drawable[]
@@ -154,7 +135,8 @@ namespace osu.Game.Graphics.UserInterfaceV2
                             {
                                 LabelContainer = new Container
                                 {
-                                    CornerRadius = corner_radius,
+                                    Depth = float.MaxValue,
+                                    CornerRadius = ShearedButton.CORNER_RADIUS,
                                     Masking = true,
                                     AutoSizeAxes = Axes.Both,
                                     Children = new Drawable[]
@@ -165,9 +147,14 @@ namespace osu.Game.Graphics.UserInterfaceV2
                                         },
                                         labelText = new OsuSpriteText
                                         {
-                                            Margin = new MarginPadding { Horizontal = 10f, Vertical = 8f },
-                                            Font = OsuFont.Torus.With(size: 16.8f, weight: FontWeight.SemiBold),
-                                            Shear = -shear,
+                                            Margin = new MarginPadding
+                                            {
+                                                Horizontal = 10f,
+                                                // Chosen specifically so the height of these dropdowns matches ShearedToggleButton (30).
+                                                Vertical = 7f
+                                            },
+                                            Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
+                                            Shear = -OsuGame.SHEAR,
                                         },
                                     },
                                 },
@@ -178,7 +165,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
                                     RelativeSizeAxes = Axes.X,
                                     AutoSizeAxes = Axes.Y,
                                     Padding = new MarginPadding { Horizontal = 10f },
-                                    Shear = -shear,
+                                    Shear = -OsuGame.SHEAR,
                                     Children = new Drawable[]
                                     {
                                         valueText = new TruncatingSpriteText
@@ -186,7 +173,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
                                             Anchor = Anchor.CentreLeft,
                                             Origin = Anchor.CentreLeft,
                                             Padding = new MarginPadding { Right = 15f },
-                                            Font = OsuFont.Torus.With(size: 16.8f, weight: FontWeight.SemiBold),
+                                            Font = OsuFont.Style.Body,
                                             RelativeSizeAxes = Axes.X,
                                         },
                                         chevron = new SpriteIcon
@@ -203,8 +190,6 @@ namespace osu.Game.Graphics.UserInterfaceV2
                         }
                     },
                 };
-
-                AddInternal(LabelContainer.CreateProxy());
             }
 
             [BackgroundDependencyLoader]
@@ -229,7 +214,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
                 searchBar.Padding = new MarginPadding { Left = LabelContainer.DrawWidth };
 
                 // By limiting the width we avoid this box showing up as an outline around the drawables that are on top of it.
-                Background.Padding = new MarginPadding { Left = LabelContainer.DrawWidth - corner_radius };
+                Background.Padding = new MarginPadding { Left = LabelContainer.DrawWidth - ShearedButton.CORNER_RADIUS };
             }
 
             protected override bool OnHover(HoverEvent e)
@@ -286,12 +271,10 @@ namespace osu.Game.Graphics.UserInterfaceV2
 
                 private partial class DropdownSearchTextBox : OsuTextBox
                 {
-                    private readonly Vector2 shear = new Vector2(OsuGame.SHEAR, 0);
-
                     [BackgroundDependencyLoader]
                     private void load(OverlayColourProvider? colourProvider)
                     {
-                        TextContainer.Shear = -shear;
+                        TextContainer.Shear = -OsuGame.SHEAR;
                         BackgroundUnfocused = colourProvider?.Background5 ?? new Color4(10, 10, 10, 255);
                         BackgroundFocused = colourProvider?.Background5 ?? new Color4(10, 10, 10, 255);
                     }
diff --git a/osu.Game/Input/RealmKeyBindingStore.cs b/osu.Game/Input/RealmKeyBindingStore.cs
index 48ace58235..7209d3851b 100644
--- a/osu.Game/Input/RealmKeyBindingStore.cs
+++ b/osu.Game/Input/RealmKeyBindingStore.cs
@@ -5,8 +5,10 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Localisation;
 using osu.Game.Database;
 using osu.Game.Input.Bindings;
+using osu.Game.Localisation;
 using osu.Game.Rulesets;
 using Realms;
 
@@ -23,6 +25,19 @@ namespace osu.Game.Input
             this.keyCombinationProvider = keyCombinationProvider;
         }
 
+        /// <summary>
+        /// For a given <see cref="GlobalAction"/>, return a human-readable string representing the bindings bound to the action.
+        /// </summary>
+        public LocalisableString GetBindingsStringFor(GlobalAction globalAction)
+        {
+            var combinations = GetReadableKeyCombinationsFor(globalAction);
+
+            if (combinations.Count == 0)
+                return ToastStrings.NoKeyBound;
+
+            return string.Join(" / ", combinations);
+        }
+
         /// <summary>
         /// Retrieve all user-defined key combinations (in a format that can be displayed) for a specific action.
         /// </summary>
diff --git a/osu.Game/Localisation/AudioSettingsStrings.cs b/osu.Game/Localisation/AudioSettingsStrings.cs
index 89db60d8a6..5c9e207f84 100644
--- a/osu.Game/Localisation/AudioSettingsStrings.cs
+++ b/osu.Game/Localisation/AudioSettingsStrings.cs
@@ -69,6 +69,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString SuggestedOffsetNote => new TranslatableString(getKey(@"suggested_offset_note"), @"Play a few beatmaps to receive a suggested offset!");
 
+        /// <summary>
+        /// "Based on the last {0} play(s), your offset is set correctly!"
+        /// </summary>
+        public static LocalisableString SuggestedOffsetCorrect(int plays) => new TranslatableString(getKey(@"suggested_offset_correct"), @"Based on the last {0} play(s), your offset is set correctly!", plays);
+
         /// <summary>
         /// "Based on the last {0} play(s), the suggested offset is {1} ms."
         /// </summary>
diff --git a/osu.Game/Localisation/ChatStrings.cs b/osu.Game/Localisation/ChatStrings.cs
index 6841e7d938..b14cfd6729 100644
--- a/osu.Game/Localisation/ChatStrings.cs
+++ b/osu.Game/Localisation/ChatStrings.cs
@@ -25,9 +25,9 @@ namespace osu.Game.Localisation
         public static LocalisableString MentionUser => new TranslatableString(getKey(@"mention_user"), @"Mention");
 
         /// <summary>
-        /// "press enter to chat..."
+        /// "press {0} to chat..."
         /// </summary>
-        public static LocalisableString InGameInputPlaceholder => new TranslatableString(getKey(@"in_game_input_placeholder"), @"press enter to chat...");
+        public static LocalisableString InGameInputPlaceholder(LocalisableString keyBind) => new TranslatableString(getKey(@"in_game_input_placeholder"), @"press {0} to chat...", keyBind);
 
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
diff --git a/osu.Game/Localisation/DrawableRoomPlaylistItemStrings.cs b/osu.Game/Localisation/DrawableRoomPlaylistItemStrings.cs
new file mode 100644
index 0000000000..44616c03ca
--- /dev/null
+++ b/osu.Game/Localisation/DrawableRoomPlaylistItemStrings.cs
@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Localisation;
+
+namespace osu.Game.Localisation
+{
+    public static class DrawableRoomPlaylistItemStrings
+    {
+        private const string prefix = @"osu.Game.Resources.Localisation.DrawableRoomPlaylistItem";
+
+        /// <summary>
+        /// "You have completed this beatmap"
+        /// </summary>
+        public static LocalisableString CompletedTooltip => new TranslatableString(getKey(@"completed_tooltip"), @"You have completed this beatmap");
+
+        private static string getKey(string key) => $@"{prefix}:{key}";
+    }
+}
diff --git a/osu.Game/Online/API/Requests/GetScoresRequest.cs b/osu.Game/Online/API/Requests/GetScoresRequest.cs
index f2a2daccb5..ed26c77dd9 100644
--- a/osu.Game/Online/API/Requests/GetScoresRequest.cs
+++ b/osu.Game/Online/API/Requests/GetScoresRequest.cs
@@ -36,7 +36,7 @@ namespace osu.Game.Online.API.Requests
             this.mods = mods ?? Array.Empty<IMod>();
         }
 
-        protected override string Target => $@"beatmaps/{beatmapInfo.OnlineID}/solo-scores{createQueryParameters()}";
+        protected override string Target => $@"beatmaps/{beatmapInfo.OnlineID}/scores{createQueryParameters()}";
 
         private string createQueryParameters()
         {
diff --git a/osu.Game/Online/API/Requests/Responses/APIBeatmap.cs b/osu.Game/Online/API/Requests/Responses/APIBeatmap.cs
index 055d2dd8e2..20494a1cbf 100644
--- a/osu.Game/Online/API/Requests/Responses/APIBeatmap.cs
+++ b/osu.Game/Online/API/Requests/Responses/APIBeatmap.cs
@@ -32,6 +32,9 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"playcount")]
         public int PlayCount { get; set; }
 
+        [JsonProperty(@"current_user_playcount")]
+        public int UserPlayCount { get; set; }
+
         [JsonProperty(@"passcount")]
         public int PassCount { get; set; }
 
diff --git a/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs b/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
index d98715a42d..c6cf0f735f 100644
--- a/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
+++ b/osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
@@ -128,6 +128,9 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"converts")]
         public APIBeatmap[]? Converts { get; set; }
 
+        [JsonProperty(@"related_tags")]
+        public APITag[]? RelatedTags { get; set; }
+
         private BeatmapMetadata metadata => new BeatmapMetadata
         {
             Title = Title,
diff --git a/osu.Game/Online/API/Requests/Responses/APITag.cs b/osu.Game/Online/API/Requests/Responses/APITag.cs
index 4dd18663af..b0454fdb1d 100644
--- a/osu.Game/Online/API/Requests/Responses/APITag.cs
+++ b/osu.Game/Online/API/Requests/Responses/APITag.cs
@@ -15,5 +15,8 @@ namespace osu.Game.Online.API.Requests.Responses
 
         [JsonProperty("description")]
         public string Description { get; set; } = string.Empty;
+
+        [JsonProperty("ruleset_id")]
+        public int? RulesetId { get; set; }
     }
 }
diff --git a/osu.Game/Online/Chat/MessageNotifier.cs b/osu.Game/Online/Chat/MessageNotifier.cs
index 56f490cb21..49304c93a3 100644
--- a/osu.Game/Online/Chat/MessageNotifier.cs
+++ b/osu.Game/Online/Chat/MessageNotifier.cs
@@ -37,6 +37,9 @@ namespace osu.Game.Online.Chat
         [Resolved]
         private ChannelManager channelManager { get; set; }
 
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
         [Resolved]
         private GameHost host { get; set; }
 
@@ -47,19 +50,19 @@ namespace osu.Game.Online.Chat
         private readonly IBindableList<Channel> joinedChannels = new BindableList<Channel>();
 
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config, IAPIProvider api)
+        private void load(OsuConfigManager config)
         {
             notifyOnUsername = config.GetBindable<bool>(OsuSetting.NotifyOnUsernameMentioned);
             notifyOnPrivateMessage = config.GetBindable<bool>(OsuSetting.NotifyOnPrivateMessage);
-
-            localUser.BindTo(api.LocalUser);
-            joinedChannels.BindTo(channelManager.JoinedChannels);
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
             joinedChannels.BindCollectionChanged(channelsChanged, true);
+
+            localUser.BindTo(api.LocalUser);
+            joinedChannels.BindTo(channelManager.JoinedChannels);
         }
 
         private void channelsChanged(object sender, NotifyCollectionChangedEventArgs e)
diff --git a/osu.Game/Online/Leaderboards/LeaderboardManager.cs b/osu.Game/Online/Leaderboards/LeaderboardManager.cs
new file mode 100644
index 0000000000..cd77a28893
--- /dev/null
+++ b/osu.Game/Online/Leaderboards/LeaderboardManager.cs
@@ -0,0 +1,215 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Extensions;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Scoring;
+using osu.Game.Screens.Select.Leaderboards;
+using Realms;
+
+namespace osu.Game.Online.Leaderboards
+{
+    public partial class LeaderboardManager : Component
+    {
+        public IBindable<LeaderboardScores?> Scores => scores;
+        private readonly Bindable<LeaderboardScores?> scores = new Bindable<LeaderboardScores?>();
+
+        public LeaderboardCriteria? CurrentCriteria { get; private set; }
+
+        private IDisposable? localScoreSubscription;
+        private TaskCompletionSource<LeaderboardScores?>? localFetchCompletionSource;
+        private TaskCompletionSource<LeaderboardScores?>? lastFetchCompletionSource;
+        private GetScoresRequest? inFlightOnlineRequest;
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
+        public Task<LeaderboardScores?> FetchWithCriteriaAsync(LeaderboardCriteria newCriteria)
+        {
+            if (CurrentCriteria?.Equals(newCriteria) == true && lastFetchCompletionSource?.Task.IsFaulted == false)
+                return lastFetchCompletionSource?.Task ?? Task.FromResult(Scores.Value);
+
+            CurrentCriteria = newCriteria;
+            localScoreSubscription?.Dispose();
+            inFlightOnlineRequest?.Cancel();
+            lastFetchCompletionSource?.TrySetCanceled();
+            scores.Value = null;
+
+            if (newCriteria.Beatmap == null || newCriteria.Ruleset == null)
+                return Task.FromResult<LeaderboardScores?>(scores.Value = LeaderboardScores.Failure(LeaderboardFailState.NoneSelected));
+
+            switch (newCriteria.Scope)
+            {
+                case BeatmapLeaderboardScope.Local:
+                {
+                    // this task completion source will be marked completed in the `localScoresChanged()` below.
+                    // yes it's twisty, but such are the costs of trying to reconcile data-push / subscription and data-pull / explicit fetch flows.
+                    lastFetchCompletionSource = localFetchCompletionSource = new TaskCompletionSource<LeaderboardScores?>();
+                    localScoreSubscription = realm.RegisterForNotifications(r =>
+                        r.All<ScoreInfo>().Filter($"{nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $0"
+                                                  + $" AND {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
+                                                  + $" AND {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $1"
+                                                  + $" AND {nameof(ScoreInfo.DeletePending)} == false"
+                            , newCriteria.Beatmap.ID, newCriteria.Ruleset.ShortName), localScoresChanged);
+                    return localFetchCompletionSource.Task;
+                }
+
+                default:
+                {
+                    if (!api.IsLoggedIn)
+                        return Task.FromResult<LeaderboardScores?>(scores.Value = LeaderboardScores.Failure(LeaderboardFailState.NotLoggedIn));
+
+                    if (!newCriteria.Ruleset.IsLegacyRuleset())
+                        return Task.FromResult<LeaderboardScores?>(scores.Value = LeaderboardScores.Failure(LeaderboardFailState.RulesetUnavailable));
+
+                    if (newCriteria.Beatmap.OnlineID <= 0 || newCriteria.Beatmap.Status <= BeatmapOnlineStatus.Pending)
+                        return Task.FromResult<LeaderboardScores?>(scores.Value = LeaderboardScores.Failure(LeaderboardFailState.BeatmapUnavailable));
+
+                    if ((newCriteria.Scope.RequiresSupporter(newCriteria.ExactMods != null)) && !api.LocalUser.Value.IsSupporter)
+                        return Task.FromResult<LeaderboardScores?>(scores.Value = LeaderboardScores.Failure(LeaderboardFailState.NotSupporter));
+
+                    if (newCriteria.Scope == BeatmapLeaderboardScope.Team && api.LocalUser.Value.Team == null)
+                        return Task.FromResult<LeaderboardScores?>(scores.Value = LeaderboardScores.Failure(LeaderboardFailState.NoTeam));
+
+                    var onlineFetchCompletionSource = new TaskCompletionSource<LeaderboardScores?>();
+                    lastFetchCompletionSource = onlineFetchCompletionSource;
+
+                    IReadOnlyList<Mod>? requestMods = null;
+
+                    if (newCriteria.ExactMods != null)
+                    {
+                        if (!newCriteria.ExactMods.Any())
+                            // add nomod for the request
+                            requestMods = new Mod[] { new ModNoMod() };
+                        else
+                            requestMods = newCriteria.ExactMods;
+                    }
+
+                    var newRequest = new GetScoresRequest(newCriteria.Beatmap, newCriteria.Ruleset, newCriteria.Scope, requestMods);
+                    newRequest.Success += response =>
+                    {
+                        if (inFlightOnlineRequest != null && !newRequest.Equals(inFlightOnlineRequest))
+                            return;
+
+                        var result = LeaderboardScores.Success
+                        (
+                            response.Scores.Select(s => s.ToScoreInfo(rulesets, newCriteria.Beatmap)).OrderByTotalScore().ToArray(),
+                            response.UserScore?.CreateScoreInfo(rulesets, newCriteria.Beatmap)
+                        );
+                        inFlightOnlineRequest = null;
+                        if (onlineFetchCompletionSource.TrySetResult(result))
+                            scores.Value = result;
+                    };
+                    newRequest.Failure += _ => onlineFetchCompletionSource.TrySetResult(LeaderboardScores.Failure(LeaderboardFailState.NetworkFailure));
+                    api.Queue(inFlightOnlineRequest = newRequest);
+                    return onlineFetchCompletionSource.Task;
+                }
+            }
+        }
+
+        private void localScoresChanged(IRealmCollection<ScoreInfo> sender, ChangeSet? changes)
+        {
+            Debug.Assert(CurrentCriteria != null);
+
+            // This subscription may fire from changes to linked beatmaps, which we don't care about.
+            // It's currently not possible for a score to be modified after insertion, so we can safely ignore callbacks with only modifications.
+            if (changes?.HasCollectionChanges() == false)
+                return;
+
+            var newScores = sender.AsEnumerable();
+
+            if (CurrentCriteria.ExactMods != null)
+            {
+                if (!CurrentCriteria.ExactMods.Any())
+                {
+                    // we need to filter out all scores that have any mods to get all local nomod scores
+                    newScores = newScores.Where(s => !s.Mods.Any());
+                }
+                else
+                {
+                    // otherwise find all the scores that have all of the currently selected mods (similar to how web applies mod filters)
+                    // we're creating and using a string HashSet representation of selected mods so that it can be translated into the DB query itself
+                    var selectedMods = CurrentCriteria.ExactMods.Select(m => m.Acronym).ToHashSet();
+
+                    newScores = newScores.Where(s => selectedMods.SetEquals(s.Mods.Select(m => m.Acronym)));
+                }
+            }
+
+            newScores = newScores.Detach().OrderByTotalScore();
+
+            scores.Value = LeaderboardScores.Success(newScores.ToArray(), null);
+
+            if (localFetchCompletionSource != null && localFetchCompletionSource == lastFetchCompletionSource)
+            {
+                localFetchCompletionSource.SetResult(scores.Value);
+                localFetchCompletionSource = lastFetchCompletionSource = null;
+            }
+        }
+    }
+
+    public record LeaderboardCriteria(
+        BeatmapInfo? Beatmap,
+        RulesetInfo? Ruleset,
+        BeatmapLeaderboardScope Scope,
+        Mod[]? ExactMods
+    );
+
+    public record LeaderboardScores
+    {
+        public ICollection<ScoreInfo> TopScores { get; }
+        public ScoreInfo? UserScore { get; }
+        public LeaderboardFailState? FailState { get; }
+
+        public IEnumerable<ScoreInfo> AllScores
+        {
+            get
+            {
+                foreach (var score in TopScores)
+                    yield return score;
+
+                if (UserScore != null && TopScores.All(topScore => !topScore.Equals(UserScore) && !topScore.MatchesOnlineID(UserScore)))
+                    yield return UserScore;
+            }
+        }
+
+        private LeaderboardScores(ICollection<ScoreInfo> topScores, ScoreInfo? userScore, LeaderboardFailState? failState)
+        {
+            TopScores = topScores;
+            UserScore = userScore;
+            FailState = failState;
+        }
+
+        public static LeaderboardScores Success(ICollection<ScoreInfo> topScores, ScoreInfo? userScore) => new LeaderboardScores(topScores, userScore, null);
+        public static LeaderboardScores Failure(LeaderboardFailState failState) => new LeaderboardScores([], null, failState);
+    }
+
+    public enum LeaderboardFailState
+    {
+        NetworkFailure = -1,
+        BeatmapUnavailable = -2,
+        RulesetUnavailable = -3,
+        NoneSelected = -4,
+        NotLoggedIn = -5,
+        NotSupporter = -6,
+        NoTeam = -7
+    }
+}
diff --git a/osu.Game/Online/Leaderboards/LeaderboardState.cs b/osu.Game/Online/Leaderboards/LeaderboardState.cs
index dbd982acf2..b0b45ef04e 100644
--- a/osu.Game/Online/Leaderboards/LeaderboardState.cs
+++ b/osu.Game/Online/Leaderboards/LeaderboardState.cs
@@ -7,13 +7,14 @@ namespace osu.Game.Online.Leaderboards
     {
         Success,
         Retrieving,
-        NetworkFailure,
-        BeatmapUnavailable,
-        RulesetUnavailable,
-        NoneSelected,
         NoScores,
-        NotLoggedIn,
-        NotSupporter,
-        NoTeam
+
+        NetworkFailure = LeaderboardFailState.NetworkFailure,
+        BeatmapUnavailable = LeaderboardFailState.BeatmapUnavailable,
+        RulesetUnavailable = LeaderboardFailState.RulesetUnavailable,
+        NoneSelected = LeaderboardFailState.NoneSelected,
+        NotLoggedIn = LeaderboardFailState.NotLoggedIn,
+        NotSupporter = LeaderboardFailState.NotSupporter,
+        NoTeam = LeaderboardFailState.NoTeam,
     }
 }
diff --git a/osu.Game/Online/Multiplayer/MultiplayerClient.cs b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
index 57aaf68853..92fc8a3dcf 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerClient.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
@@ -36,6 +36,21 @@ namespace osu.Game.Online.Multiplayer
         /// </summary>
         public virtual event Action? RoomUpdated;
 
+        /// <summary>
+        /// Invoked when a user's local style is changed.
+        /// </summary>
+        public event Action<MultiplayerRoomUser>? UserStyleChanged;
+
+        /// <summary>
+        /// Invoked when a user's local mods are changed.
+        /// </summary>
+        public event Action<MultiplayerRoomUser>? UserModsChanged;
+
+        /// <summary>
+        /// Invoked when the room's settings are changed.
+        /// </summary>
+        public event Action<MultiplayerRoomSettings>? SettingsChanged;
+
         /// <summary>
         /// Invoked when a new user joins the room.
         /// </summary>
@@ -710,7 +725,7 @@ namespace osu.Game.Online.Multiplayer
             return Task.CompletedTask;
         }
 
-        public Task UserStyleChanged(int userId, int? beatmapId, int? rulesetId)
+        Task IMultiplayerClient.UserStyleChanged(int userId, int? beatmapId, int? rulesetId)
         {
             Scheduler.Add(() =>
             {
@@ -723,13 +738,14 @@ namespace osu.Game.Online.Multiplayer
                 user.BeatmapId = beatmapId;
                 user.RulesetId = rulesetId;
 
+                UserStyleChanged?.Invoke(user);
                 RoomUpdated?.Invoke();
             }, false);
 
             return Task.CompletedTask;
         }
 
-        public Task UserModsChanged(int userId, IEnumerable<APIMod> mods)
+        Task IMultiplayerClient.UserModsChanged(int userId, IEnumerable<APIMod> mods)
         {
             Scheduler.Add(() =>
             {
@@ -741,6 +757,7 @@ namespace osu.Game.Online.Multiplayer
 
                 user.Mods = mods;
 
+                UserModsChanged?.Invoke(user);
                 RoomUpdated?.Invoke();
             }, false);
 
@@ -907,6 +924,7 @@ namespace osu.Game.Online.Multiplayer
             APIRoom.CurrentPlaylistItem = APIRoom.Playlist.Single(item => item.ID == settings.PlaylistItemId);
             APIRoom.AutoSkip = Room.Settings.AutoSkip;
 
+            SettingsChanged?.Invoke(settings);
             RoomUpdated?.Invoke();
         }
 
diff --git a/osu.Game/Online/Multiplayer/MultiplayerRoom.cs b/osu.Game/Online/Multiplayer/MultiplayerRoom.cs
index db1722af8c..3c02565fa1 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerRoom.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerRoom.cs
@@ -85,6 +85,7 @@ namespace osu.Game.Online.Multiplayer
         /// Retrieves the active <see cref="MultiplayerPlaylistItem"/> as determined by the room's current settings.
         /// </summary>
         [IgnoreMember]
+        [JsonIgnore]
         public MultiplayerPlaylistItem CurrentPlaylistItem => Playlist.Single(item => item.ID == Settings.PlaylistItemId);
 
         /// <summary>
diff --git a/osu.Game/Online/Rooms/ItemAttemptsCount.cs b/osu.Game/Online/Rooms/ItemAttemptsCount.cs
index dc86897660..9ea2235500 100644
--- a/osu.Game/Online/Rooms/ItemAttemptsCount.cs
+++ b/osu.Game/Online/Rooms/ItemAttemptsCount.cs
@@ -10,10 +10,22 @@ namespace osu.Game.Online.Rooms
     /// </summary>
     public class ItemAttemptsCount
     {
+        /// <summary>
+        /// The playlist item this object describes.
+        /// </summary>
         [JsonProperty("id")]
         public int PlaylistItemID { get; set; }
 
+        /// <summary>
+        /// The number of times the user attempted the playlist item.
+        /// </summary>
         [JsonProperty("attempts")]
         public int Attempts { get; set; }
+
+        /// <summary>
+        /// Whether the user has a passing score on the playlist item.
+        /// </summary>
+        [JsonProperty("passed")]
+        public bool Passed { get; set; }
     }
 }
diff --git a/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs b/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
index 3234e28166..f58a67294e 100644
--- a/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
+++ b/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
@@ -62,11 +62,20 @@ namespace osu.Game.Online.Rooms
         [Key(11)]
         public bool Freestyle { get; set; }
 
+        /// <summary>
+        /// Creates a new <see cref="MultiplayerPlaylistItem"/>.
+        /// </summary>
         [SerializationConstructor]
         public MultiplayerPlaylistItem()
         {
         }
 
+        /// <summary>
+        /// Creates a new <see cref="MultiplayerPlaylistItem"/> from an API <see cref="PlaylistItem"/>.
+        /// </summary>
+        /// <remarks>
+        /// This will create unique instances of the <see cref="RequiredMods"/> and <see cref="AllowedMods"/> arrays but NOT unique instances of the contained <see cref="APIMod"/>s.
+        /// </remarks>
         public MultiplayerPlaylistItem(PlaylistItem item)
         {
             ID = item.ID;
@@ -82,5 +91,19 @@ namespace osu.Game.Online.Rooms
             StarRating = item.Beatmap.StarRating;
             Freestyle = item.Freestyle;
         }
+
+        /// <summary>
+        /// Creates a copy of this <see cref="MultiplayerPlaylistItem"/>.
+        /// </summary>
+        /// <remarks>
+        /// This will create unique instances of the <see cref="RequiredMods"/> and <see cref="AllowedMods"/> arrays but NOT unique instances of the contained <see cref="APIMod"/>s.
+        /// </remarks>
+        public MultiplayerPlaylistItem Clone()
+        {
+            MultiplayerPlaylistItem clone = (MultiplayerPlaylistItem)MemberwiseClone();
+            clone.RequiredMods = RequiredMods.ToArray();
+            clone.AllowedMods = AllowedMods.ToArray();
+            return clone;
+        }
     }
 }
diff --git a/osu.Game/Online/Rooms/PlaylistItem.cs b/osu.Game/Online/Rooms/PlaylistItem.cs
index 817b42f503..8ba62fd0e2 100644
--- a/osu.Game/Online/Rooms/PlaylistItem.cs
+++ b/osu.Game/Online/Rooms/PlaylistItem.cs
@@ -85,6 +85,11 @@ namespace osu.Game.Online.Rooms
 
         private readonly Bindable<bool> valid = new BindableBool(true);
 
+        [JsonIgnore]
+        public IBindable<bool> Completed => completed;
+
+        private readonly Bindable<bool> completed = new BindableBool(false);
+
         [JsonConstructor]
         private PlaylistItem()
             : this(new APIBeatmap())
@@ -96,8 +101,14 @@ namespace osu.Game.Online.Rooms
             Beatmap = beatmap;
         }
 
+        /// <summary>
+        /// Creates a new <see cref="PlaylistItem"/> from a <see cref="MultiplayerPlaylistItem"/>.
+        /// </summary>
+        /// <remarks>
+        /// This will create unique instances of the <see cref="RequiredMods"/> and <see cref="AllowedMods"/> arrays but NOT unique instances of the contained <see cref="APIMod"/>s.
+        /// </remarks>
         public PlaylistItem(MultiplayerPlaylistItem item)
-            : this(new APIBeatmap { OnlineID = item.BeatmapID, StarRating = item.StarRating })
+            : this(new APIBeatmap { OnlineID = item.BeatmapID, StarRating = item.StarRating, Checksum = item.BeatmapChecksum })
         {
             ID = item.ID;
             OwnerID = item.OwnerID;
@@ -112,6 +123,8 @@ namespace osu.Game.Online.Rooms
 
         public void MarkInvalid() => valid.Value = false;
 
+        public void MarkCompleted() => completed.Value = true;
+
         #region Newtonsoft.Json implicit ShouldSerialize() methods
 
         // The properties in this region are used implicitly by Newtonsoft.Json to not serialise certain fields in some cases.
diff --git a/osu.Game/OsuGame.cs b/osu.Game/OsuGame.cs
index 3381553970..0c6a06a8fc 100644
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@@ -47,6 +47,7 @@ using osu.Game.IO;
 using osu.Game.Localisation;
 using osu.Game.Online;
 using osu.Game.Online.Chat;
+using osu.Game.Online.Leaderboards;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Overlays.BeatmapListing;
@@ -67,6 +68,7 @@ using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Seasonal;
 using osu.Game.Skinning;
 using osu.Game.Updater;
@@ -100,7 +102,12 @@ namespace osu.Game
         /// <summary>
         /// A common shear factor applied to most components of the game.
         /// </summary>
-        public const float SHEAR = 0.2f;
+        public static readonly Vector2 SHEAR = new Vector2(0.2f, 0);
+
+        /// <summary>
+        /// For elements placed close to the screen edge, this is the margin to leave to the edge.
+        /// </summary>
+        public const float SCREEN_EDGE_MARGIN = 12f;
 
         public Toolbar Toolbar { get; private set; }
 
@@ -784,6 +791,24 @@ namespace osu.Game
                 if (!Beatmap.Value.BeatmapInfo.Equals(databasedBeatmap))
                     Beatmap.Value = BeatmapManager.GetWorkingBeatmap(databasedBeatmap);
 
+                var currentLeaderboard = LeaderboardManager.CurrentCriteria;
+
+                bool leaderboardBeatmapMatches = currentLeaderboard != null && databasedBeatmap.Equals(currentLeaderboard.Beatmap);
+                bool leaderboardRulesetMatches = currentLeaderboard != null && databasedScore.ScoreInfo.Ruleset.Equals(currentLeaderboard.Ruleset);
+
+                if (!leaderboardBeatmapMatches || !leaderboardRulesetMatches)
+                {
+                    var newLeaderboard = currentLeaderboard != null
+                        ? currentLeaderboard with { Beatmap = databasedBeatmap, Ruleset = databasedScore.ScoreInfo.Ruleset }
+                        : new LeaderboardCriteria(databasedBeatmap, databasedScore.ScoreInfo.Ruleset, BeatmapLeaderboardScope.Global, null);
+                    LeaderboardManager.FetchWithCriteriaAsync(newLeaderboard)
+                                      .ContinueWith(t =>
+                                      {
+                                          if (t.Exception != null)
+                                              Logger.Log($@"Failed to fetch leaderboards when displaying results: {t.Exception}", LoggingTarget.Network);
+                                      });
+                }
+
                 switch (presentType)
                 {
                     case ScorePresentType.Gameplay:
@@ -977,20 +1002,6 @@ namespace osu.Game
             MultiplayerClient.PostNotification = n => Notifications.Post(n);
             MultiplayerClient.PresentMatch = PresentMultiplayerMatch;
 
-            // make config aware of how to lookup skins for on-screen display purposes.
-            // if this becomes a more common thing, tracked settings should be reconsidered to allow local DI.
-            LocalConfig.LookupSkinName = id => SkinManager.Query(s => s.ID == id)?.ToString() ?? "Unknown";
-
-            LocalConfig.LookupKeyBindings = l =>
-            {
-                var combinations = KeyBindingStore.GetReadableKeyCombinationsFor(l);
-
-                if (combinations.Count == 0)
-                    return ToastStrings.NoKeyBound;
-
-                return string.Join(" / ", combinations);
-            };
-
             ScreenFooter.BackReceptor backReceptor;
 
             dependencies.CacheAs(idleTracker = new GameIdleTracker(6000));
diff --git a/osu.Game/OsuGameBase.cs b/osu.Game/OsuGameBase.cs
index 4087a8b71e..4cc9ab7936 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -49,6 +49,7 @@ using osu.Game.Localisation;
 using osu.Game.Online;
 using osu.Game.Online.API;
 using osu.Game.Online.Chat;
+using osu.Game.Online.Leaderboards;
 using osu.Game.Online.Metadata;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Spectator;
@@ -203,6 +204,7 @@ namespace osu.Game
 
         private UserLookupCache userCache;
         private BeatmapLookupCache beatmapCache;
+        protected LeaderboardManager LeaderboardManager { get; private set; }
 
         private RulesetConfigCache rulesetConfigCache;
 
@@ -365,6 +367,9 @@ namespace osu.Game
             dependencies.CacheAs<IBindable<WorkingBeatmap>>(Beatmap);
             dependencies.CacheAs(Beatmap);
 
+            dependencies.Cache(LeaderboardManager = new LeaderboardManager());
+            base.Content.Add(LeaderboardManager);
+
             // add api components to hierarchy.
             if (API is APIAccess apiAccess)
                 base.Content.Add(apiAccess);
@@ -421,6 +426,11 @@ namespace osu.Game
 
             Ruleset.BindValueChanged(onRulesetChanged);
             Beatmap.BindValueChanged(onBeatmapChanged);
+
+            // make config aware of how to lookup skins for on-screen display purposes.
+            // if this becomes a more common thing, tracked settings should be reconsidered to allow local DI.
+            LocalConfig.LookupSkinName = id => SkinManager.Query(s => s.ID == id)?.ToString() ?? "Unknown";
+            LocalConfig.LookupKeyBindings = l => KeyBindingStore.GetBindingsStringFor(l);
         }
 
         private void updateLanguage() => CurrentLanguage.Value = LanguageExtensions.GetLanguageFor(frameworkLocale.Value, localisationParameters.Value);
diff --git a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
index c72c2a6698..9b10f6156d 100644
--- a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
+++ b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
@@ -177,7 +177,6 @@ namespace osu.Game.Overlays.BeatmapSet
                         {
                             onlineStatusPill = new BeatmapSetOnlineStatusPill
                             {
-                                AutoSizeAxes = Axes.Both,
                                 Anchor = Anchor.TopRight,
                                 Origin = Anchor.TopRight,
                                 TextSize = 14,
diff --git a/osu.Game/Overlays/BeatmapSet/Info.cs b/osu.Game/Overlays/BeatmapSet/Info.cs
index d21b2546b9..96e6622507 100644
--- a/osu.Game/Overlays/BeatmapSet/Info.cs
+++ b/osu.Game/Overlays/BeatmapSet/Info.cs
@@ -2,14 +2,15 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.Containers;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.BeatmapListing;
 
@@ -17,29 +18,24 @@ namespace osu.Game.Overlays.BeatmapSet
 {
     public partial class Info : Container
     {
-        private const float metadata_width = 175;
+        private const float metadata_width = 185;
         private const float spacing = 20;
-        private const float base_height = 220;
+        private const float base_height = 300;
 
         private readonly Box successRateBackground;
         private readonly Box background;
-        private readonly SuccessRate successRate;
+        private readonly MetadataSection<string[]?> userTags;
 
         public readonly Bindable<APIBeatmapSet> BeatmapSet = new Bindable<APIBeatmapSet>();
-
-        public APIBeatmap? BeatmapInfo
-        {
-            get => successRate.Beatmap;
-            set => successRate.Beatmap = value;
-        }
+        public readonly Bindable<APIBeatmap> Beatmap = new Bindable<APIBeatmap>();
 
         public Info()
         {
+            SuccessRate successRate;
             MetadataSectionNominators nominators;
-            MetadataSection source, tags;
+            MetadataSection source, mapperTags;
             MetadataSectionGenre genre;
             MetadataSectionLanguage language;
-            OsuSpriteText notRankedPlaceholder;
 
             RelativeSizeAxes = Axes.X;
             Height = base_height;
@@ -66,27 +62,30 @@ namespace osu.Game.Overlays.BeatmapSet
                                 Child = new MetadataSectionDescription(),
                             },
                         },
-                        new Container
+                        new OsuScrollContainer
                         {
                             Anchor = Anchor.TopRight,
                             Origin = Anchor.TopRight,
                             RelativeSizeAxes = Axes.Y,
                             Width = metadata_width,
-                            Padding = new MarginPadding { Horizontal = 10 },
+                            Padding = new MarginPadding { Left = 10 },
                             Margin = new MarginPadding { Right = BeatmapSetOverlay.RIGHT_WIDTH + spacing },
                             Masking = true,
+                            ScrollbarOverlapsContent = false,
                             Child = new FillFlowContainer
                             {
                                 RelativeSizeAxes = Axes.X,
                                 AutoSizeAxes = Axes.Y,
                                 Direction = FillDirection.Full,
+                                Padding = new MarginPadding { Right = 5 },
                                 Children = new Drawable[]
                                 {
                                     nominators = new MetadataSectionNominators(),
                                     source = new MetadataSectionSource(),
                                     genre = new MetadataSectionGenre { Width = 0.5f },
                                     language = new MetadataSectionLanguage { Width = 0.5f },
-                                    tags = new MetadataSectionTags(),
+                                    userTags = new MetadataSectionUserTags(),
+                                    mapperTags = new MetadataSectionMapperTags(),
                                 },
                             },
                         },
@@ -107,32 +106,45 @@ namespace osu.Game.Overlays.BeatmapSet
                                     RelativeSizeAxes = Axes.Both,
                                     Padding = new MarginPadding { Top = 20, Horizontal = 15 },
                                 },
-                                notRankedPlaceholder = new OsuSpriteText
-                                {
-                                    Anchor = Anchor.Centre,
-                                    Origin = Anchor.Centre,
-                                    Alpha = 0,
-                                    Text = "This beatmap is not ranked",
-                                    Font = OsuFont.GetFont(size: 12)
-                                },
                             },
                         },
                     },
                 },
             };
 
-            BeatmapSet.ValueChanged += b =>
+            BeatmapSet.BindValueChanged(b =>
             {
                 nominators.Metadata = (b.NewValue?.CurrentNominations ?? Array.Empty<BeatmapSetOnlineNomination>(), b.NewValue?.RelatedUsers ?? Array.Empty<APIUser>());
                 source.Metadata = b.NewValue?.Source ?? string.Empty;
-                tags.Metadata = b.NewValue?.Tags ?? string.Empty;
+                mapperTags.Metadata = b.NewValue?.Tags ?? string.Empty;
+                updateUserTags();
                 genre.Metadata = b.NewValue?.Genre ?? new BeatmapSetOnlineGenre { Id = (int)SearchGenre.Unspecified };
                 language.Metadata = b.NewValue?.Language ?? new BeatmapSetOnlineLanguage { Id = (int)SearchLanguage.Unspecified };
-                bool setHasLeaderboard = b.NewValue?.Status > 0;
-                successRate.Alpha = setHasLeaderboard ? 1 : 0;
-                notRankedPlaceholder.Alpha = setHasLeaderboard ? 0 : 1;
-                Height = setHasLeaderboard ? 270 : base_height;
-            };
+            });
+            Beatmap.BindValueChanged(b =>
+            {
+                successRate.Beatmap = b.NewValue;
+                updateUserTags();
+            });
+        }
+
+        private void updateUserTags()
+        {
+            if (Beatmap.Value?.TopTags == null || Beatmap.Value.TopTags.Length == 0 || BeatmapSet.Value?.RelatedTags == null)
+            {
+                userTags.Metadata = null;
+                return;
+            }
+
+            var tagsById = BeatmapSet.Value.RelatedTags.ToDictionary(t => t.Id);
+            userTags.Metadata = Beatmap.Value.TopTags
+                                       .Select(t => (topTag: t, relatedTag: tagsById.GetValueOrDefault(t.TagId)))
+                                       .Where(t => t.relatedTag != null)
+                                       // see https://github.com/ppy/osu-web/blob/bb3bd2e7c6f84f26066df5ea20a81c77ec9bb60a/resources/js/beatmapsets-show/controller.ts#L103-L106 for sort criteria
+                                       .OrderByDescending(t => t.topTag.VoteCount)
+                                       .ThenBy(t => t.relatedTag!.Name)
+                                       .Select(t => t.relatedTag!.Name)
+                                       .ToArray();
         }
 
         [BackgroundDependencyLoader]
diff --git a/osu.Game/Overlays/BeatmapSet/MetadataSectionTags.cs b/osu.Game/Overlays/BeatmapSet/MetadataSectionMapperTags.cs
similarity index 80%
rename from osu.Game/Overlays/BeatmapSet/MetadataSectionTags.cs
rename to osu.Game/Overlays/BeatmapSet/MetadataSectionMapperTags.cs
index fc16ba19d8..47e839a84d 100644
--- a/osu.Game/Overlays/BeatmapSet/MetadataSectionTags.cs
+++ b/osu.Game/Overlays/BeatmapSet/MetadataSectionMapperTags.cs
@@ -7,10 +7,10 @@ using osu.Game.Online.Chat;
 
 namespace osu.Game.Overlays.BeatmapSet
 {
-    public partial class MetadataSectionTags : MetadataSection
+    public partial class MetadataSectionMapperTags : MetadataSection
     {
-        public MetadataSectionTags(Action<string>? searchAction = null)
-            : base(MetadataType.Tags, searchAction)
+        public MetadataSectionMapperTags(Action<string>? searchAction = null)
+            : base(MetadataType.MapperTags, searchAction)
         {
         }
 
diff --git a/osu.Game/Overlays/BeatmapSet/MetadataSectionUserTags.cs b/osu.Game/Overlays/BeatmapSet/MetadataSectionUserTags.cs
new file mode 100644
index 0000000000..3a9fe8d33f
--- /dev/null
+++ b/osu.Game/Overlays/BeatmapSet/MetadataSectionUserTags.cs
@@ -0,0 +1,39 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Graphics.Containers;
+using osu.Game.Online.Chat;
+
+namespace osu.Game.Overlays.BeatmapSet
+{
+    public partial class MetadataSectionUserTags : MetadataSection<string[]?>
+    {
+        private readonly Action<string>? searchAction;
+
+        public MetadataSectionUserTags(Action<string>? searchAction = null)
+            : base(MetadataType.UserTags, null)
+        {
+            this.searchAction = searchAction;
+        }
+
+        protected override void AddMetadata(string[]? tags, LinkFlowContainer loaded)
+        {
+            if (tags == null)
+                return;
+
+            for (int i = 0; i <= tags.Length - 1; i++)
+            {
+                string tag = tags[i];
+
+                if (searchAction != null)
+                    loaded.AddLink(tag, () => searchAction(tag));
+                else
+                    loaded.AddLink(tag, LinkAction.SearchBeatmapSet, $@"tag=""""{tag}""""");
+
+                if (i != tags.Length - 1)
+                    loaded.AddText(" ");
+            }
+        }
+    }
+}
diff --git a/osu.Game/Overlays/BeatmapSet/MetadataType.cs b/osu.Game/Overlays/BeatmapSet/MetadataType.cs
index c92cecc17e..dba6a63679 100644
--- a/osu.Game/Overlays/BeatmapSet/MetadataType.cs
+++ b/osu.Game/Overlays/BeatmapSet/MetadataType.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.ComponentModel;
 using osu.Framework.Localisation;
 using osu.Game.Resources.Localisation.Web;
 
@@ -8,8 +9,11 @@ namespace osu.Game.Overlays.BeatmapSet
 {
     public enum MetadataType
     {
-        [LocalisableDescription(typeof(BeatmapsetsStrings), nameof(BeatmapsetsStrings.ShowInfoTags))]
-        Tags,
+        [Description("User Tags")] // TODO: use translated string after osu-resources update
+        UserTags,
+
+        [Description("Mapper Tags")] // TODO: use translated string after osu-resources update
+        MapperTags,
 
         [LocalisableDescription(typeof(BeatmapsetsStrings), nameof(BeatmapsetsStrings.ShowInfoSource))]
         Source,
diff --git a/osu.Game/Overlays/BeatmapSetOverlay.cs b/osu.Game/Overlays/BeatmapSetOverlay.cs
index 8de21129d3..255e30038b 100644
--- a/osu.Game/Overlays/BeatmapSetOverlay.cs
+++ b/osu.Game/Overlays/BeatmapSetOverlay.cs
@@ -47,7 +47,10 @@ namespace osu.Game.Overlays
                 Spacing = new Vector2(0, 20),
                 Children = new Drawable[]
                 {
-                    info = new Info(),
+                    info = new Info
+                    {
+                        Beatmap = { BindTarget = Header.HeaderContent.Picker.Beatmap }
+                    },
                     new ScoresContainer
                     {
                         Beatmap = { BindTarget = Header.HeaderContent.Picker.Beatmap }
@@ -60,11 +63,7 @@ namespace osu.Game.Overlays
             info.BeatmapSet.BindTo(beatmapSet);
             comments.BeatmapSet.BindTo(beatmapSet);
 
-            Header.HeaderContent.Picker.Beatmap.ValueChanged += b =>
-            {
-                info.BeatmapInfo = b.NewValue;
-                ScrollFlow.ScrollToStart();
-            };
+            Header.HeaderContent.Picker.Beatmap.ValueChanged += b => ScrollFlow.ScrollToStart();
         }
 
         [BackgroundDependencyLoader]
diff --git a/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs b/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs
index 6107f130ec..3741852993 100644
--- a/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs
+++ b/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs
@@ -18,6 +18,7 @@ using osu.Game.Online.Chat;
 using osu.Game.Overlays.Chat.Listing;
 using osu.Game.Users.Drawables;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Overlays.Chat.ChannelList
 {
@@ -160,6 +161,17 @@ namespace osu.Game.Overlays.Chat.ChannelList
             };
         }
 
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            if (e.Button == MouseButton.Middle)
+            {
+                close?.TriggerClick();
+                return true;
+            }
+
+            return base.OnMouseDown(e);
+        }
+
         private ChannelListItemCloseButton? createCloseButton()
         {
             if (isSelector || !CanLeave)
diff --git a/osu.Game/Overlays/MarqueeContainer.cs b/osu.Game/Overlays/MarqueeContainer.cs
new file mode 100644
index 0000000000..1b0b59abe0
--- /dev/null
+++ b/osu.Game/Overlays/MarqueeContainer.cs
@@ -0,0 +1,125 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osuTK;
+
+namespace osu.Game.Overlays
+{
+    public partial class MarqueeContainer : CompositeDrawable
+    {
+        /// <summary>
+        /// Whether the marquee should be allowed to scroll the content if it overflows.
+        /// Note that upon changing the value of this, any existing scrolls will be terminated instantly.
+        /// </summary>
+        public bool AllowScrolling
+        {
+            get => allowScrolling;
+            set
+            {
+                allowScrolling = value;
+                ScheduleAfterChildren(updateScrolling);
+            }
+        }
+
+        private bool allowScrolling = true;
+
+        /// <summary>
+        /// Time in milliseconds before scrolling begins.
+        /// </summary>
+        public double InitialMoveDelay { get; set; } = 1000;
+
+        /// <summary>
+        /// The <see cref="Anchor"/> to anchor the content to if it does not overflow.
+        /// </summary>
+        public Anchor NonOverflowingContentAnchor { get; init; } = Anchor.TopLeft;
+
+        public Func<Drawable>? CreateContent
+        {
+            set
+            {
+                createContent = value;
+                if (IsLoaded)
+                    updateContent();
+            }
+        }
+
+        private Func<Drawable>? createContent;
+
+        private const float pixels_per_second = 50;
+        private const float padding = 15;
+
+        private Drawable mainContent = null!;
+        private Drawable fillerContent = null!;
+        private FillFlowContainer flow = null!;
+
+        public MarqueeContainer()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChild = flow = new FillFlowContainer
+            {
+                AutoSizeAxes = Axes.Both,
+                Direction = FillDirection.Horizontal,
+                Anchor = NonOverflowingContentAnchor,
+                Origin = NonOverflowingContentAnchor,
+                Spacing = new Vector2(padding),
+                Padding = new MarginPadding { Horizontal = padding },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            updateContent();
+        }
+
+        private void updateContent()
+        {
+            flow.Clear();
+
+            if (createContent == null)
+                return;
+
+            flow.Add(mainContent = createContent());
+            flow.Add(fillerContent = createContent().With(d => d.Alpha = 0));
+            ScheduleAfterChildren(updateScrolling);
+        }
+
+        private void updateScrolling()
+        {
+            float overflowWidth = mainContent.DrawWidth + padding - DrawWidth;
+
+            if (overflowWidth > 0 && AllowScrolling)
+            {
+                fillerContent.Alpha = 1;
+                flow.Anchor = Anchor.TopLeft;
+                flow.Origin = Anchor.TopLeft;
+
+                float targetX = mainContent.DrawWidth + padding;
+
+                flow.MoveToX(0)
+                    .Delay(InitialMoveDelay)
+                    .MoveToX(-targetX, targetX * 1000 / pixels_per_second)
+                    .Loop();
+            }
+            else
+            {
+                fillerContent.Alpha = 0;
+                flow.ClearTransforms();
+                flow.MoveToX(0, 300, Easing.OutQuint);
+                flow.Anchor = NonOverflowingContentAnchor;
+                flow.Origin = NonOverflowingContentAnchor;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs b/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
index dedd1e336e..3cefa07cfa 100644
--- a/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
+++ b/osu.Game/Overlays/Mods/BeatmapAttributesDisplay.cs
@@ -20,7 +20,6 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Utils;
-using osuTK;
 
 namespace osu.Game.Overlays.Mods
 {
@@ -66,21 +65,19 @@ namespace osu.Game.Overlays.Mods
         [BackgroundDependencyLoader]
         private void load()
         {
-            const float shear = OsuGame.SHEAR;
-
             LeftContent.AddRange(new Drawable[]
             {
                 starRatingDisplay = new StarRatingDisplay(default, animated: true)
                 {
                     Origin = Anchor.CentreLeft,
                     Anchor = Anchor.CentreLeft,
-                    Shear = new Vector2(-shear, 0),
+                    Shear = -OsuGame.SHEAR,
                 },
                 bpmDisplay = new BPMDisplay
                 {
                     Origin = Anchor.CentreLeft,
                     Anchor = Anchor.CentreLeft,
-                    Shear = new Vector2(-shear, 0),
+                    Shear = -OsuGame.SHEAR,
                     AutoSizeAxes = Axes.Y,
                     Width = 75,
                 }
@@ -89,10 +86,10 @@ namespace osu.Game.Overlays.Mods
             RightContent.Alpha = 0;
             RightContent.AddRange(new Drawable[]
             {
-                circleSizeDisplay = new VerticalAttributeDisplay("CS") { Shear = new Vector2(-shear, 0), },
-                drainRateDisplay = new VerticalAttributeDisplay("HP") { Shear = new Vector2(-shear, 0), },
-                overallDifficultyDisplay = new VerticalAttributeDisplay("OD") { Shear = new Vector2(-shear, 0), },
-                approachRateDisplay = new VerticalAttributeDisplay("AR") { Shear = new Vector2(-shear, 0), },
+                circleSizeDisplay = new VerticalAttributeDisplay("CS") { Shear = -OsuGame.SHEAR, },
+                drainRateDisplay = new VerticalAttributeDisplay("HP") { Shear = -OsuGame.SHEAR, },
+                overallDifficultyDisplay = new VerticalAttributeDisplay("OD") { Shear = -OsuGame.SHEAR, },
+                approachRateDisplay = new VerticalAttributeDisplay("AR") { Shear = -OsuGame.SHEAR, },
             });
         }
 
diff --git a/osu.Game/Overlays/Mods/ModColumn.cs b/osu.Game/Overlays/Mods/ModColumn.cs
index 326394a207..7d2ce54074 100644
--- a/osu.Game/Overlays/Mods/ModColumn.cs
+++ b/osu.Game/Overlays/Mods/ModColumn.cs
@@ -106,7 +106,7 @@ namespace osu.Game.Overlays.Mods
                     Origin = Anchor.CentreLeft,
                     Scale = new Vector2(0.8f),
                     RelativeSizeAxes = Axes.X,
-                    Shear = new Vector2(-OsuGame.SHEAR, 0)
+                    Shear = -OsuGame.SHEAR
                 });
                 ItemsFlow.Padding = new MarginPadding
                 {
diff --git a/osu.Game/Overlays/Mods/ModFooterInformationDisplay.cs b/osu.Game/Overlays/Mods/ModFooterInformationDisplay.cs
index 6665a3b8dc..db42200775 100644
--- a/osu.Game/Overlays/Mods/ModFooterInformationDisplay.cs
+++ b/osu.Game/Overlays/Mods/ModFooterInformationDisplay.cs
@@ -37,7 +37,7 @@ namespace osu.Game.Overlays.Mods
                 Anchor = Anchor.BottomRight,
                 AutoSizeAxes = Axes.X,
                 Height = ShearedButton.DEFAULT_HEIGHT,
-                Shear = new Vector2(OsuGame.SHEAR, 0),
+                Shear = OsuGame.SHEAR,
                 CornerRadius = ShearedButton.CORNER_RADIUS,
                 BorderThickness = ShearedButton.BORDER_THICKNESS,
                 Masking = true,
diff --git a/osu.Game/Overlays/Mods/ModPanel.cs b/osu.Game/Overlays/Mods/ModPanel.cs
index b85904f22b..df72692f48 100644
--- a/osu.Game/Overlays/Mods/ModPanel.cs
+++ b/osu.Game/Overlays/Mods/ModPanel.cs
@@ -37,7 +37,7 @@ namespace osu.Game.Overlays.Mods
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 Active = { BindTarget = Active },
-                Shear = new Vector2(-OsuGame.SHEAR, 0),
+                Shear = -OsuGame.SHEAR,
                 Scale = new Vector2(HEIGHT / ModSwitchSmall.DEFAULT_SIZE)
             };
         }
diff --git a/osu.Game/Overlays/Mods/ModSelectColumn.cs b/osu.Game/Overlays/Mods/ModSelectColumn.cs
index 8a499a391c..92c75e3494 100644
--- a/osu.Game/Overlays/Mods/ModSelectColumn.cs
+++ b/osu.Game/Overlays/Mods/ModSelectColumn.cs
@@ -70,7 +70,7 @@ namespace osu.Game.Overlays.Mods
         {
             Width = WIDTH;
             RelativeSizeAxes = Axes.Y;
-            Shear = new Vector2(OsuGame.SHEAR, 0);
+            Shear = OsuGame.SHEAR;
 
             InternalChildren = new Drawable[]
             {
@@ -96,7 +96,7 @@ namespace osu.Game.Overlays.Mods
                                 {
                                     RelativeSizeAxes = Axes.X,
                                     Height = header_height,
-                                    Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                    Shear = -OsuGame.SHEAR,
                                     Velocity = 0.7f,
                                     ClampAxes = Axes.Y
                                 },
@@ -111,7 +111,7 @@ namespace osu.Game.Overlays.Mods
                                     AutoSizeAxes = Axes.Y,
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
-                                    Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                    Shear = -OsuGame.SHEAR,
                                     Padding = new MarginPadding
                                     {
                                         Horizontal = 17,
diff --git a/osu.Game/Overlays/Mods/ModSelectOverlay.cs b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
index ac589fbebf..9ba3b3774f 100644
--- a/osu.Game/Overlays/Mods/ModSelectOverlay.cs
+++ b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
@@ -168,7 +168,7 @@ namespace osu.Game.Overlays.Mods
                                         Anchor = Anchor.BottomLeft,
                                         Origin = Anchor.BottomLeft,
                                         Direction = FillDirection.Horizontal,
-                                        Shear = new Vector2(OsuGame.SHEAR, 0),
+                                        Shear = OsuGame.SHEAR,
                                         RelativeSizeAxes = Axes.Y,
                                         AutoSizeAxes = Axes.X,
                                         Margin = new MarginPadding { Horizontal = 70 },
@@ -353,7 +353,10 @@ namespace osu.Game.Overlays.Mods
                                     .ToArray();
 
                 foreach (var modState in modStates)
+                {
+                    modState.Active.Value = SelectedMods.Value.Any(selected => selected.GetType() == modState.Mod.GetType());
                     modState.Active.BindValueChanged(_ => updateFromInternalSelection());
+                }
 
                 newLocalAvailableMods[modType] = modStates;
             }
@@ -723,7 +726,7 @@ namespace osu.Game.Overlays.Mods
                     // DrawWidth/DrawPosition do not include shear effects, and we want to know the full extents of the columns post-shear,
                     // so we have to manually compensate.
                     var topLeft = column.ToSpaceOfOtherDrawable(Vector2.Zero, ScrollContent);
-                    var bottomRight = column.ToSpaceOfOtherDrawable(new Vector2(column.DrawWidth - column.DrawHeight * OsuGame.SHEAR, 0), ScrollContent);
+                    var bottomRight = column.ToSpaceOfOtherDrawable(new Vector2(column.DrawWidth - column.DrawHeight * OsuGame.SHEAR.X, 0), ScrollContent);
 
                     bool isCurrentlyVisible = Precision.AlmostBigger(topLeft.X, leftVisibleBound)
                                               && Precision.DefinitelyBigger(rightVisibleBound, bottomRight.X);
diff --git a/osu.Game/Overlays/Mods/ModSelectPanel.cs b/osu.Game/Overlays/Mods/ModSelectPanel.cs
index 284356f37e..6d48576742 100644
--- a/osu.Game/Overlays/Mods/ModSelectPanel.cs
+++ b/osu.Game/Overlays/Mods/ModSelectPanel.cs
@@ -20,7 +20,6 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
-using osuTK;
 using osuTK.Graphics;
 using osuTK.Input;
 
@@ -87,7 +86,7 @@ namespace osu.Game.Overlays.Mods
             Content.CornerRadius = CORNER_RADIUS;
             Content.BorderThickness = 2;
 
-            Shear = new Vector2(OsuGame.SHEAR, 0);
+            Shear = OsuGame.SHEAR;
 
             Children = new Drawable[]
             {
@@ -128,10 +127,10 @@ namespace osu.Game.Overlays.Mods
                                     {
                                         Font = OsuFont.TorusAlternate.With(size: 18, weight: FontWeight.SemiBold),
                                         RelativeSizeAxes = Axes.X,
-                                        Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                        Shear = -OsuGame.SHEAR,
                                         Margin = new MarginPadding
                                         {
-                                            Left = -18 * OsuGame.SHEAR
+                                            Left = -18 * OsuGame.SHEAR.X
                                         },
                                         ShowTooltip = false, // Tooltip is handled by `IncompatibilityDisplayingModPanel`.
                                     },
@@ -139,7 +138,7 @@ namespace osu.Game.Overlays.Mods
                                     {
                                         Font = OsuFont.Default.With(size: 12),
                                         RelativeSizeAxes = Axes.X,
-                                        Shear = new Vector2(-OsuGame.SHEAR, 0),
+                                        Shear = -OsuGame.SHEAR,
                                         ShowTooltip = false, // Tooltip is handled by `IncompatibilityDisplayingModPanel`.
                                     }
                                 }
diff --git a/osu.Game/Overlays/Mods/RankingInformationDisplay.cs b/osu.Game/Overlays/Mods/RankingInformationDisplay.cs
index 75a8f289d8..11c963f616 100644
--- a/osu.Game/Overlays/Mods/RankingInformationDisplay.cs
+++ b/osu.Game/Overlays/Mods/RankingInformationDisplay.cs
@@ -15,7 +15,6 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Utils;
-using osuTK;
 
 namespace osu.Game.Overlays.Mods
 {
@@ -52,7 +51,7 @@ namespace osu.Game.Overlays.Mods
                 Anchor = Anchor.BottomRight,
                 Origin = Anchor.BottomRight,
                 RelativeSizeAxes = Axes.Both,
-                Shear = new Vector2(OsuGame.SHEAR, 0),
+                Shear = OsuGame.SHEAR,
                 CornerRadius = ShearedButton.CORNER_RADIUS,
                 Masking = true,
                 Children = new Drawable[]
@@ -79,7 +78,7 @@ namespace osu.Game.Overlays.Mods
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        Shear = new Vector2(-OsuGame.SHEAR, 0),
+                        Shear = -OsuGame.SHEAR,
                         Font = OsuFont.Default.With(size: 17, weight: FontWeight.SemiBold)
                     }
                 }
@@ -94,7 +93,7 @@ namespace osu.Game.Overlays.Mods
                 Origin = Anchor.Centre,
                 Child = counter = new EffectCounter
                 {
-                    Shear = new Vector2(-OsuGame.SHEAR, 0),
+                    Shear = -OsuGame.SHEAR,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Current = { BindTarget = ModMultiplier }
diff --git a/osu.Game/Overlays/Music/FilterControl.cs b/osu.Game/Overlays/Music/FilterControl.cs
deleted file mode 100644
index a61702645a..0000000000
--- a/osu.Game/Overlays/Music/FilterControl.cs
+++ /dev/null
@@ -1,76 +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 osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics;
-using osu.Game.Graphics.UserInterface;
-using osuTK;
-using System;
-using osu.Framework.Allocation;
-
-namespace osu.Game.Overlays.Music
-{
-    public partial class FilterControl : Container
-    {
-        public Action<FilterCriteria> FilterChanged;
-
-        public readonly FilterTextBox Search;
-        private readonly NowPlayingCollectionDropdown collectionDropdown;
-
-        public FilterControl()
-        {
-            Children = new Drawable[]
-            {
-                new FillFlowContainer
-                {
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
-                    Spacing = new Vector2(0f, 10f),
-                    Children = new Drawable[]
-                    {
-                        Search = new FilterTextBox
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            Height = 40,
-                        },
-                        collectionDropdown = new NowPlayingCollectionDropdown { RelativeSizeAxes = Axes.X }
-                    },
-                },
-            };
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Search.Current.BindValueChanged(_ => updateCriteria());
-            collectionDropdown.Current.BindValueChanged(_ => updateCriteria(), true);
-        }
-
-        private void updateCriteria() => FilterChanged?.Invoke(createCriteria());
-
-        private FilterCriteria createCriteria() => new FilterCriteria
-        {
-            SearchText = Search.Current.Value,
-            Collection = collectionDropdown.Current.Value?.Collection
-        };
-
-        public partial class FilterTextBox : BasicSearchTextBox
-        {
-            protected override bool AllowCommit => true;
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                Masking = true;
-                CornerRadius = 5;
-
-                BackgroundUnfocused = OsuColour.Gray(0.06f);
-                BackgroundFocused = OsuColour.Gray(0.12f);
-            }
-        }
-    }
-}
diff --git a/osu.Game/Overlays/Music/FilterCriteria.cs b/osu.Game/Overlays/Music/FilterCriteria.cs
deleted file mode 100644
index ad491be845..0000000000
--- a/osu.Game/Overlays/Music/FilterCriteria.cs
+++ /dev/null
@@ -1,25 +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 JetBrains.Annotations;
-using osu.Game.Collections;
-using osu.Game.Database;
-
-namespace osu.Game.Overlays.Music
-{
-    public class FilterCriteria
-    {
-        /// <summary>
-        /// The search text.
-        /// </summary>
-        public string SearchText;
-
-        /// <summary>
-        /// The collection to filter beatmaps from.
-        /// </summary>
-        [CanBeNull]
-        public Live<BeatmapCollection> Collection;
-    }
-}
diff --git a/osu.Game/Overlays/Music/MusicKeyBindingHandler.cs b/osu.Game/Overlays/Music/MusicKeyBindingHandler.cs
index 78de76b981..8cec85b748 100644
--- a/osu.Game/Overlays/Music/MusicKeyBindingHandler.cs
+++ b/osu.Game/Overlays/Music/MusicKeyBindingHandler.cs
@@ -9,7 +9,7 @@ using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
-using osu.Game.Configuration;
+using osu.Game.Input;
 using osu.Game.Input.Bindings;
 using osu.Game.Localisation;
 using osu.Game.Overlays.OSD;
@@ -92,9 +92,9 @@ namespace osu.Game.Overlays.Music
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuConfigManager config)
+            private void load(RealmKeyBindingStore keyBindingStore)
             {
-                ShortcutText.Text = config.LookupKeyBindings(action).ToUpper();
+                ShortcutText.Text = keyBindingStore.GetBindingsStringFor(action).ToUpper();
             }
         }
     }
diff --git a/osu.Game/Overlays/Music/NowPlayingCollectionDropdown.cs b/osu.Game/Overlays/Music/NowPlayingCollectionDropdown.cs
index 0f2e9400d9..2ba222b976 100644
--- a/osu.Game/Overlays/Music/NowPlayingCollectionDropdown.cs
+++ b/osu.Game/Overlays/Music/NowPlayingCollectionDropdown.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Overlays.Music
     /// <summary>
     /// A <see cref="CollectionDropdown"/> for use in the <see cref="NowPlayingOverlay"/>.
     /// </summary>
-    public partial class NowPlayingCollectionDropdown : CollectionDropdown
+    public partial class NowPlayingCollectionDropdown : CollectionDropdown // TODO: class is now unused. if we decide this isn't coming back it can be nuked.
     {
         protected override bool ShowManageCollectionsItem => false;
 
diff --git a/osu.Game/Overlays/Music/Playlist.cs b/osu.Game/Overlays/Music/Playlist.cs
index ab51ca7e1d..d7f35e6131 100644
--- a/osu.Game/Overlays/Music/Playlist.cs
+++ b/osu.Game/Overlays/Music/Playlist.cs
@@ -1,67 +1,27 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Linq;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Graphics.Containers;
-using osuTK;
 
 namespace osu.Game.Overlays.Music
 {
-    public partial class Playlist : OsuRearrangeableListContainer<Live<BeatmapSetInfo>>
+    public partial class Playlist : VirtualisedListContainer<Live<BeatmapSetInfo>, PlaylistItem>
     {
-        public Action<Live<BeatmapSetInfo>>? RequestSelection;
-
-        public readonly Bindable<Live<BeatmapSetInfo>> SelectedSet = new Bindable<Live<BeatmapSetInfo>>();
-
-        private FilterCriteria currentCriteria = new FilterCriteria();
-
         public new MarginPadding Padding
         {
             get => base.Padding;
             set => base.Padding = value;
         }
 
-        protected override void OnItemsChanged()
+        public Playlist()
+            : base(20, 50)
         {
-            base.OnItemsChanged();
-            Filter(currentCriteria);
         }
 
-        public void Filter(FilterCriteria criteria)
-        {
-            var items = (SearchContainer<RearrangeableListItem<Live<BeatmapSetInfo>>>)ListContainer;
-
-            string[]? currentCollectionHashes = criteria.Collection?.PerformRead(c => c.BeatmapMD5Hashes.ToArray());
-
-            foreach (var item in items.OfType<PlaylistItem>())
-            {
-                item.InSelectedCollection = currentCollectionHashes == null || item.Model.Value.Beatmaps.Select(b => b.MD5Hash).Any(currentCollectionHashes.Contains);
-            }
-
-            items.SearchTerm = criteria.SearchText;
-            currentCriteria = criteria;
-        }
-
-        public Live<BeatmapSetInfo>? FirstVisibleSet => Items.FirstOrDefault(i => ((PlaylistItem)ItemMap[i]).MatchingFilter);
-
-        protected override OsuRearrangeableListItem<Live<BeatmapSetInfo>> CreateOsuDrawable(Live<BeatmapSetInfo> item) =>
-            new PlaylistItem(item)
-            {
-                SelectedSet = { BindTarget = SelectedSet },
-                RequestSelection = set => RequestSelection?.Invoke(set)
-            };
-
-        protected override FillFlowContainer<RearrangeableListItem<Live<BeatmapSetInfo>>> CreateListFillFlowContainer() => new SearchContainer<RearrangeableListItem<Live<BeatmapSetInfo>>>
-        {
-            Spacing = new Vector2(0, 3),
-            LayoutDuration = 200,
-            LayoutEasing = Easing.OutQuint,
-        };
+        protected override ScrollContainer<Drawable> CreateScrollContainer() => new OsuScrollContainer();
     }
 }
diff --git a/osu.Game/Overlays/Music/PlaylistItem.cs b/osu.Game/Overlays/Music/PlaylistItem.cs
index 01b0472172..6217a9bc9e 100644
--- a/osu.Game/Overlays/Music/PlaylistItem.cs
+++ b/osu.Game/Overlays/Music/PlaylistItem.cs
@@ -1,15 +1,13 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Pooling;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
@@ -20,118 +18,110 @@ using osuTK.Graphics;
 
 namespace osu.Game.Overlays.Music
 {
-    public partial class PlaylistItem : OsuRearrangeableListItem<Live<BeatmapSetInfo>>, IFilterable
+    public partial class PlaylistItem : PoolableDrawable, IHasCurrentValue<Live<BeatmapSetInfo>>
     {
-        public readonly Bindable<Live<BeatmapSetInfo>> SelectedSet = new Bindable<Live<BeatmapSetInfo>>();
-
-        public Action<Live<BeatmapSetInfo>> RequestSelection;
-
-        private TextFlowContainer text;
-        private ITextPart titlePart;
-
-        [Resolved]
-        private OsuColour colours { get; set; }
-
-        public PlaylistItem(Live<BeatmapSetInfo> item)
-            : base(item)
+        public Bindable<Live<BeatmapSetInfo>> Current
         {
-            Padding = new MarginPadding { Left = 5 };
+            get => current.Current;
+            set => current.Current = value;
         }
 
+        private readonly BindableWithCurrent<Live<BeatmapSetInfo>> current = new BindableWithCurrent<Live<BeatmapSetInfo>>();
+
+        private readonly Bindable<Live<BeatmapSetInfo>?> selectedSet = new Bindable<Live<BeatmapSetInfo>?>();
+        private Action<Live<BeatmapSetInfo>>? requestSelection;
+
+        private MarqueeContainer text = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(PlaylistOverlay playlistOverlay)
         {
-            HandleColour = colours.Gray5;
+            RelativeSizeAxes = Axes.X;
+            Height = 20;
+
+            InternalChild = text = new MarqueeContainer
+            {
+                Anchor = Anchor.CentreLeft,
+                Origin = Anchor.CentreLeft,
+                RelativeSizeAxes = Axes.X,
+                InitialMoveDelay = 0,
+                AllowScrolling = false,
+            };
+
+            selectedSet.BindTo(playlistOverlay.SelectedSet);
+            requestSelection = playlistOverlay.ItemSelected;
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
+            Current.BindValueChanged(_ => onItemChanged(), true);
+            selectedSet.BindValueChanged(updateSelectionState, true);
+        }
 
-            Model.PerformRead(m =>
+        private void onItemChanged() => Current.Value.PerformRead(m =>
+        {
+            var metadata = m.Metadata;
+
+            var title = new RomanisableString(metadata.TitleUnicode, metadata.Title);
+            var artist = new RomanisableString(metadata.ArtistUnicode, metadata.Artist);
+
+            text.CreateContent = () =>
             {
-                var metadata = m.Metadata;
+                var flow = new OsuTextFlowContainer
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+                };
 
-                var title = new RomanisableString(metadata.TitleUnicode, metadata.Title);
-                var artist = new RomanisableString(metadata.ArtistUnicode, metadata.Artist);
-
-                titlePart = text.AddText(title, sprite => sprite.Font = OsuFont.GetFont(weight: FontWeight.Regular));
-                titlePart.DrawablePartsRecreated += _ => updateSelectionState(SelectedSet.Value, applyImmediately: true);
-
-                text.AddText(@"  "); // to separate the title from the artist.
-                text.AddText(artist, sprite =>
+                flow.AddText(title, sprite => sprite.Font = OsuFont.GetFont(weight: FontWeight.Regular));
+                flow.AddText(@"  "); // to separate the title from the artist.
+                flow.AddText(artist, sprite =>
                 {
                     sprite.Font = OsuFont.GetFont(size: 14, weight: FontWeight.Bold);
                     sprite.Colour = colours.Gray9;
                 });
+                return flow;
+            };
 
-                SelectedSet.BindValueChanged(set => updateSelectionState(set.NewValue));
-                updateSelectionState(SelectedSet.Value, applyImmediately: true);
-            });
-        }
+            selectedSet.TriggerChange();
+            FinishTransforms(true);
+        });
 
-        private bool selected;
+        private bool? selected;
 
-        private void updateSelectionState(Live<BeatmapSetInfo> selectedSet, bool applyImmediately = false)
+        private void updateSelectionState(ValueChangedEvent<Live<BeatmapSetInfo>?> selected)
         {
-            bool wasSelected = selected;
-            selected = selectedSet?.Equals(Model) == true;
+            bool? wasSelected = this.selected;
+            this.selected = selected.NewValue?.Equals(Current.Value) == true;
 
-            // Immediate updates should forcibly set correct state regardless of previous state.
-            // This ensures that the initial state is correctly applied.
-            if (wasSelected == selected && !applyImmediately)
+            if (wasSelected == this.selected)
                 return;
 
-            foreach (Drawable s in titlePart.Drawables)
-                s.FadeColour(selected ? colours.Yellow : Color4.White, applyImmediately ? 0 : FADE_DURATION);
+            text.FadeColour(this.selected == true ? colours.Yellow : Color4.White, 100);
         }
 
-        protected override Drawable CreateContent() => new DelayedLoadWrapper(text = new OsuTextFlowContainer
-        {
-            RelativeSizeAxes = Axes.X,
-            AutoSizeAxes = Axes.Y,
-        });
-
         protected override bool OnClick(ClickEvent e)
         {
-            RequestSelection?.Invoke(Model);
+            requestSelection?.Invoke(Current.Value);
             return true;
         }
 
-        private bool inSelectedCollection = true;
-
-        public bool InSelectedCollection
+        protected override bool OnHover(HoverEvent e)
         {
-            get => inSelectedCollection;
-            set
-            {
-                if (inSelectedCollection == value)
-                    return;
-
-                inSelectedCollection = value;
-                updateFilter();
-            }
+            text.AllowScrolling = true;
+            return true;
         }
 
-        public IEnumerable<LocalisableString> FilterTerms => Model.PerformRead(m => m.Metadata.GetSearchableTerms()).Select(s => (LocalisableString)s).ToArray();
-
-        private bool matchingFilter = true;
-
-        public bool MatchingFilter
+        protected override void OnHoverLost(HoverLostEvent e)
         {
-            get => matchingFilter && inSelectedCollection;
-            set
-            {
-                if (matchingFilter == value)
-                    return;
-
-                matchingFilter = value;
-                updateFilter();
-            }
+            text.AllowScrolling = false;
+            base.OnHoverLost(e);
         }
-
-        private void updateFilter() => this.FadeTo(MatchingFilter ? 1 : 0, 200);
-
-        public bool FilteringActive { get; set; }
     }
 }
diff --git a/osu.Game/Overlays/Music/PlaylistOverlay.cs b/osu.Game/Overlays/Music/PlaylistOverlay.cs
index b49c794aa3..99ae88701a 100644
--- a/osu.Game/Overlays/Music/PlaylistOverlay.cs
+++ b/osu.Game/Overlays/Music/PlaylistOverlay.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Linq;
 using osu.Framework.Allocation;
@@ -21,8 +19,11 @@ using Realms;
 
 namespace osu.Game.Overlays.Music
 {
+    [Cached]
     public partial class PlaylistOverlay : VisibilityContainer
     {
+        public Bindable<Live<BeatmapSetInfo>?> SelectedSet = new Bindable<Live<BeatmapSetInfo>?>();
+
         private const float transition_duration = 600;
         public const float PLAYLIST_HEIGHT = 510;
 
@@ -31,15 +32,14 @@ namespace osu.Game.Overlays.Music
         private readonly Bindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
 
         [Resolved]
-        private BeatmapManager beatmaps { get; set; }
+        private BeatmapManager beatmaps { get; set; } = null!;
 
         [Resolved]
-        private RealmAccess realm { get; set; }
+        private RealmAccess realm { get; set; } = null!;
 
-        private IDisposable beatmapSubscription;
+        private IDisposable? beatmapSubscription;
 
-        private FilterControl filter;
-        private Playlist list;
+        private Playlist list = null!;
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours, Bindable<WorkingBeatmap> beatmap)
@@ -69,33 +69,11 @@ namespace osu.Game.Overlays.Music
                         list = new Playlist
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Top = 95, Bottom = 10, Right = 10 },
-                            RequestSelection = itemSelected
-                        },
-                        filter = new FilterControl
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                            FilterChanged = criteria => list.Filter(criteria),
-                            Padding = new MarginPadding(10),
+                            Padding = new MarginPadding { Vertical = 10, Right = 10 },
                         },
                     },
                 },
             };
-
-            filter.Search.OnCommit += (_, _) =>
-            {
-                list.FirstVisibleSet?.PerformRead(set =>
-                {
-                    BeatmapInfo toSelect = set.Beatmaps.FirstOrDefault();
-
-                    if (toSelect != null)
-                    {
-                        beatmap.Value = beatmaps.GetWorkingBeatmap(toSelect);
-                        beatmap.Value.Track.Restart();
-                    }
-                });
-            };
         }
 
         protected override void LoadComplete()
@@ -104,11 +82,11 @@ namespace osu.Game.Overlays.Music
 
             beatmapSubscription = realm.RegisterForNotifications(r => r.All<BeatmapSetInfo>().Where(s => !s.DeletePending && !s.Protected), beatmapsChanged);
 
-            list.Items.BindTo(beatmapSets);
-            beatmap.BindValueChanged(working => list.SelectedSet.Value = working.NewValue.BeatmapSetInfo.ToLive(realm), true);
+            list.RowData.BindTo(beatmapSets);
+            beatmap.BindValueChanged(working => SelectedSet.Value = working.NewValue.BeatmapSetInfo.ToLive(realm), true);
         }
 
-        private void beatmapsChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet changes)
+        private void beatmapsChanged(IRealmCollection<BeatmapSetInfo> sender, ChangeSet? changes)
         {
             if (changes == null)
             {
@@ -127,22 +105,17 @@ namespace osu.Game.Overlays.Music
 
         protected override void PopIn()
         {
-            filter.Search.HoldFocus = true;
-            Schedule(() => filter.Search.TakeFocus());
-
             this.ResizeTo(new Vector2(1, RelativeSizeAxes.HasFlag(Axes.Y) ? 1f : PLAYLIST_HEIGHT), transition_duration, Easing.OutQuint);
             this.FadeIn(transition_duration, Easing.OutQuint);
         }
 
         protected override void PopOut()
         {
-            filter.Search.HoldFocus = false;
-
             this.ResizeTo(new Vector2(1, 0), transition_duration, Easing.OutQuint);
             this.FadeOut(transition_duration);
         }
 
-        private void itemSelected(Live<BeatmapSetInfo> beatmapSet)
+        public void ItemSelected(Live<BeatmapSetInfo> beatmapSet)
         {
             beatmapSet.PerformRead(set =>
             {
diff --git a/osu.Game/Overlays/MusicController.cs b/osu.Game/Overlays/MusicController.cs
index da5388534c..8bb88fc8e9 100644
--- a/osu.Game/Overlays/MusicController.cs
+++ b/osu.Game/Overlays/MusicController.cs
@@ -73,9 +73,9 @@ namespace osu.Game.Overlays
         private AudioFilter audioDuckFilter = null!;
 
         private readonly Bindable<RandomSelectAlgorithm> randomSelectAlgorithm = new Bindable<RandomSelectAlgorithm>();
-        private readonly List<Live<BeatmapSetInfo>> previousRandomSets = new List<Live<BeatmapSetInfo>>();
-        private int randomHistoryDirection;
-        private int lastRandomTrackDirection;
+
+        private readonly LinkedList<Live<BeatmapSetInfo>> randomHistory = new LinkedList<Live<BeatmapSetInfo>>();
+        private LinkedListNode<Live<BeatmapSetInfo>>? currentRandomHistoryPosition;
 
         [BackgroundDependencyLoader]
         private void load(AudioManager audio, OsuConfigManager configManager)
@@ -371,81 +371,75 @@ namespace osu.Game.Overlays
 
         private Live<BeatmapSetInfo>? getNextRandom(int direction, bool allowProtectedTracks)
         {
-            try
+            Live<BeatmapSetInfo> result;
+
+            var possibleSets = getBeatmapSets(allowProtectedTracks).ToList();
+
+            if (possibleSets.Count == 0)
+                return null;
+
+            // if there is only one possible set left, play it, even if it is the same as the current track.
+            // looping is preferable over playing nothing.
+            if (possibleSets.Count == 1)
+                return possibleSets.Single();
+
+            // now that we actually know there is a choice, do not allow the current track to be played again.
+            possibleSets.RemoveAll(s => s.Value.Equals(current?.BeatmapSetInfo));
+
+            if (currentRandomHistoryPosition != null)
             {
-                Live<BeatmapSetInfo> result;
-
-                var possibleSets = getBeatmapSets(allowProtectedTracks).ToList();
-
-                if (possibleSets.Count == 0)
-                    return null;
-
-                // if there is only
-                // one possible set left, play it, even if it is the same as the current track.
-                // looping is preferable over playing nothing.
-                if (possibleSets.Count == 1)
-                    return possibleSets.Single();
-
-                // now that we actually know there is a choice, do not allow the current track to be played again.
-                possibleSets.RemoveAll(s => s.Value.Equals(current?.BeatmapSetInfo));
-
-                // condition below checks if the signs of `randomHistoryDirection` and `direction` are opposite and not zero.
-                // if that is the case, it means that the user had previously chosen next track `randomHistoryDirection` times and wants to go back,
-                // or that the user had previously chosen previous track `randomHistoryDirection` times and wants to go forward.
-                // in both cases, it means that we have a history of previous random selections that we can rewind.
-                if (randomHistoryDirection * direction < 0)
+                if (direction < 0 && currentRandomHistoryPosition.Previous != null)
                 {
-                    Debug.Assert(Math.Abs(randomHistoryDirection) == previousRandomSets.Count);
-
-                    // if the user has been shuffling backwards and now going forwards (or vice versa),
-                    // the topmost item from history needs to be discarded because it's the *current* track.
-                    if (direction * lastRandomTrackDirection < 0)
-                    {
-                        previousRandomSets.RemoveAt(previousRandomSets.Count - 1);
-                        randomHistoryDirection += direction;
-                    }
-
-                    if (previousRandomSets.Count > 0)
-                    {
-                        result = previousRandomSets[^1];
-                        previousRandomSets.RemoveAt(previousRandomSets.Count - 1);
-                        return result;
-                    }
+                    currentRandomHistoryPosition = currentRandomHistoryPosition.Previous;
+                    return currentRandomHistoryPosition.Value;
                 }
 
-                // if the early-return above didn't cover it, it means that we have no history to fall back on
-                // and need to actually choose something random.
-                switch (randomSelectAlgorithm.Value)
+                if (direction > 0 && currentRandomHistoryPosition.Next != null)
                 {
-                    case RandomSelectAlgorithm.Random:
-                        result = possibleSets[RNG.Next(possibleSets.Count)];
-                        break;
-
-                    case RandomSelectAlgorithm.RandomPermutation:
-                        var notYetPlayedSets = possibleSets.Except(previousRandomSets).ToList();
-
-                        if (notYetPlayedSets.Count == 0)
-                        {
-                            notYetPlayedSets = possibleSets;
-                            previousRandomSets.Clear();
-                            randomHistoryDirection = 0;
-                        }
-
-                        result = notYetPlayedSets[RNG.Next(notYetPlayedSets.Count)];
-                        break;
-
-                    default:
-                        throw new ArgumentOutOfRangeException(nameof(randomSelectAlgorithm), randomSelectAlgorithm.Value, "Unsupported random select algorithm");
+                    currentRandomHistoryPosition = currentRandomHistoryPosition.Next;
+                    return currentRandomHistoryPosition.Value;
                 }
+            }
 
-                previousRandomSets.Add(result);
-                return result;
-            }
-            finally
+            // if the early-return above didn't cover it, it means that we have no history to fall back on
+            // and need to actually choose something random.
+
+            switch (randomSelectAlgorithm.Value)
             {
-                randomHistoryDirection += direction;
-                lastRandomTrackDirection = direction;
+                case RandomSelectAlgorithm.Random:
+                    result = possibleSets[RNG.Next(possibleSets.Count)];
+                    break;
+
+                case RandomSelectAlgorithm.RandomPermutation:
+                    var notYetPlayedSets = possibleSets.Except(randomHistory).ToList();
+
+                    if (notYetPlayedSets.Count == 0)
+                    {
+                        possibleSets.RemoveAll(s => s.Value.Equals(current?.BeatmapSetInfo));
+                        notYetPlayedSets = possibleSets;
+                        randomHistory.Clear();
+                    }
+
+                    result = notYetPlayedSets[RNG.Next(notYetPlayedSets.Count)];
+
+                    Debug.Assert(randomHistory.Count == 0
+                                 || (currentRandomHistoryPosition == randomHistory.First && direction < 0)
+                                 || (currentRandomHistoryPosition == randomHistory.Last && direction > 0));
+
+                    // notably, this depends solely on `direction` specifically, because when there are less than 2 items in `randomHistory`,
+                    // we have `randomHistory.First == randomHistory.Last` (either `null` if no items, or the single item).
+                    // the assert above should make that safe to depend on.
+                    if (direction > 0)
+                        currentRandomHistoryPosition = randomHistory.AddLast(result);
+                    else if (direction < 0)
+                        currentRandomHistoryPosition = randomHistory.AddFirst(result);
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(randomSelectAlgorithm), randomSelectAlgorithm.Value, "Unsupported random select algorithm");
             }
+
+            return result;
         }
 
         private void restartTrack()
diff --git a/osu.Game/Overlays/NowPlayingOverlay.cs b/osu.Game/Overlays/NowPlayingOverlay.cs
index f4da9a92dc..11819cb485 100644
--- a/osu.Game/Overlays/NowPlayingOverlay.cs
+++ b/osu.Game/Overlays/NowPlayingOverlay.cs
@@ -5,7 +5,6 @@ using System;
 using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Configuration;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
@@ -50,7 +49,7 @@ namespace osu.Game.Overlays
         private MusicIconButton shuffleButton = null!;
         private IconButton playlistButton = null!;
 
-        private ScrollingTextContainer title = null!, artist = null!;
+        private MarqueeContainer title = null!, artist = null!;
 
         private PlaylistOverlay? playlist;
 
@@ -72,6 +71,9 @@ namespace osu.Game.Overlays
         private Bindable<bool> allowTrackControl = null!;
         private readonly BindableBool shuffle = new BindableBool(true);
 
+        private static readonly FontUsage title_font = OsuFont.GetFont(size: 25, italics: true);
+        private static readonly FontUsage artist_font = OsuFont.GetFont(size: 15, weight: FontWeight.Bold, italics: true);
+
         public NowPlayingOverlay()
         {
             Width = player_width;
@@ -105,23 +107,35 @@ namespace osu.Game.Overlays
                             Children = new[]
                             {
                                 background = Empty(),
-                                title = new ScrollingTextContainer
+                                title = new MarqueeContainer
                                 {
                                     Origin = Anchor.BottomCentre,
                                     Anchor = Anchor.TopCentre,
                                     Position = new Vector2(0, 40),
-                                    Font = OsuFont.GetFont(size: 25, italics: true),
                                     Colour = Color4.White,
-                                    Text = @"Nothing to play",
+                                    CreateContent = () => new OsuSpriteText
+                                    {
+                                        Font = title_font,
+                                        Text = @"Nothing to play",
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                    },
+                                    NonOverflowingContentAnchor = Anchor.Centre,
                                 },
-                                artist = new ScrollingTextContainer
+                                artist = new MarqueeContainer
                                 {
                                     Origin = Anchor.TopCentre,
                                     Anchor = Anchor.TopCentre,
                                     Position = new Vector2(0, 45),
-                                    Font = OsuFont.GetFont(size: 15, weight: FontWeight.Bold, italics: true),
                                     Colour = Color4.White,
-                                    Text = @"Nothing to play",
+                                    CreateContent = () => new OsuSpriteText
+                                    {
+                                        Font = artist_font,
+                                        Text = @"Nothing to play",
+                                        Anchor = Anchor.Centre,
+                                        Origin = Anchor.Centre,
+                                    },
+                                    NonOverflowingContentAnchor = Anchor.Centre,
                                 },
                                 new Container
                                 {
@@ -318,8 +332,20 @@ namespace osu.Game.Overlays
             {
                 BeatmapMetadata metadata = beatmap.Metadata;
 
-                title.Text = new RomanisableString(metadata.TitleUnicode, metadata.Title);
-                artist.Text = new RomanisableString(metadata.ArtistUnicode, metadata.Artist);
+                title.CreateContent = () => new OsuSpriteText
+                {
+                    Text = new RomanisableString(metadata.TitleUnicode, metadata.Title),
+                    Font = title_font,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                };
+                artist.CreateContent = () => new OsuSpriteText
+                {
+                    Text = new RomanisableString(metadata.ArtistUnicode, metadata.Artist),
+                    Font = artist_font,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                };
 
                 backgroundLoadCancellation?.Cancel();
 
@@ -484,111 +510,5 @@ namespace osu.Game.Overlays
                 base.OnHoverLost(e);
             }
         }
-
-        private partial class ScrollingTextContainer : CompositeDrawable
-        {
-            private const float initial_move_delay = 1000;
-            private const float pixels_per_second = 50;
-
-            private OsuSpriteText mainSpriteText = null!;
-            private OsuSpriteText fillerSpriteText = null!;
-
-            private Bindable<bool> showUnicode = null!;
-
-            [Resolved]
-            private FrameworkConfigManager frameworkConfig { get; set; } = null!;
-
-            private LocalisableString text;
-
-            public LocalisableString Text
-            {
-                get => text;
-                set
-                {
-                    text = value;
-
-                    if (IsLoaded)
-                        updateText();
-                }
-            }
-
-            private FontUsage font = OsuFont.Default;
-
-            public FontUsage Font
-            {
-                get => font;
-                set
-                {
-                    font = value;
-
-                    if (IsLoaded)
-                        updateFontAndText();
-                }
-            }
-
-            public ScrollingTextContainer()
-            {
-                AutoSizeAxes = Axes.Both;
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                InternalChild = new FillFlowContainer<OsuSpriteText>
-                {
-                    AutoSizeAxes = Axes.Both,
-                    Direction = FillDirection.Horizontal,
-                    Children = new[]
-                    {
-                        mainSpriteText = new OsuSpriteText { Padding = new MarginPadding { Horizontal = margin } },
-                        fillerSpriteText = new OsuSpriteText { Padding = new MarginPadding { Horizontal = margin }, Alpha = 0 },
-                    }
-                };
-            }
-
-            protected override void LoadComplete()
-            {
-                base.LoadComplete();
-
-                showUnicode = frameworkConfig.GetBindable<bool>(FrameworkSetting.ShowUnicode);
-                showUnicode.BindValueChanged(_ => updateText());
-
-                updateFontAndText();
-            }
-
-            private void updateFontAndText()
-            {
-                mainSpriteText.Font = font;
-                fillerSpriteText.Font = font;
-
-                updateText();
-            }
-
-            private void updateText()
-            {
-                mainSpriteText.Text = text;
-                fillerSpriteText.Alpha = 0;
-
-                ClearTransforms();
-                X = 0;
-
-                float textOverflowWidth = mainSpriteText.Width - player_width;
-
-                // apply half margin of tolerance on both sides before the text scrolls
-                if (textOverflowWidth > margin)
-                {
-                    fillerSpriteText.Alpha = 1;
-                    fillerSpriteText.Text = text;
-
-                    float initialX = (textOverflowWidth + mainSpriteText.Width) / 2;
-                    float targetX = (textOverflowWidth - mainSpriteText.Width) / 2;
-
-                    this.MoveToX(initialX)
-                        .Delay(initial_move_delay)
-                        .MoveToX(targetX, mainSpriteText.Width * 1000 / pixels_per_second)
-                        .Loop();
-                }
-            }
-        }
     }
 }
diff --git a/osu.Game/Overlays/OSD/SpeedChangeToast.cs b/osu.Game/Overlays/OSD/SpeedChangeToast.cs
index 49d3985b04..652c043357 100644
--- a/osu.Game/Overlays/OSD/SpeedChangeToast.cs
+++ b/osu.Game/Overlays/OSD/SpeedChangeToast.cs
@@ -1,7 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Configuration;
+using osu.Game.Input;
 using osu.Game.Input.Bindings;
 using osu.Game.Localisation;
 
@@ -9,8 +9,8 @@ namespace osu.Game.Overlays.OSD
 {
     public partial class SpeedChangeToast : Toast
     {
-        public SpeedChangeToast(OsuConfigManager config, double newSpeed)
-            : base(ModSelectOverlayStrings.ModCustomisation, ToastStrings.SpeedChangedTo(newSpeed), config.LookupKeyBindings(GlobalAction.IncreaseModSpeed) + " / " + config.LookupKeyBindings(GlobalAction.DecreaseModSpeed))
+        public SpeedChangeToast(RealmKeyBindingStore keyBindingStore, double newSpeed)
+            : base(ModSelectOverlayStrings.ModCustomisation, ToastStrings.SpeedChangedTo(newSpeed), keyBindingStore.GetBindingsStringFor(GlobalAction.IncreaseModSpeed) + " / " + keyBindingStore.GetBindingsStringFor(GlobalAction.DecreaseModSpeed))
         {
         }
     }
diff --git a/osu.Game/Overlays/OnScreenDisplay.cs b/osu.Game/Overlays/OnScreenDisplay.cs
index 4f2dba7b2c..c2ffb8ba6c 100644
--- a/osu.Game/Overlays/OnScreenDisplay.cs
+++ b/osu.Game/Overlays/OnScreenDisplay.cs
@@ -5,8 +5,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Configuration.Tracking;
+using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Transforms;
@@ -56,8 +59,11 @@ namespace osu.Game.Overlays
         /// <param name="configManager">The <see cref="ConfigManager{T}"/> to be tracked.</param>
         /// <exception cref="ArgumentNullException">If <paramref name="configManager"/> is null.</exception>
         /// <exception cref="InvalidOperationException">If <paramref name="configManager"/> is already being tracked from the same <paramref name="source"/>.</exception>
-        public void BeginTracking(object source, ITrackableConfigManager configManager)
+        /// <returns>An object representing the registration, that may be disposed to stop tracking the <see cref="ConfigManager{T}"/>.</returns>
+        public IDisposable BeginTracking(object source, ITrackableConfigManager configManager)
         {
+            Debug.Assert(ThreadSafety.IsUpdateThread);
+
             ArgumentNullException.ThrowIfNull(configManager);
 
             if (trackedConfigManagers.ContainsKey((source, configManager)))
@@ -65,32 +71,18 @@ namespace osu.Game.Overlays
 
             var trackedSettings = configManager.CreateTrackedSettings();
             if (trackedSettings == null)
-                return;
+                return new InvokeOnDisposal(() => { });
 
             configManager.LoadInto(trackedSettings);
             trackedSettings.SettingChanged += displayTrackedSettingChange;
-
             trackedConfigManagers.Add((source, configManager), trackedSettings);
-        }
 
-        /// <summary>
-        /// Unregisters a <see cref="ConfigManager{T}"/> from having its settings tracked by this <see cref="OnScreenDisplay"/>.
-        /// </summary>
-        /// <param name="source">The object that registered the <see cref="ConfigManager{T}"/> to be tracked.</param>
-        /// <param name="configManager">The <see cref="ConfigManager{T}"/> that is being tracked.</param>
-        /// <exception cref="ArgumentNullException">If <paramref name="configManager"/> is null.</exception>
-        /// <exception cref="InvalidOperationException">If <paramref name="configManager"/> is not being tracked from the same <paramref name="source"/>.</exception>
-        public void StopTracking(object source, ITrackableConfigManager configManager)
-        {
-            ArgumentNullException.ThrowIfNull(configManager);
-
-            if (!trackedConfigManagers.TryGetValue((source, configManager), out var existing))
-                return;
-
-            existing.Unload();
-            existing.SettingChanged -= displayTrackedSettingChange;
-
-            trackedConfigManagers.Remove((source, configManager));
+            return new InvokeOnDisposal(() =>
+            {
+                trackedSettings.Unload();
+                trackedSettings.SettingChanged -= displayTrackedSettingChange;
+                trackedConfigManagers.Remove((source, configManager));
+            });
         }
 
         /// <summary>
diff --git a/osu.Game/Overlays/Profile/Header/Components/FollowersButton.cs b/osu.Game/Overlays/Profile/Header/Components/FollowersButton.cs
index b93f996ec2..daf23c8ef3 100644
--- a/osu.Game/Overlays/Profile/Header/Components/FollowersButton.cs
+++ b/osu.Game/Overlays/Profile/Header/Components/FollowersButton.cs
@@ -62,8 +62,11 @@ namespace osu.Game.Overlays.Profile.Header.Components
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
         [BackgroundDependencyLoader]
-        private void load(IAPIProvider api, INotificationOverlay? notifications)
+        private void load(INotificationOverlay? notifications)
         {
             localUser.BindTo(api.LocalUser);
 
@@ -73,15 +76,6 @@ namespace osu.Game.Overlays.Profile.Header.Components
                 updateColor();
             });
 
-            User.BindValueChanged(u =>
-            {
-                followerCount = u.NewValue?.User.FollowerCount ?? 0;
-                updateStatus();
-            }, true);
-
-            apiFriends.BindTo(api.Friends);
-            apiFriends.BindCollectionChanged((_, _) => Schedule(updateStatus));
-
             Action += () =>
             {
                 if (User.Value == null)
@@ -126,6 +120,20 @@ namespace osu.Game.Overlays.Profile.Header.Components
             };
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            apiFriends.BindTo(api.Friends);
+            apiFriends.BindCollectionChanged((_, _) => Schedule(updateStatus));
+
+            User.BindValueChanged(u =>
+            {
+                followerCount = u.NewValue?.User.FollowerCount ?? 0;
+                updateStatus();
+            }, true);
+        }
+
         protected override bool OnHover(HoverEvent e)
         {
             if (status.Value > FriendStatus.None)
diff --git a/osu.Game/Overlays/Settings/Sections/Audio/AudioOffsetAdjustControl.cs b/osu.Game/Overlays/Settings/Sections/Audio/AudioOffsetAdjustControl.cs
index b9f043a233..2629cd2183 100644
--- a/osu.Game/Overlays/Settings/Sections/Audio/AudioOffsetAdjustControl.cs
+++ b/osu.Game/Overlays/Settings/Sections/Audio/AudioOffsetAdjustControl.cs
@@ -8,13 +8,13 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Extensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
@@ -109,6 +109,7 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
                 base.LoadComplete();
 
                 averageHitErrorHistory.BindCollectionChanged(updateDisplay, true);
+                current.BindValueChanged(_ => updateHintText());
                 SuggestedOffset.BindValueChanged(_ => updateHintText(), true);
             }
 
@@ -148,17 +149,28 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
                         break;
                 }
 
-                SuggestedOffset.Value = averageHitErrorHistory.Any() ? averageHitErrorHistory.Average(dataPoint => dataPoint.SuggestedGlobalAudioOffset) : null;
+                SuggestedOffset.Value = averageHitErrorHistory.Any() ? Math.Round(averageHitErrorHistory.Average(dataPoint => dataPoint.SuggestedGlobalAudioOffset)) : null;
             }
 
             private float getXPositionForOffset(double offset) => (float)(Math.Clamp(offset, current.MinValue, current.MaxValue) / (2 * current.MaxValue));
 
             private void updateHintText()
             {
-                hintText.Text = SuggestedOffset.Value == null
-                    ? AudioSettingsStrings.SuggestedOffsetNote
-                    : AudioSettingsStrings.SuggestedOffsetValueReceived(averageHitErrorHistory.Count, SuggestedOffset.Value.ToLocalisableString(@"N0"));
-                applySuggestion.Enabled.Value = SuggestedOffset.Value != null;
+                if (SuggestedOffset.Value == null)
+                {
+                    applySuggestion.Enabled.Value = false;
+                    hintText.Text = AudioSettingsStrings.SuggestedOffsetNote;
+                }
+                else if (Math.Abs(SuggestedOffset.Value.Value - current.Value) < 1)
+                {
+                    applySuggestion.Enabled.Value = false;
+                    hintText.Text = AudioSettingsStrings.SuggestedOffsetCorrect(averageHitErrorHistory.Count);
+                }
+                else
+                {
+                    applySuggestion.Enabled.Value = true;
+                    hintText.Text = AudioSettingsStrings.SuggestedOffsetValueReceived(averageHitErrorHistory.Count, SuggestedOffset.Value.Value.ToStandardFormattedString(0, false));
+                }
             }
 
             private partial class OffsetSliderBar : RoundedSliderBar<double>
diff --git a/osu.Game/Overlays/Settings/Sections/UserInterface/SongSelectSettings.cs b/osu.Game/Overlays/Settings/Sections/UserInterface/SongSelectSettings.cs
index cb0d738a2c..d15008f858 100644
--- a/osu.Game/Overlays/Settings/Sections/UserInterface/SongSelectSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/UserInterface/SongSelectSettings.cs
@@ -23,6 +23,7 @@ namespace osu.Game.Overlays.Settings.Sections.UserInterface
                 {
                     LabelText = UserInterfaceStrings.ShowConvertedBeatmaps,
                     Current = config.GetBindable<bool>(OsuSetting.ShowConvertedBeatmaps),
+                    Keywords = new[] { "converts", "converted" }
                 },
                 new SettingsEnumDropdown<RandomSelectAlgorithm>
                 {
diff --git a/osu.Game/Overlays/SkinEditor/SkinEditor.cs b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
index 534abd1ab3..c1c64cac1f 100644
--- a/osu.Game/Overlays/SkinEditor/SkinEditor.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
@@ -760,11 +760,7 @@ namespace osu.Game.Overlays.SkinEditor
 
         #region Delegation of IEditorChangeHandler
 
-        public event Action? OnStateChange
-        {
-            add => throw new NotImplementedException();
-            remove => throw new NotImplementedException();
-        }
+        public event Action? OnStateChange;
 
         private IEditorChangeHandler? beginChangeHandler;
 
@@ -773,6 +769,9 @@ namespace osu.Game.Overlays.SkinEditor
             // Change handler may change between begin and end, which can cause unbalanced operations.
             // Let's track the one that was used when beginning the change so we can call EndChange on it specifically.
             (beginChangeHandler = changeHandler)?.BeginChange();
+
+            if (beginChangeHandler != null)
+                beginChangeHandler.OnStateChange += OnStateChange;
         }
 
         public void EndChange() => beginChangeHandler?.EndChange();
diff --git a/osu.Game/Overlays/SkinEditor/SkinSelectionHandler.cs b/osu.Game/Overlays/SkinEditor/SkinSelectionHandler.cs
index bc878b9214..838b5ff2f0 100644
--- a/osu.Game/Overlays/SkinEditor/SkinSelectionHandler.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinSelectionHandler.cs
@@ -22,7 +22,10 @@ namespace osu.Game.Overlays.SkinEditor
 {
     public partial class SkinSelectionHandler : SelectionHandler<ISerialisableDrawable>
     {
-        private OsuMenuItem originMenu = null!;
+        private OsuMenuItem? originMenu;
+
+        private TernaryStateRadioMenuItem? closestAnchor;
+        private AnchorMenuItem[]? fixedAnchors;
 
         [Resolved]
         private SkinEditor skinEditor { get; set; } = null!;
@@ -44,6 +47,38 @@ namespace osu.Game.Overlays.SkinEditor
             return scaleHandler;
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            if (ChangeHandler != null)
+                ChangeHandler.OnStateChange += updateTernaryStates;
+            SelectedItems.BindCollectionChanged((_, _) => updateTernaryStates());
+        }
+
+        private void updateTernaryStates()
+        {
+            var usingClosestAnchor = GetStateFromSelection(SelectedBlueprints, c => !c.Item.UsesFixedAnchor);
+
+            if (closestAnchor != null)
+                closestAnchor.State.Value = usingClosestAnchor;
+
+            if (fixedAnchors != null)
+            {
+                foreach (var fixedAnchor in fixedAnchors)
+                    fixedAnchor.State.Value = GetStateFromSelection(SelectedBlueprints, c => c.Item.UsesFixedAnchor && ((Drawable)c.Item).Anchor == fixedAnchor.Anchor);
+            }
+
+            if (originMenu != null)
+            {
+                foreach (var origin in originMenu.Items.OfType<AnchorMenuItem>())
+                {
+                    origin.State.Value = GetStateFromSelection(SelectedBlueprints, c => ((Drawable)c.Item).Origin == origin.Anchor);
+                    origin.Action.Disabled = usingClosestAnchor == TernaryState.True;
+                }
+            }
+        }
+
         public override bool HandleFlip(Direction direction, bool flipOverOrigin)
         {
             var selectionQuad = getSelectionQuad();
@@ -102,27 +137,17 @@ namespace osu.Game.Overlays.SkinEditor
 
         protected override IEnumerable<MenuItem> GetContextMenuItemsForSelection(IEnumerable<SelectionBlueprint<ISerialisableDrawable>> selection)
         {
-            var closestItem = new TernaryStateRadioMenuItem(SkinEditorStrings.Closest, MenuItemType.Standard, _ => applyClosestAnchors())
-            {
-                State = { Value = GetStateFromSelection(selection, c => !c.Item.UsesFixedAnchor) }
-            };
+            closestAnchor = new TernaryStateRadioMenuItem(SkinEditorStrings.Closest, MenuItemType.Standard, _ => applyClosestAnchors());
+            fixedAnchors = createAnchorItems(applyFixedAnchors).ToArray();
 
             yield return new OsuMenuItem(SkinEditorStrings.Anchor)
             {
-                Items = createAnchorItems((d, a) => d.UsesFixedAnchor && ((Drawable)d).Anchor == a, applyFixedAnchors)
-                        .Prepend(closestItem)
-                        .ToArray()
+                Items = fixedAnchors.Prepend(closestAnchor).ToArray()
             };
 
             yield return originMenu = new OsuMenuItem(SkinEditorStrings.Origin);
 
-            closestItem.State.BindValueChanged(s =>
-            {
-                // For UX simplicity, origin should only be user-editable when "closest" anchor mode is disabled.
-                originMenu.Items = s.NewValue == TernaryState.True
-                    ? Array.Empty<MenuItem>()
-                    : createAnchorItems((d, o) => ((Drawable)d).Origin == o, applyOrigins).ToArray();
-            }, true);
+            originMenu.Items = createAnchorItems(applyOrigins).ToArray();
 
             yield return new OsuMenuItemSpacer();
 
@@ -163,27 +188,37 @@ namespace osu.Game.Overlays.SkinEditor
             foreach (var item in base.GetContextMenuItemsForSelection(selection))
                 yield return item;
 
-            IEnumerable<TernaryStateMenuItem> createAnchorItems(Func<ISerialisableDrawable, Anchor, bool> checkFunction, Action<Anchor> applyFunction)
+            updateTernaryStates();
+        }
+
+        private IEnumerable<AnchorMenuItem> createAnchorItems(Action<Anchor> applyFunction)
+        {
+            var displayableAnchors = new[]
             {
-                var displayableAnchors = new[]
-                {
-                    Anchor.TopLeft,
-                    Anchor.TopCentre,
-                    Anchor.TopRight,
-                    Anchor.CentreLeft,
-                    Anchor.Centre,
-                    Anchor.CentreRight,
-                    Anchor.BottomLeft,
-                    Anchor.BottomCentre,
-                    Anchor.BottomRight,
-                };
-                return displayableAnchors.Select(a =>
-                {
-                    return new TernaryStateRadioMenuItem(a.ToString(), MenuItemType.Standard, _ => applyFunction(a))
-                    {
-                        State = { Value = GetStateFromSelection(selection, c => checkFunction(c.Item, a)) }
-                    };
-                });
+                Anchor.TopLeft,
+                Anchor.TopCentre,
+                Anchor.TopRight,
+                Anchor.CentreLeft,
+                Anchor.Centre,
+                Anchor.CentreRight,
+                Anchor.BottomLeft,
+                Anchor.BottomCentre,
+                Anchor.BottomRight,
+            };
+            return displayableAnchors.Select(a =>
+            {
+                return new AnchorMenuItem(a, _ => applyFunction(a));
+            });
+        }
+
+        private partial class AnchorMenuItem : TernaryStateRadioMenuItem
+        {
+            public readonly Anchor Anchor;
+
+            public AnchorMenuItem(Anchor anchor, Action<Anchor> applyFunction)
+                : base(anchor.ToString(), MenuItemType.Standard, _ => applyFunction(anchor))
+            {
+                Anchor = anchor;
             }
         }
 
diff --git a/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs b/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
index 5c840a8357..f4d8e8518e 100644
--- a/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
+++ b/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
@@ -68,6 +68,7 @@ namespace osu.Game.Rulesets.Difficulty
                 cancellationToken = timedCancellationSource.Token;
 
             cancellationToken.ThrowIfCancellationRequested();
+            // ReSharper disable once PossiblyMistakenUseOfCancellationToken
             preProcess(mods, cancellationToken);
 
             var skills = CreateSkills(Beatmap, playableMods, clockRate);
@@ -109,6 +110,7 @@ namespace osu.Game.Rulesets.Difficulty
                 cancellationToken = timedCancellationSource.Token;
 
             cancellationToken.ThrowIfCancellationRequested();
+            // ReSharper disable once PossiblyMistakenUseOfCancellationToken
             preProcess(mods, cancellationToken);
 
             var attribs = new List<TimedDifficultyAttributes>();
diff --git a/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs b/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs
index 4129a6fb2c..2d6e09b3fd 100644
--- a/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs
+++ b/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs
@@ -14,9 +14,9 @@ using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Framework.Utils;
-using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Input;
 using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
 using osu.Game.Overlays.OSD;
@@ -312,9 +312,9 @@ namespace osu.Game.Rulesets.Edit
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuConfigManager config)
+            private void load(RealmKeyBindingStore keyBindingStore)
             {
-                ShortcutText.Text = config.LookupKeyBindings(getAction(change)).ToUpper();
+                ShortcutText.Text = keyBindingStore.GetBindingsStringFor(getAction(change)).ToUpper();
             }
 
             private static GlobalAction getAction(ValueChangedEvent<double> change) => change.NewValue - change.OldValue > 0
diff --git a/osu.Game/Rulesets/Mods/ModRateAdjust.cs b/osu.Game/Rulesets/Mods/ModRateAdjust.cs
index 358034541c..a824731830 100644
--- a/osu.Game/Rulesets/Mods/ModRateAdjust.cs
+++ b/osu.Game/Rulesets/Mods/ModRateAdjust.cs
@@ -34,5 +34,7 @@ namespace osu.Game.Rulesets.Mods
                     yield return ("Speed change", $"{SpeedChange.Value:N2}x");
             }
         }
+
+        public override string ExtendedIconInformation => SpeedChange.IsDefault ? string.Empty : FormattableString.Invariant($"{SpeedChange.Value:N2}x");
     }
 }
diff --git a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
index 1f735576bc..ed9ed1db0a 100644
--- a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
@@ -5,7 +5,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Linq;
 using JetBrains.Annotations;
@@ -16,7 +15,6 @@ using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Lists;
-using osu.Framework.Threading;
 using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Configuration;
@@ -63,6 +61,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         protected PausableSkinnableSound Samples { get; private set; }
 
+        private bool samplesLoaded;
+
         public virtual IEnumerable<HitSampleInfo> GetSamples() => HitObject.Samples;
 
         private readonly List<DrawableHitObject> nestedHitObjects = new List<DrawableHitObject>();
@@ -227,6 +227,12 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
             comboColourBrightness.BindValueChanged(_ => UpdateComboColour());
 
+            samplesBindable.BindCollectionChanged((_, _) =>
+            {
+                if (samplesLoaded)
+                    LoadSamples();
+            });
+
             // Apply transforms
             updateStateFromResult();
         }
@@ -293,8 +299,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
             }
 
             samplesBindable.BindTo(HitObject.SamplesBindable);
-            samplesBindable.BindCollectionChanged(onSamplesChanged, true);
-
             HitObject.DefaultsApplied += onDefaultsApplied;
 
             OnApply();
@@ -335,11 +339,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
             samplesBindable.UnbindFrom(HitObject.SamplesBindable);
 
-            // When a new hitobject is applied, the samples will be cleared before re-populating.
-            // In order to stop this needless update, the event is unbound and re-bound as late as possible in Apply().
-            samplesBindable.CollectionChanged -= onSamplesChanged;
-
             // Release the samples for other hitobjects to use.
+            samplesLoaded = false;
             Samples?.ClearSamples();
 
             foreach (var obj in nestedHitObjects)
@@ -396,8 +397,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
             Samples.Samples = samples.Cast<ISampleInfo>().ToArray();
         }
 
-        private void onSamplesChanged(object sender, NotifyCollectionChangedEventArgs e) => LoadSamples();
-
         private void onNewResult(DrawableHitObject drawableHitObject, JudgementResult result) => OnNewResult?.Invoke(drawableHitObject, result);
 
         private void onRevertResult()
@@ -631,6 +630,33 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         #endregion
 
+        protected override void Update()
+        {
+            // We use a flag here to load samples only when they are required to be played.
+            // Why in Update and not PlaySamples? Because some hit object implementations may expect LoadSamples to be called to load custom samples
+            // (slider slide sound as an example).
+            //
+            // This is best effort optimisation (over previous method of loading and de-pooling in `OnApply`) due to requiring knowledge of
+            // hitobjects' metadata. For cases like sliders with many repeats, there can be a sudden request to de-pool (ie slider with many repeats)
+            // hundreds of samples, causing a gameplay stutter.
+            //
+            // Note that we already have optimisations in OsuPlayfield for this but it applies to DrawableHitObjects and not samples.
+            //
+            // This is definitely not the end of optimisation of sample loading, but the structure of gameplay samples is going to take some
+            // time to dismantle and optimise. Optimally:
+            //
+            // - we would want to remove as much of the drawable overheads from samples as possible (currently two drawables per sample worst case)
+            // - pool the rawest representation of samples possible (if required at that point).
+            // - infer metadata at beatmap load to asynchronously preload the samples (into memory / bass).
+            if (!samplesLoaded)
+            {
+                samplesLoaded = true;
+                LoadSamples();
+            }
+
+            base.Update();
+        }
+
         public override bool UpdateSubTreeMasking() => false;
 
         protected override void UpdateAfterChildren()
@@ -640,14 +666,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
             UpdateResult(false);
         }
 
-        /// <summary>
-        /// Schedules an <see cref="Action"/> to this <see cref="DrawableHitObject"/>.
-        /// </summary>
-        /// <remarks>
-        /// Only provided temporarily until hitobject pooling is implemented.
-        /// </remarks>
-        protected internal new ScheduledDelegate Schedule(Action action) => base.Schedule(action);
-
         /// <summary>
         /// An offset prior to the start time of <see cref="HitObject"/> at which this <see cref="DrawableHitObject"/> may begin displaying contents.
         /// By default, <see cref="DrawableHitObject"/>s are assumed to display their contents within 10 seconds prior to the start time of <see cref="HitObject"/>.
@@ -689,9 +707,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         protected void ApplyResult(HitResult type) => ApplyResult(static (result, state) => result.Type = state, type);
 
-        [Obsolete("Use overload with state, preferrably with static delegates to avoid allocation overhead.")] // Can be removed 2024-07-26
-        protected void ApplyResult(Action<JudgementResult> application) => ApplyResult((r, _) => application(r), this);
-
         protected void ApplyResult(Action<JudgementResult, DrawableHitObject> application) => ApplyResult(application, this);
 
         /// <summary>
diff --git a/osu.Game/Rulesets/Scoring/HitEventExtensions.cs b/osu.Game/Rulesets/Scoring/HitEventExtensions.cs
index fed0c3b51b..01d800a351 100644
--- a/osu.Game/Rulesets/Scoring/HitEventExtensions.cs
+++ b/osu.Game/Rulesets/Scoring/HitEventExtensions.cs
@@ -71,6 +71,26 @@ namespace osu.Game.Rulesets.Scoring
             return timeOffsets.Average();
         }
 
+        /// <summary>
+        /// Calculates the median hit offset/error for a sequence of <see cref="HitEvent"/>s, where negative numbers mean the user hit too early on average.
+        /// </summary>
+        /// <returns>
+        /// A non-null <see langword="double"/> value if unstable rate could be calculated,
+        /// and <see langword="null"/> if unstable rate cannot be calculated due to <paramref name="hitEvents"/> being empty.
+        /// </returns>
+        public static double? CalculateMedianHitError(this IEnumerable<HitEvent> hitEvents)
+        {
+            double[] timeOffsets = hitEvents.Where(AffectsUnstableRate).Select(ev => ev.TimeOffset).OrderBy(x => x).ToArray();
+
+            if (timeOffsets.Length == 0)
+                return null;
+
+            int center = timeOffsets.Length / 2;
+
+            // Use average of the 2 central values if length is even
+            return timeOffsets.Length % 2 == 0 ? (timeOffsets[center - 1] + timeOffsets[center]) / 2 : timeOffsets[center];
+        }
+
         public static bool AffectsUnstableRate(HitEvent e) => AffectsUnstableRate(e.HitObject, e.Result);
         public static bool AffectsUnstableRate(HitObject hitObject, HitResult result) => hitObject.HitWindows != HitWindows.Empty && result.IsHit();
 
diff --git a/osu.Game/Rulesets/UI/DrawableRuleset.cs b/osu.Game/Rulesets/UI/DrawableRuleset.cs
index 13d4b67132..97c4ee45af 100644
--- a/osu.Game/Rulesets/UI/DrawableRuleset.cs
+++ b/osu.Game/Rulesets/UI/DrawableRuleset.cs
@@ -54,7 +54,12 @@ namespace osu.Game.Rulesets.UI
         /// <summary>
         /// The key conversion input manager for this DrawableRuleset.
         /// </summary>
-        protected PassThroughInputManager KeyBindingInputManager;
+        protected PassThroughInputManager KeyBindingInputManager { get; }
+
+        /// <summary>
+        /// This configuration for this DrawableRuleset.
+        /// </summary>
+        protected IRulesetConfigManager Config { get; private set; }
 
         public override double GameplayStartTime => Objects.FirstOrDefault()?.StartTime - 2000 ?? 0;
 
@@ -77,8 +82,26 @@ namespace osu.Game.Rulesets.UI
 
         public override IFrameStableClock FrameStableClock => frameStabilityContainer;
 
+        public override IEnumerable<HitObject> Objects => Beatmap.HitObjects;
+
+        /// <summary>
+        /// The beatmap.
+        /// </summary>
+        [Cached(typeof(IBeatmap))]
+        public readonly Beatmap<TObject> Beatmap;
+
+        [Cached(typeof(IReadOnlyList<Mod>))]
+        public sealed override IReadOnlyList<Mod> Mods { get; }
+
+        [Resolved(CanBeNull = true)]
+        private OnScreenDisplay onScreenDisplay { get; set; }
+
         private readonly PlayfieldAdjustmentContainer playfieldAdjustmentContainer;
 
+        private IDisposable configTracker;
+        private FrameStabilityContainer frameStabilityContainer;
+        private DrawableRulesetDependencies dependencies;
+
         private bool allowBackwardsSeeks;
 
         public override bool AllowBackwardsSeeks
@@ -105,25 +128,6 @@ namespace osu.Game.Rulesets.UI
             }
         }
 
-        /// <summary>
-        /// The beatmap.
-        /// </summary>
-        [Cached(typeof(IBeatmap))]
-        public readonly Beatmap<TObject> Beatmap;
-
-        public override IEnumerable<HitObject> Objects => Beatmap.HitObjects;
-
-        protected IRulesetConfigManager Config { get; private set; }
-
-        [Cached(typeof(IReadOnlyList<Mod>))]
-        public sealed override IReadOnlyList<Mod> Mods { get; }
-
-        private FrameStabilityContainer frameStabilityContainer;
-
-        private OnScreenDisplay onScreenDisplay;
-
-        private DrawableRulesetDependencies dependencies;
-
         /// <summary>
         /// Creates a ruleset visualisation for the provided ruleset and beatmap.
         /// </summary>
@@ -156,6 +160,9 @@ namespace osu.Game.Rulesets.UI
         {
             base.LoadComplete();
 
+            if (Config != null)
+                configTracker = onScreenDisplay?.BeginTracking(this, Config);
+
             IsPaused.ValueChanged += paused =>
             {
                 if (HasReplayLoaded.Value)
@@ -168,13 +175,7 @@ namespace osu.Game.Rulesets.UI
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
             dependencies = new DrawableRulesetDependencies(Ruleset, base.CreateChildDependencies(parent));
-
             Config = dependencies.RulesetConfigManager;
-
-            onScreenDisplay = dependencies.Get<OnScreenDisplay>();
-            if (Config != null)
-                onScreenDisplay?.BeginTracking(this, Config);
-
             return dependencies;
         }
 
@@ -404,11 +405,7 @@ namespace osu.Game.Rulesets.UI
         {
             base.Dispose(isDisposing);
 
-            if (Config != null)
-            {
-                onScreenDisplay?.StopTracking(this, Config);
-                Config = null;
-            }
+            configTracker?.Dispose();
 
             // Dispose the components created by this dependency container.
             dependencies?.Dispose();
diff --git a/osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs b/osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs
index ba3a9bd483..f0b9876b51 100644
--- a/osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs
+++ b/osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -21,6 +19,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Timing;
 using osu.Game.Rulesets.UI.Scrolling.Algorithms;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Rulesets.UI.Scrolling
 {
@@ -69,6 +68,12 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         protected virtual bool UserScrollSpeedAdjustment => true;
 
+        /// <summary>
+        /// Whether at the current point in time, whether scroll speed adjustments should be applied to gameplay.
+        /// This can potentially become false at some point during gameplay for game balance reasons.
+        /// </summary>
+        protected bool AllowScrollSpeedAdjustment => UserScrollSpeedAdjustment && player?.AllowCriticalSettingsAdjustment != false;
+
         /// <summary>
         /// Whether <see cref="TimingControlPoint"/> beat lengths should scale relative to the most common beat length in the <see cref="Beatmap"/>.
         /// </summary>
@@ -84,7 +89,10 @@ namespace osu.Game.Rulesets.UI.Scrolling
         [Cached(Type = typeof(IScrollingInfo))]
         private readonly LocalScrollingInfo scrollingInfo;
 
-        protected DrawableScrollingRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
+        [Resolved]
+        private Player? player { get; set; }
+
+        protected DrawableScrollingRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods = null)
             : base(ruleset, beatmap, mods)
         {
             scrollingInfo = new LocalScrollingInfo();
@@ -195,28 +203,30 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// Adjusts the scroll speed of <see cref="HitObject"/>s.
         /// </summary>
         /// <param name="amount">The amount to adjust by. Greater than 0 if the scroll speed should be increased, less than 0 if it should be decreased.</param>
-        protected virtual void AdjustScrollSpeed(int amount) => this.TransformBindableTo(TimeRange, TimeRange.Value - amount * time_span_step, 200, Easing.OutQuint);
+        protected virtual void AdjustScrollSpeed(int amount)
+        {
+            this.TransformBindableTo(TimeRange, TimeRange.Value - amount * time_span_step, 200, Easing.OutQuint);
+        }
 
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
-            if (!UserScrollSpeedAdjustment)
-                return false;
-
             switch (e.Action)
             {
                 case GlobalAction.IncreaseScrollSpeed:
-                    AdjustScrollSpeed(1);
+                    if (AllowScrollSpeedAdjustment)
+                        AdjustScrollSpeed(1);
                     return true;
 
                 case GlobalAction.DecreaseScrollSpeed:
-                    AdjustScrollSpeed(-1);
+                    if (AllowScrollSpeedAdjustment)
+                        AdjustScrollSpeed(-1);
                     return true;
             }
 
             return false;
         }
 
-        private ScheduledDelegate scheduledScrollSpeedAdjustment;
+        private ScheduledDelegate? scheduledScrollSpeedAdjustment;
 
         public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
         {
diff --git a/osu.Game/Scoring/ScoreImporter.cs b/osu.Game/Scoring/ScoreImporter.cs
index 69c53af16f..4b3f4a5e63 100644
--- a/osu.Game/Scoring/ScoreImporter.cs
+++ b/osu.Game/Scoring/ScoreImporter.cs
@@ -17,6 +17,7 @@ using osu.Game.Scoring.Legacy;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Utils;
 using Realms;
 
 namespace osu.Game.Scoring
@@ -90,6 +91,9 @@ namespace osu.Game.Scoring
             ArgumentNullException.ThrowIfNull(model.BeatmapInfo);
             ArgumentNullException.ThrowIfNull(model.Ruleset);
 
+            if (!ModUtils.CheckCompatibleSet(model.Mods))
+                throw new InvalidOperationException(@"The score specifies an incompatible set of mods!");
+
             if (string.IsNullOrEmpty(model.StatisticsJson))
                 model.StatisticsJson = JsonConvert.SerializeObject(model.Statistics);
 
diff --git a/osu.Game/Screens/Edit/BottomBar.cs b/osu.Game/Screens/Edit/BottomBar.cs
index 6af8217d41..49f3d704bc 100644
--- a/osu.Game/Screens/Edit/BottomBar.cs
+++ b/osu.Game/Screens/Edit/BottomBar.cs
@@ -7,6 +7,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
+using osu.Framework.Input.Events;
 using osu.Framework.Testing;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Screens.Edit.Components;
@@ -92,5 +93,8 @@ namespace osu.Game.Screens.Edit
                 }
             }, true);
         }
+
+        protected override bool OnMouseDown(MouseDownEvent e) => true;
+        protected override bool OnClick(ClickEvent e) => true;
     }
 }
diff --git a/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs b/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
index 22df917992..5386b39190 100644
--- a/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/BeatDivisorControl.cs
@@ -167,6 +167,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }, true);
         }
 
+        protected override bool OnMouseDown(MouseDownEvent e) => true;
+        protected override bool OnClick(ClickEvent e) => true;
+
         private void cycleDivisorType(int direction)
         {
             int totalTypes = Enum.GetValues<BeatDivisorType>().Length;
diff --git a/osu.Game/Screens/Edit/Editor.cs b/osu.Game/Screens/Edit/Editor.cs
index f56380a34d..e238abbb25 100644
--- a/osu.Game/Screens/Edit/Editor.cs
+++ b/osu.Game/Screens/Edit/Editor.cs
@@ -573,6 +573,9 @@ namespace osu.Game.Screens.Edit
             return true;
         }
 
+        [CanBeNull]
+        internal event Action Saved;
+
         /// <summary>
         /// Saves the currently edited beatmap.
         /// </summary>
@@ -601,6 +604,7 @@ namespace osu.Game.Screens.Edit
             isNewBeatmap = false;
             updateLastSavedHash();
             onScreenDisplay?.Display(new BeatmapEditorToast(ToastStrings.BeatmapSaved, editorBeatmap.BeatmapInfo.GetDisplayTitle()));
+            Saved?.Invoke();
             return true;
         }
 
@@ -1262,7 +1266,7 @@ namespace osu.Game.Screens.Edit
             yield return createDifficultyCreationMenu();
             yield return createDifficultySwitchMenu();
             yield return new OsuMenuItemSpacer();
-            yield return new EditorMenuItem(EditorStrings.DeleteDifficulty, MenuItemType.Standard, deleteDifficulty) { Action = { Disabled = Beatmap.Value.BeatmapSetInfo.Beatmaps.Count < 2 } };
+            yield return new EditorMenuItem(EditorStrings.DeleteDifficulty, MenuItemType.Destructive, deleteDifficulty) { Action = { Disabled = Beatmap.Value.BeatmapSetInfo.Beatmaps.Count < 2 } };
             yield return new OsuMenuItemSpacer();
 
             var save = new EditorMenuItem(WebCommonStrings.ButtonsSave, MenuItemType.Standard, () => attemptMutationOperation(Save)) { Hotkey = new Hotkey(PlatformAction.Save) };
diff --git a/osu.Game/Screens/Edit/Setup/DifficultySection.cs b/osu.Game/Screens/Edit/Setup/DifficultySection.cs
index 88241451cf..d0fc9cc3e1 100644
--- a/osu.Game/Screens/Edit/Setup/DifficultySection.cs
+++ b/osu.Game/Screens/Edit/Setup/DifficultySection.cs
@@ -103,6 +103,7 @@ namespace osu.Game.Screens.Edit.Setup
                 {
                     Caption = EditorSetupStrings.TickRate,
                     HintText = EditorSetupStrings.TickRateDescription,
+                    KeyboardStep = 1,
                     Current = new BindableDouble(Beatmap.Difficulty.SliderTickRate)
                     {
                         Default = 1,
diff --git a/osu.Game/Screens/Edit/Setup/MetadataSection.cs b/osu.Game/Screens/Edit/Setup/MetadataSection.cs
index 85247bc15a..735204e2f4 100644
--- a/osu.Game/Screens/Edit/Setup/MetadataSection.cs
+++ b/osu.Game/Screens/Edit/Setup/MetadataSection.cs
@@ -3,7 +3,6 @@
 
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
@@ -26,8 +25,13 @@ namespace osu.Game.Screens.Edit.Setup
         private FormTextBox sourceTextBox = null!;
         private FormTextBox tagsTextBox = null!;
 
+        private bool dirty;
+
         public override LocalisableString Title => EditorSetupStrings.MetadataHeader;
 
+        [Resolved]
+        private Editor? editor { get; set; }
+
         [BackgroundDependencyLoader]
         private void load(SetupScreen? setupScreen)
         {
@@ -68,7 +72,19 @@ namespace osu.Game.Screens.Edit.Setup
             TitleTextBox.Current.BindValueChanged(title => transferIfRomanised(title.NewValue, RomanisedTitleTextBox));
 
             foreach (var item in Children.OfType<FormTextBox>())
-                item.OnCommit += onCommit;
+            {
+                // Apply immediately on any change to ensure that if the user hits Ctrl+S after making a change (without committing)
+                // it will still apply to the beatmap.
+                item.Current.BindValueChanged(_ => applyMetadata());
+                item.OnCommit += (_, newText) =>
+                {
+                    if (newText && dirty)
+                        Beatmap.SaveState();
+                };
+            }
+
+            if (editor != null)
+                editor.Saved += () => dirty = false;
 
             updateReadOnlyState();
         }
@@ -87,15 +103,6 @@ namespace osu.Game.Screens.Edit.Setup
             RomanisedTitleTextBox.ReadOnly = MetadataUtils.IsRomanised(TitleTextBox.Current.Value);
         }
 
-        private void onCommit(TextBox sender, bool newText)
-        {
-            if (!newText) return;
-
-            // for now, update on commit rather than making BeatmapMetadata bindables.
-            // after switching database engines we can reconsider if switching to bindables is a good direction.
-            setMetadata();
-        }
-
         private void reloadMetadata()
         {
             var metadata = Beatmap.Metadata;
@@ -115,20 +122,18 @@ namespace osu.Game.Screens.Edit.Setup
             updateReadOnlyState();
         }
 
-        private void setMetadata()
+        private void applyMetadata()
         {
             Beatmap.Metadata.ArtistUnicode = ArtistTextBox.Current.Value;
             Beatmap.Metadata.Artist = RomanisedArtistTextBox.Current.Value;
-
             Beatmap.Metadata.TitleUnicode = TitleTextBox.Current.Value;
             Beatmap.Metadata.Title = RomanisedTitleTextBox.Current.Value;
-
             Beatmap.Metadata.Author.Username = creatorTextBox.Current.Value;
             Beatmap.BeatmapInfo.DifficultyName = difficultyTextBox.Current.Value;
             Beatmap.Metadata.Source = sourceTextBox.Current.Value;
             Beatmap.Metadata.Tags = tagsTextBox.Current.Value;
 
-            Beatmap.SaveState();
+            dirty = true;
         }
 
         private partial class FormRomanisedTextBox : FormTextBox
diff --git a/osu.Game/Screens/Edit/Setup/ResourcesSection.cs b/osu.Game/Screens/Edit/Setup/ResourcesSection.cs
index cab6eddaa4..a1c81eedec 100644
--- a/osu.Game/Screens/Edit/Setup/ResourcesSection.cs
+++ b/osu.Game/Screens/Edit/Setup/ResourcesSection.cs
@@ -192,7 +192,7 @@ namespace osu.Game.Screens.Edit.Setup
                     // note that this triggers a full save flow, including triggering a difficulty calculation.
                     // this is not a cheap operation and should be reconsidered in the future.
                     var beatmapWorking = beatmaps.GetWorkingBeatmap(b);
-                    beatmaps.Save(b, beatmapWorking.Beatmap, beatmapWorking.GetSkin());
+                    beatmaps.Save(b, beatmapWorking.GetPlayableBeatmap(b.Ruleset), beatmapWorking.GetSkin());
                 }
             }
 
diff --git a/osu.Game/Screens/Edit/Timing/MetronomeDisplay.cs b/osu.Game/Screens/Edit/Timing/MetronomeDisplay.cs
index f3bd9ff257..f91a67a7e3 100644
--- a/osu.Game/Screens/Edit/Timing/MetronomeDisplay.cs
+++ b/osu.Game/Screens/Edit/Timing/MetronomeDisplay.cs
@@ -7,7 +7,6 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
@@ -217,7 +216,7 @@ namespace osu.Game.Screens.Edit.Timing
                 bpmText = new OsuTextFlowContainer(st =>
                 {
                     st.Font = OsuFont.Default.With(fixedWidth: true);
-                    st.Spacing = new Vector2(-2.2f, 0);
+                    st.Spacing = new Vector2(-1.9f, 0);
                 })
                 {
                     Name = @"BPM display",
@@ -233,8 +232,7 @@ namespace osu.Game.Screens.Edit.Timing
         }
 
         private double effectiveBeatLength;
-
-        private double effectiveBpm => 60_000 / effectiveBeatLength;
+        private double effectiveBpm;
 
         private TimingControlPoint timingPoint = null!;
 
@@ -268,19 +266,26 @@ namespace osu.Game.Screens.Edit.Timing
 
         private void updateBpmText()
         {
-            int intPart = (int)interpolatedBpm.Value;
+            bool reachedFinalNumber = interpolatedBpm.Value == effectiveBpm;
+            int decimalPlaces = Math.Min(2, FormatUtils.FindPrecision((decimal)effectiveBpm));
 
-            bpmText.Text = intPart.ToLocalisableString();
+            string text = interpolatedBpm.Value.ToString($"N{decimalPlaces}");
+            int? breakPoint = null;
 
-            // While interpolating between two integer values, showing the decimal places would look a bit odd
-            // so rounding is applied until we're close to the final value.
-            int decimalPlaces = FormatUtils.FindPrecision((decimal)effectiveBpm);
-
-            if (decimalPlaces > 0)
+            for (int i = 0; i < text.Length; i++)
             {
-                bool reachedFinalNumber = intPart == (int)effectiveBpm;
+                if (!char.IsDigit(text[i]))
+                    breakPoint = i;
+            }
 
-                bpmText.AddText((effectiveBpm % 1).ToLocalisableString("." + new string('0', decimalPlaces)), cp => cp.Alpha = reachedFinalNumber ? 0.5f : 0.1f);
+            if (breakPoint != null)
+            {
+                bpmText.Text = text.Substring(0, breakPoint.Value);
+                bpmText.AddText(text.Substring(breakPoint.Value), cp => cp.Alpha = reachedFinalNumber ? 0.5f : 0.2f);
+            }
+            else
+            {
+                bpmText.Text = text;
             }
         }
 
@@ -300,6 +305,7 @@ namespace osu.Game.Screens.Edit.Timing
             if (effectiveBeatLength != timingPoint.BeatLength / Divisor)
             {
                 effectiveBeatLength = timingPoint.BeatLength / Divisor;
+                effectiveBpm = TimingSection.BeatLengthToBpm(effectiveBeatLength);
 
                 EarlyActivationMilliseconds = timingPoint.BeatLength / 2;
 
diff --git a/osu.Game/Screens/Edit/Timing/TimingSection.cs b/osu.Game/Screens/Edit/Timing/TimingSection.cs
index ae1ac02dd6..0c06a4e69b 100644
--- a/osu.Game/Screens/Edit/Timing/TimingSection.cs
+++ b/osu.Game/Screens/Edit/Timing/TimingSection.cs
@@ -115,7 +115,7 @@ namespace osu.Game.Screens.Edit.Timing
                     try
                     {
                         if (double.TryParse(Current.Value, out double doubleVal) && doubleVal > 0)
-                            beatLengthBindable.Value = beatLengthToBpm(doubleVal);
+                            beatLengthBindable.Value = BeatLengthToBpm(doubleVal);
                     }
                     catch
                     {
@@ -130,7 +130,7 @@ namespace osu.Game.Screens.Edit.Timing
 
                 beatLengthBindable.BindValueChanged(val =>
                 {
-                    Current.Value = beatLengthToBpm(val.NewValue).ToString("N2");
+                    Current.Value = BeatLengthToBpm(val.NewValue).ToString("N2");
                 }, true);
             }
 
@@ -146,6 +146,6 @@ namespace osu.Game.Screens.Edit.Timing
             }
         }
 
-        private static double beatLengthToBpm(double beatLength) => 60000 / beatLength;
+        public static double BeatLengthToBpm(double beatLength) => 60000 / beatLength;
     }
 }
diff --git a/osu.Game/Screens/Footer/ScreenFooter.cs b/osu.Game/Screens/Footer/ScreenFooter.cs
index f75250a832..94f4ceeb1a 100644
--- a/osu.Game/Screens/Footer/ScreenFooter.cs
+++ b/osu.Game/Screens/Footer/ScreenFooter.cs
@@ -104,14 +104,14 @@ namespace osu.Game.Screens.Footer
                 },
                 BackButton = new ScreenBackButton
                 {
-                    Margin = new MarginPadding { Bottom = 15f, Left = 12f },
+                    Margin = new MarginPadding { Bottom = OsuGame.SCREEN_EDGE_MARGIN, Left = OsuGame.SCREEN_EDGE_MARGIN },
                     Anchor = Anchor.BottomLeft,
                     Origin = Anchor.BottomLeft,
                     Action = onBackPressed,
                 },
                 hiddenButtonsContainer = new Container<ScreenFooterButton>
                 {
-                    Margin = new MarginPadding { Left = 12f + ScreenBackButton.BUTTON_WIDTH + padding },
+                    Margin = new MarginPadding { Left = OsuGame.SCREEN_EDGE_MARGIN + ScreenBackButton.BUTTON_WIDTH + padding },
                     Y = 10f,
                     Anchor = Anchor.BottomLeft,
                     Origin = Anchor.BottomLeft,
diff --git a/osu.Game/Screens/Footer/ScreenFooterButton.cs b/osu.Game/Screens/Footer/ScreenFooterButton.cs
index 6515203ca0..5e96eadfea 100644
--- a/osu.Game/Screens/Footer/ScreenFooterButton.cs
+++ b/osu.Game/Screens/Footer/ScreenFooterButton.cs
@@ -25,16 +25,12 @@ namespace osu.Game.Screens.Footer
 {
     public partial class ScreenFooterButton : OsuClickableContainer, IKeyBindingHandler<GlobalAction>
     {
-        private const float shear = OsuGame.SHEAR;
-
         protected const int CORNER_RADIUS = 10;
         protected const int BUTTON_HEIGHT = 75;
         protected const int BUTTON_WIDTH = 116;
 
         public Bindable<Visibility> OverlayState = new Bindable<Visibility>();
 
-        protected static readonly Vector2 BUTTON_SHEAR = new Vector2(shear, 0);
-
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
@@ -89,7 +85,7 @@ namespace osu.Game.Screens.Footer
                         Colour = Colour4.Black.Opacity(0.25f),
                         Offset = new Vector2(0, 2),
                     },
-                    Shear = BUTTON_SHEAR,
+                    Shear = OsuGame.SHEAR,
                     Masking = true,
                     CornerRadius = CORNER_RADIUS,
                     RelativeSizeAxes = Axes.Both,
@@ -108,7 +104,7 @@ namespace osu.Game.Screens.Footer
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
-                            Shear = -BUTTON_SHEAR,
+                            Shear = -OsuGame.SHEAR,
                             RelativeSizeAxes = Axes.Both,
                             Children = new Drawable[]
                             {
@@ -135,7 +131,7 @@ namespace osu.Game.Screens.Footer
                         },
                         new Container
                         {
-                            Shear = -BUTTON_SHEAR,
+                            Shear = -OsuGame.SHEAR,
                             Anchor = Anchor.BottomCentre,
                             Origin = Anchor.Centre,
                             Y = -CORNER_RADIUS,
diff --git a/osu.Game/Screens/Menu/MainMenu.cs b/osu.Game/Screens/Menu/MainMenu.cs
index 7d792a6bb8..c7d57f2993 100644
--- a/osu.Game/Screens/Menu/MainMenu.cs
+++ b/osu.Game/Screens/Menu/MainMenu.cs
@@ -106,7 +106,7 @@ namespace osu.Game.Screens.Menu
         private SongTicker songTicker;
         private Container logoTarget;
         private OnlineMenuBanner onlineMenuBanner;
-        private MenuTip menuTip;
+        private MenuTipDisplay menuTipDisplay;
         private FillFlowContainer bottomElementsFlow;
         private SupporterDisplay supporterDisplay;
 
@@ -191,7 +191,7 @@ namespace osu.Game.Screens.Menu
                     Spacing = new Vector2(5),
                     Children = new Drawable[]
                     {
-                        menuTip = new MenuTip
+                        menuTipDisplay = new MenuTipDisplay
                         {
                             Anchor = Anchor.TopCentre,
                             Origin = Anchor.TopCentre,
@@ -206,8 +206,8 @@ namespace osu.Game.Screens.Menu
                 supporterDisplay = new SupporterDisplay
                 {
                     Margin = new MarginPadding(5),
-                    Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.BottomLeft,
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.TopLeft,
                 },
                 holdToExitGameOverlay?.CreateProxy() ?? Empty()
             });
@@ -391,7 +391,7 @@ namespace osu.Game.Screens.Menu
             musicController.EnsurePlayingSomething();
 
             // Cycle tip on resuming
-            menuTip.ShowNextTip();
+            menuTipDisplay.ShowNextTip();
 
             bottomElementsFlow
                 .ScaleTo(1, 1000, Easing.OutQuint)
diff --git a/osu.Game/Screens/Menu/MenuTip.cs b/osu.Game/Screens/Menu/MenuTipDisplay.cs
similarity index 94%
rename from osu.Game/Screens/Menu/MenuTip.cs
rename to osu.Game/Screens/Menu/MenuTipDisplay.cs
index af7cfde52b..283528d22a 100644
--- a/osu.Game/Screens/Menu/MenuTip.cs
+++ b/osu.Game/Screens/Menu/MenuTipDisplay.cs
@@ -18,7 +18,7 @@ using osu.Game.Localisation;
 
 namespace osu.Game.Screens.Menu
 {
-    public partial class MenuTip : CompositeDrawable
+    public partial class MenuTipDisplay : CompositeDrawable
     {
         [Resolved]
         private OsuConfigManager config { get; set; } = null!;
@@ -86,7 +86,12 @@ namespace osu.Game.Screens.Menu
             textFlow.AddParagraph(MenuTipStrings.MenuTipTitle, formatSemiBold);
             textFlow.AddParagraph(tip, formatRegular);
 
-            this.FadeInFromZero(200, Easing.OutQuint)
+            this
+                .FadeOut()
+                .ScaleTo(0.9f)
+                .Delay(600)
+                .FadeInFromZero(800, Easing.OutQuint)
+                .ScaleTo(1, 800, Easing.OutElasticHalf)
                 .Delay(1000 + 80 * tip.ToString().Length)
                 .Then()
                 .FadeOutFromOne(2000, Easing.OutQuint);
diff --git a/osu.Game/Screens/Menu/SupporterDisplay.cs b/osu.Game/Screens/Menu/SupporterDisplay.cs
index be50a54619..9602f4f61d 100644
--- a/osu.Game/Screens/Menu/SupporterDisplay.cs
+++ b/osu.Game/Screens/Menu/SupporterDisplay.cs
@@ -10,6 +10,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Framework.Threading;
+using osu.Framework.Utils;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Online.API;
@@ -53,7 +54,7 @@ namespace osu.Game.Screens.Menu
                 backgroundBox = new Box
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Alpha = 0.4f,
+                    Alpha = 0.6f,
                 },
                 supportFlow = new LinkFlowContainer
                 {
@@ -111,7 +112,7 @@ namespace osu.Game.Screens.Menu
 
             this
                 .FadeOut()
-                .Delay(1000)
+                .Delay(RNG.Next(800, 4000))
                 .FadeInFromZero(800, Easing.OutQuint);
 
             scheduleDismissal();
@@ -128,13 +129,13 @@ namespace osu.Game.Screens.Menu
 
         protected override bool OnHover(HoverEvent e)
         {
-            backgroundBox.FadeTo(0.6f, 500, Easing.OutQuint);
+            backgroundBox.FadeTo(0.8f, 500, Easing.OutQuint);
             return base.OnHover(e);
         }
 
         protected override void OnHoverLost(HoverLostEvent e)
         {
-            backgroundBox.FadeTo(0.4f, 500, Easing.OutQuint);
+            backgroundBox.FadeTo(0.6f, 500, Easing.OutQuint);
             base.OnHoverLost(e);
         }
 
@@ -160,7 +161,7 @@ namespace osu.Game.Screens.Menu
                 this
                     .Delay(200)
                     .FadeOut(750, Easing.Out);
-            }, 6000);
+            }, 8000);
         }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Components/OnlinePlayBackgroundScreen.cs b/osu.Game/Screens/OnlinePlay/Components/OnlinePlayBackgroundScreen.cs
index ef7c1747e9..4f9d1b9246 100644
--- a/osu.Game/Screens/OnlinePlay/Components/OnlinePlayBackgroundScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Components/OnlinePlayBackgroundScreen.cs
@@ -1,12 +1,19 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Threading;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Logging;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Graphics.Backgrounds;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Rooms;
 using osuTK;
 using osuTK.Graphics;
@@ -16,65 +23,57 @@ namespace osu.Game.Screens.OnlinePlay.Components
     public abstract partial class OnlinePlayBackgroundScreen : BackgroundScreen
     {
         private CancellationTokenSource? cancellationSource;
-        private PlaylistItemBackground? background;
+        private Background? lastBackground;
+        private int? beatmapId;
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            switchBackground(new PlaylistItemBackground(playlistItem));
+            loadNewBackground();
         }
 
-        private PlaylistItem? playlistItem;
-
         protected PlaylistItem? PlaylistItem
         {
-            get => playlistItem;
             set
             {
-                if (playlistItem == value)
+                if (beatmapId == value?.Beatmap.OnlineID)
                     return;
 
-                playlistItem = value;
+                beatmapId = value?.Beatmap.OnlineID;
 
-                if (LoadState > LoadState.Ready)
-                    updateBackground();
+                if (LoadState >= LoadState.Ready)
+                    loadNewBackground();
             }
         }
 
-        private void updateBackground()
+        private void loadNewBackground()
         {
-            Schedule(() =>
+            cancellationSource?.Cancel();
+            cancellationSource = new CancellationTokenSource();
+
+            if (beatmapId == null)
+                switchBackground(new DefaultBackground());
+            else
+                LoadComponentAsync(new OnlineBeatmapBackground(beatmapId.Value), switchBackground, cancellationSource.Token);
+
+            void switchBackground(Background newBackground)
             {
-                var beatmap = playlistItem?.Beatmap;
+                float newDepth = 0;
 
-                string? lastCover = (background?.Beatmap?.BeatmapSet as IBeatmapSetOnlineInfo)?.Covers.Cover;
-                string? newCover = (beatmap?.BeatmapSet as IBeatmapSetOnlineInfo)?.Covers.Cover;
+                if (lastBackground != null)
+                {
+                    newDepth = lastBackground.Depth + 1;
+                    lastBackground.FinishTransforms();
+                    lastBackground.FadeOut(250);
+                    lastBackground.Expire();
+                }
 
-                if (lastCover == newCover)
-                    return;
+                newBackground.Depth = newDepth;
+                newBackground.Colour = ColourInfo.GradientVertical(new Color4(0.1f, 0.1f, 0.1f, 1f), new Color4(0.4f, 0.4f, 0.4f, 1f));
+                newBackground.BlurTo(new Vector2(10));
 
-                cancellationSource?.Cancel();
-                LoadComponentAsync(new PlaylistItemBackground(playlistItem), switchBackground, (cancellationSource = new CancellationTokenSource()).Token);
-            });
-        }
-
-        private void switchBackground(PlaylistItemBackground newBackground)
-        {
-            float newDepth = 0;
-
-            if (background != null)
-            {
-                newDepth = background.Depth + 1;
-                background.FinishTransforms();
-                background.FadeOut(250);
-                background.Expire();
+                AddInternal(lastBackground = newBackground);
             }
-
-            newBackground.Depth = newDepth;
-            newBackground.Colour = ColourInfo.GradientVertical(new Color4(0.1f, 0.1f, 0.1f, 1f), new Color4(0.4f, 0.4f, 0.4f, 1f));
-            newBackground.BlurTo(new Vector2(10));
-
-            AddInternal(background = newBackground);
         }
 
         public override void OnSuspending(ScreenTransitionEvent e)
@@ -89,5 +88,48 @@ namespace osu.Game.Screens.OnlinePlay.Components
             this.MoveToX(0);
             return result;
         }
+
+        [LongRunningLoad]
+        private partial class OnlineBeatmapBackground : Background
+        {
+            private readonly int beatmapId;
+
+            public OnlineBeatmapBackground(int beatmapId)
+            {
+                this.beatmapId = beatmapId;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(BeatmapLookupCache lookupCache, LargeTextureStore textures, CancellationToken cancellationToken)
+            {
+                try
+                {
+                    APIBeatmap? beatmap = lookupCache.GetBeatmapAsync(beatmapId, cancellationToken).GetResultSafely();
+                    string? coverImage = beatmap?.BeatmapSet?.Covers.Cover;
+
+                    if (coverImage != null)
+                        Sprite.Texture = textures.Get(coverImage);
+                }
+                catch (OperationCanceledException)
+                {
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error(ex, $"Failed to retrieve cover image for beatmap {beatmapId}.");
+                }
+            }
+        }
+
+        private partial class DefaultBackground : Background
+        {
+            [Resolved]
+            private BeatmapManager beatmapManager { get; set; } = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Sprite.Texture = beatmapManager.DefaultBeatmap.GetBackground();
+            }
+        }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Components/PlaylistItemBackground.cs b/osu.Game/Screens/OnlinePlay/Components/PlaylistItemBackground.cs
deleted file mode 100644
index 6b06eaee1e..0000000000
--- a/osu.Game/Screens/OnlinePlay/Components/PlaylistItemBackground.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics.Textures;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics.Backgrounds;
-using osu.Game.Online.Rooms;
-
-namespace osu.Game.Screens.OnlinePlay.Components
-{
-    public partial class PlaylistItemBackground : Background
-    {
-        public readonly IBeatmapInfo? Beatmap;
-
-        public PlaylistItemBackground(PlaylistItem? playlistItem)
-        {
-            Beatmap = playlistItem?.Beatmap;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(BeatmapManager beatmaps, LargeTextureStore textures)
-        {
-            Texture? texture = null;
-
-            // prefer online cover where available.
-            if (Beatmap?.BeatmapSet is IBeatmapSetOnlineInfo online)
-                texture = textures.Get(online.Covers.Cover);
-
-            Sprite.Texture = texture ?? beatmaps.DefaultBeatmap.GetBackground();
-        }
-
-        public override bool Equals(Background? other)
-        {
-            if (ReferenceEquals(null, other)) return false;
-            if (ReferenceEquals(this, other)) return true;
-
-            return other.GetType() == GetType()
-                   && ((PlaylistItemBackground)other).Beatmap == Beatmap;
-        }
-    }
-}
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs
index cb881ccfe5..893bc4eb5c 100644
--- a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs
@@ -490,7 +490,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
             if (!screen.IsCurrentScreen())
                 return;
 
-            var beatmap = beatmaps.QueryBeatmap(b => b.OnlineID == item.Beatmap.OnlineID);
+            var beatmap = beatmaps.QueryBeatmap($@"{nameof(BeatmapInfo.OnlineID)} == $0 AND {nameof(BeatmapInfo.MD5Hash)} == {nameof(BeatmapInfo.OnlineMD5Hash)}", item.Beatmap.OnlineID);
 
             screen.Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap); // this will gracefully fall back to dummy beatmap if missing locally.
             screen.Ruleset.Value = rulesets.GetRuleset(item.RulesetID);
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeIntro.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeIntro.cs
index 5b423fbc6d..3ec9217aa4 100644
--- a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeIntro.cs
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeIntro.cs
@@ -116,7 +116,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                     RelativeSizeAxes = Axes.Both,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Shear = new Vector2(OsuGame.SHEAR, 0f),
+                    Shear = OsuGame.SHEAR,
                     Children = new Drawable[]
                     {
                         titleContainer = new Container
@@ -147,7 +147,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                                             Origin = Anchor.Centre,
                                             Text = "Today's Challenge",
                                             Margin = new MarginPadding { Horizontal = 10f, Vertical = 5f },
-                                            Shear = new Vector2(-OsuGame.SHEAR, 0f),
+                                            Shear = -OsuGame.SHEAR,
                                             Font = OsuFont.GetFont(size: 32, weight: FontWeight.Light, typeface: Typeface.TorusAlternate),
                                         },
                                     }
@@ -173,7 +173,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                                             Origin = Anchor.Centre,
                                             Text = room.Name.Split(':', StringSplitOptions.TrimEntries).Last(),
                                             Margin = new MarginPadding { Horizontal = 10f, Vertical = 5f },
-                                            Shear = new Vector2(-OsuGame.SHEAR, 0f),
+                                            Shear = -OsuGame.SHEAR,
                                             Font = OsuFont.GetFont(size: 32, weight: FontWeight.Light, typeface: Typeface.TorusAlternate),
                                         },
                                     }
@@ -246,7 +246,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                                                 {
                                                     Anchor = Anchor.TopCentre,
                                                     Origin = Anchor.TopCentre,
-                                                    Shear = new Vector2(-OsuGame.SHEAR, 0f),
+                                                    Shear = -OsuGame.SHEAR,
                                                     MaxWidth = horizontal_info_size,
                                                     Text = beatmap.BeatmapSet!.Metadata.GetDisplayTitleRomanisable(false),
                                                     Padding = new MarginPadding { Horizontal = 5f },
@@ -257,7 +257,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                                                     Text = $"Difficulty: {beatmap.DifficultyName}",
                                                     Font = OsuFont.GetFont(size: 20, italics: true),
                                                     MaxWidth = horizontal_info_size,
-                                                    Shear = new Vector2(-OsuGame.SHEAR, 0f),
+                                                    Shear = -OsuGame.SHEAR,
                                                     Anchor = Anchor.TopCentre,
                                                     Origin = Anchor.TopCentre,
                                                 },
@@ -266,13 +266,13 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                                                     Text = $"by {beatmap.Metadata.Author.Username}",
                                                     Font = OsuFont.GetFont(size: 16, italics: true),
                                                     MaxWidth = horizontal_info_size,
-                                                    Shear = new Vector2(-OsuGame.SHEAR, 0f),
+                                                    Shear = -OsuGame.SHEAR,
                                                     Anchor = Anchor.TopCentre,
                                                     Origin = Anchor.TopCentre,
                                                 },
                                                 starRatingDisplay = new StarRatingDisplay(default)
                                                 {
-                                                    Shear = new Vector2(-OsuGame.SHEAR, 0f),
+                                                    Shear = -OsuGame.SHEAR,
                                                     Margin = new MarginPadding(5),
                                                     Anchor = Anchor.TopCentre,
                                                     Origin = Anchor.TopCentre,
@@ -301,7 +301,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                                             Anchor = Anchor.TopCentre,
                                             Origin = Anchor.TopCentre,
                                             AutoSizeAxes = Axes.Both,
-                                            Shear = new Vector2(-OsuGame.SHEAR, 0f),
+                                            Shear = -OsuGame.SHEAR,
                                             Current =
                                             {
                                                 Value = item.RequiredMods.Select(m => m.ToMod(ruleset)).ToArray()
@@ -329,7 +329,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                 Origin = Anchor.Centre,
                 FillMode = FillMode.Fit,
                 Scale = new Vector2(1.2f),
-                Shear = new Vector2(-OsuGame.SHEAR, 0f),
+                Shear = -OsuGame.SHEAR,
             }, c =>
             {
                 beatmapBackground.Add(c);
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeLeaderboard.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeLeaderboard.cs
index 4736ba28db..401053599e 100644
--- a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeLeaderboard.cs
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallengeLeaderboard.cs
@@ -17,7 +17,7 @@ using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using osu.Game.Screens.SelectV2.Leaderboards;
+using osu.Game.Screens.SelectV2;
 using osuTK;
 
 namespace osu.Game.Screens.OnlinePlay.DailyChallenge
@@ -40,7 +40,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
         private readonly Room room;
         private readonly PlaylistItem playlistItem;
 
-        private FillFlowContainer<LeaderboardScoreV2> scoreFlow = null!;
+        private FillFlowContainer<BeatmapLeaderboardScore> scoreFlow = null!;
         private Container userBestContainer = null!;
         private SectionHeader userBestHeader = null!;
         private LoadingLayer loadingLayer = null!;
@@ -91,7 +91,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                                 new OsuScrollContainer
                                 {
                                     RelativeSizeAxes = Axes.Both,
-                                    Child = scoreFlow = new FillFlowContainer<LeaderboardScoreV2>
+                                    Child = scoreFlow = new FillFlowContainer<BeatmapLeaderboardScore>
                                     {
                                         RelativeSizeAxes = Axes.X,
                                         AutoSizeAxes = Axes.Y,
@@ -158,7 +158,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                 }
                 else
                 {
-                    LoadComponentsAsync(best.Select((s, index) => new LeaderboardScoreV2(s, sheared: false)
+                    LoadComponentsAsync(best.Select((s, index) => new BeatmapLeaderboardScore(s, sheared: false)
                     {
                         Rank = index + 1,
                         IsPersonalBest = s.UserID == api.LocalUser.Value.Id,
@@ -178,7 +178,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
 
                 if (userBest != null)
                 {
-                    userBestContainer.Add(new LeaderboardScoreV2(userBest, sheared: false)
+                    userBestContainer.Add(new BeatmapLeaderboardScore(userBest, sheared: false)
                     {
                         Rank = userBest.Position,
                         IsPersonalBest = true,
diff --git a/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs b/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs
index c9d8365852..423c956d1c 100644
--- a/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs
+++ b/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs
@@ -165,7 +165,8 @@ namespace osu.Game.Screens.OnlinePlay
             d.RequestDeletion = i => RequestDeletion?.Invoke(i);
             d.RequestResults = i =>
             {
-                SelectedItem.Value = i;
+                if (AllowSelection)
+                    SelectedItem.Value = i;
                 RequestResults?.Invoke(i);
             };
             d.RequestEdit = i => RequestEdit?.Invoke(i);
diff --git a/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylistItem.cs b/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylistItem.cs
index 1e1e79d256..85a87b0dff 100644
--- a/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylistItem.cs
+++ b/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylistItem.cs
@@ -31,13 +31,13 @@ using osu.Game.Online.Chat;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Overlays.BeatmapSet;
-using osu.Game.Resources.Localisation.Web;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Users.Drawables;
 using osuTK;
 using osuTK.Graphics;
+using osu.Game.Localisation;
 
 namespace osu.Game.Screens.OnlinePlay
 {
@@ -76,6 +76,7 @@ namespace osu.Game.Screens.OnlinePlay
 
         private readonly DelayedLoadWrapper onScreenLoader;
         private readonly IBindable<bool> valid = new Bindable<bool>();
+        private readonly IBindable<bool> completed = new Bindable<bool>();
 
         private IBeatmapInfo? beatmap;
         private IRulesetInfo? ruleset;
@@ -128,9 +129,7 @@ namespace osu.Game.Screens.OnlinePlay
             Item = item;
 
             valid.BindTo(item.Valid);
-
-            if (item.Expired)
-                Colour = OsuColour.Gray(0.5f);
+            completed.BindTo(item.Completed);
         }
 
         [BackgroundDependencyLoader]
@@ -528,9 +527,27 @@ namespace osu.Game.Screens.OnlinePlay
 
         private IEnumerable<Drawable> createButtons() => new[]
         {
-            beatmap == null ? Empty() : new PlaylistDownloadButton(beatmap),
+            new CompletionIcon
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Visible = { BindTarget = completed }
+            },
+            beatmap == null
+                ? Empty().With(d =>
+                {
+                    d.Anchor = Anchor.Centre;
+                    d.Origin = Anchor.Centre;
+                })
+                : new PlaylistDownloadButton(beatmap)
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
             showResultsButton = new GrayButton(FontAwesome.Solid.ChartPie)
             {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
                 Size = new Vector2(30, 30),
                 Action = () => RequestResults?.Invoke(Item),
                 Alpha = AllowShowingResults ? 1 : 0,
@@ -538,13 +555,17 @@ namespace osu.Game.Screens.OnlinePlay
             },
             editButton = new PlaylistEditButton
             {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
                 Size = new Vector2(30, 30),
                 Alpha = AllowEditing ? 1 : 0,
                 Action = () => RequestEdit?.Invoke(Item),
-                TooltipText = CommonStrings.ButtonsEdit
+                TooltipText = Resources.Localisation.Web.CommonStrings.ButtonsEdit
             },
             removeButton = new PlaylistRemoveButton
             {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
                 Size = new Vector2(30, 30),
                 Alpha = AllowDeletion ? 1 : 0,
                 Action = () => RequestDeletion?.Invoke(Item),
@@ -771,5 +792,64 @@ namespace osu.Game.Screens.OnlinePlay
                 this.allowInteraction = allowInteraction;
             }
         }
+
+        private partial class CompletionIcon : CompositeDrawable, IHasTooltip
+        {
+            public readonly BindableBool Visible = new BindableBool();
+
+            [Resolved]
+            private OsuColour colours { get; set; } = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                InternalChild = new CircularContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(16),
+                    Masking = true,
+                    Colour = colours.Lime0,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        },
+                        new SpriteIcon
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Scale = new Vector2(0.5f),
+                            Colour = OsuColour.Gray(0.5f),
+                            Icon = FontAwesome.Solid.Check
+                        }
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                Visible.BindValueChanged(onVisibleChanged, true);
+            }
+
+            private void onVisibleChanged(ValueChangedEvent<bool> visible)
+            {
+                if (visible.NewValue)
+                {
+                    Size = new Vector2(16);
+                    Alpha = 1;
+                }
+                else
+                {
+                    Size = Vector2.Zero;
+                    Alpha = 0;
+                }
+            }
+
+            public LocalisableString TooltipText => DrawableRoomPlaylistItemStrings.CompletedTooltip;
+        }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
index 0276601656..14edd13ec5 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
@@ -40,10 +40,10 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
         private readonly Bindable<Room?> selectedRoom = new Bindable<Room?>();
 
-        public IReadOnlyList<DrawableRoom> DrawableRooms => roomFlow.FlowingChildren.Cast<DrawableRoom>().ToArray();
+        public IReadOnlyList<RoomPanel> DrawableRooms => roomFlow.FlowingChildren.Cast<RoomPanel>().ToArray();
 
         private readonly ScrollContainer<Drawable> scroll;
-        private readonly FillFlowContainer<DrawableLoungeRoom> roomFlow;
+        private readonly FillFlowContainer<LoungeRoomPanel> roomFlow;
 
         private const float display_scale = 0.8f;
 
@@ -65,7 +65,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 {
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
-                    Child = roomFlow = new FillFlowContainer<DrawableLoungeRoom>
+                    Child = roomFlow = new FillFlowContainer<LoungeRoomPanel>
                     {
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
@@ -128,7 +128,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 return true;
             }
 
-            static bool matchPermissions(DrawableLoungeRoom room, RoomPermissionsFilter accessType)
+            static bool matchPermissions(LoungeRoomPanel room, RoomPermissionsFilter accessType)
             {
                 switch (accessType)
                 {
@@ -183,7 +183,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         {
             foreach (var room in rooms)
             {
-                var drawableRoom = new DrawableLoungeRoom(room)
+                var drawableRoom = new LoungeRoomPanel(room)
                 {
                     SelectedRoom = selectedRoom,
                     Anchor = Anchor.Centre,
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoom.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
similarity index 89%
rename from osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoom.cs
rename to osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
index 491d8071f1..acbf5d8462 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoom.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
@@ -35,7 +35,7 @@ using Container = osu.Framework.Graphics.Containers.Container;
 
 namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 {
-    public abstract partial class DrawableRoom : CompositeDrawable, IHasContextMenu
+    public abstract partial class RoomPanel : CompositeDrawable, IHasContextMenu
     {
         protected const float CORNER_RADIUS = 10;
         private const float height = 100;
@@ -46,24 +46,28 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         [Resolved]
         private OsuGame? game { get; set; }
 
+        [Resolved]
+        private BeatmapLookupCache beatmapLookupCache { get; set; } = null!;
+
         public readonly Room Room;
 
         protected readonly Bindable<PlaylistItem?> SelectedItem = new Bindable<PlaylistItem?>();
         protected Container ButtonsContainer { get; private set; } = null!;
 
-        private readonly Bindable<MatchType> roomType = new Bindable<MatchType>();
-        private readonly Bindable<RoomCategory> roomCategory = new Bindable<RoomCategory>();
-        private readonly Bindable<bool> hasPassword = new Bindable<bool>();
-
         private DrawableRoomParticipantsList? drawableRoomParticipantsList;
         private RoomSpecialCategoryPill? specialCategoryPill;
         private PasswordProtectedIcon? passwordIcon;
         private EndDateInfo? endDateInfo;
         private SpriteText? roomName;
-        private UpdateableBeatmapBackgroundSprite background = null!;
         private DelayedLoadWrapper wrapper = null!;
+        private CancellationTokenSource? beatmapLookupCancellation;
 
-        protected DrawableRoom(Room room)
+        /// <summary>
+        /// A fully-populated representation of the selected item's current beatmap.
+        /// </summary>
+        private readonly Bindable<IBeatmapInfo?> currentBeatmap = new Bindable<IBeatmapInfo?>();
+
+        protected RoomPanel(Room room)
         {
             Room = room;
 
@@ -99,9 +103,10 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                     RelativeSizeAxes = Axes.Both,
                     Colour = colours.Background5,
                 },
-                background = CreateBackground().With(d =>
+                CreateBackground().With(d =>
                 {
                     d.RelativeSizeAxes = Axes.Both;
+                    d.Beatmap.BindTarget = currentBeatmap;
                 }),
                 wrapper = new DelayedLoadWrapper(() =>
                     new Container
@@ -206,7 +211,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                                                     },
                                                                     new RoomStatusText(Room)
                                                                     {
-                                                                        SelectedItem = { BindTarget = SelectedItem }
+                                                                        Beatmap = { BindTarget = currentBeatmap }
                                                                     }
                                                                 }
                                                             }
@@ -280,7 +285,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 updateRoomHasPassword();
             };
 
-            SelectedItem.BindValueChanged(item => background.Beatmap.Value = item.NewValue?.Beatmap, true);
+            SelectedItem.BindValueChanged(onSelectedItemChanged, true);
         }
 
         private void onRoomPropertyChanged(object? sender, PropertyChangedEventArgs e)
@@ -305,6 +310,31 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             }
         }
 
+        private void onSelectedItemChanged(ValueChangedEvent<PlaylistItem?> item)
+        {
+            if (item.NewValue?.Beatmap.OnlineID == item.OldValue?.Beatmap.OnlineID)
+                return;
+
+            beatmapLookupCancellation?.Cancel();
+            beatmapLookupCancellation?.Dispose();
+            beatmapLookupCancellation = null;
+
+            if (item.NewValue?.Beatmap == null)
+            {
+                currentBeatmap.Value = null;
+                return;
+            }
+
+            var cancellationSource = beatmapLookupCancellation = new CancellationTokenSource();
+
+            beatmapLookupCache.GetBeatmapAsync(item.NewValue.Beatmap.OnlineID, cancellationSource.Token)
+                              .ContinueWith(task => Schedule(() =>
+                              {
+                                  if (!cancellationSource.IsCancellationRequested)
+                                      currentBeatmap.Value = task.GetResultSafely();
+                              }), cancellationSource.Token);
+        }
+
         private void updateRoomName()
         {
             if (roomName != null)
@@ -406,14 +436,11 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
         private partial class RoomStatusText : CompositeDrawable
         {
-            public readonly IBindable<PlaylistItem?> SelectedItem = new Bindable<PlaylistItem?>();
+            public readonly Bindable<IBeatmapInfo?> Beatmap = new Bindable<IBeatmapInfo?>();
 
             [Resolved]
             private OsuColour colours { get; set; } = null!;
 
-            [Resolved]
-            private BeatmapLookupCache beatmapLookupCache { get; set; } = null!;
-
             private readonly Room room;
             private SpriteText statusText = null!;
             private LinkFlowContainer beatmapText = null!;
@@ -469,14 +496,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             protected override void LoadComplete()
             {
                 base.LoadComplete();
-                SelectedItem.BindValueChanged(onSelectedItemChanged, true);
+
+                Beatmap.BindValueChanged(onBeatmapChanged, true);
             }
 
-            private CancellationTokenSource? beatmapLookupCancellation;
-
-            private void onSelectedItemChanged(ValueChangedEvent<PlaylistItem?> item)
+            private void onBeatmapChanged(ValueChangedEvent<IBeatmapInfo?> beatmap)
             {
-                beatmapLookupCancellation?.Cancel();
                 beatmapText.Clear();
 
                 if (room.Type == MatchType.Playlists)
@@ -485,31 +510,17 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                     return;
                 }
 
-                var beatmap = item.NewValue?.Beatmap;
-                if (beatmap == null)
-                    return;
+                statusText.Text = "Currently playing ";
 
-                var cancellationSource = beatmapLookupCancellation = new CancellationTokenSource();
-                beatmapLookupCache.GetBeatmapAsync(beatmap.OnlineID, cancellationSource.Token)
-                                  .ContinueWith(task => Schedule(() =>
-                                  {
-                                      if (cancellationSource.IsCancellationRequested)
-                                          return;
-
-                                      var retrievedBeatmap = task.GetResultSafely();
-
-                                      statusText.Text = "Currently playing ";
-
-                                      if (retrievedBeatmap != null)
-                                      {
-                                          beatmapText.AddLink(retrievedBeatmap.GetDisplayTitleRomanisable(),
-                                              LinkAction.OpenBeatmap,
-                                              retrievedBeatmap.OnlineID.ToString(),
-                                              creationParameters: s => s.Truncate = true);
-                                      }
-                                      else
-                                          beatmapText.AddText("unknown beatmap");
-                                  }), cancellationSource.Token);
+                if (beatmap.NewValue != null)
+                {
+                    beatmapText.AddLink(beatmap.NewValue.GetDisplayTitleRomanisable(),
+                        LinkAction.OpenBeatmap,
+                        beatmap.NewValue.OnlineID.ToString(),
+                        creationParameters: s => s.Truncate = true);
+                }
+                else
+                    beatmapText.AddText("unknown beatmap");
             }
         }
 
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/IOnlinePlayLounge.cs b/osu.Game/Screens/OnlinePlay/Lounge/IOnlinePlayLounge.cs
index 73ab84af13..c9f6921328 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/IOnlinePlayLounge.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/IOnlinePlayLounge.cs
@@ -14,8 +14,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
         /// <param name="room">The room to join.</param>
         /// <param name="password">The password.</param>
         /// <param name="onSuccess">A delegate to invoke if the user joined the room.</param>
-        /// <param name="onFailure">A delegate to invoke if the user is not able join the room.</param>
-        void Join(Room room, string? password, Action<Room>? onSuccess = null, Action<string>? onFailure = null);
+        /// <param name="onFailure">A delegate to invoke if the user is not able to join the room.</param>
+        void Join(Room room, string? password, Action<Room>? onSuccess = null, Action<string, Exception?>? onFailure = null);
 
         /// <summary>
         /// Copies the given room and opens it as a fresh (not-yet-created) one.
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs b/osu.Game/Screens/OnlinePlay/Lounge/LoungeRoomPanel.cs
similarity index 95%
rename from osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs
rename to osu.Game/Screens/OnlinePlay/Lounge/LoungeRoomPanel.cs
index d369722e5f..3ff27a14bb 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/LoungeRoomPanel.cs
@@ -17,6 +17,7 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
+using osu.Framework.Logging;
 using osu.Game.Extensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
@@ -36,9 +37,9 @@ using Container = osu.Framework.Graphics.Containers.Container;
 namespace osu.Game.Screens.OnlinePlay.Lounge
 {
     /// <summary>
-    /// A <see cref="DrawableRoom"/> with lounge-specific interactions such as selection and hover sounds.
+    /// A <see cref="RoomPanel"/> with lounge-specific interactions such as selection and hover sounds.
     /// </summary>
-    public partial class DrawableLoungeRoom : DrawableRoom, IFilterable, IHasPopover, IKeyBindingHandler<GlobalAction>
+    public partial class LoungeRoomPanel : RoomPanel, IFilterable, IHasPopover, IKeyBindingHandler<GlobalAction>
     {
         private const float transition_duration = 60;
         private const float selection_border_width = 4;
@@ -63,7 +64,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
         private Sample? sampleJoin;
         private Drawable selectionBox = null!;
 
-        public DrawableLoungeRoom(Room room)
+        public LoungeRoomPanel(Room room)
             : base(room)
         {
         }
@@ -306,13 +307,14 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
                 GetContainingFocusManager()?.TriggerFocusContention(passwordTextBox);
             }
 
-            private void joinFailed(string error) => Schedule(() =>
+            private void joinFailed(string message, Exception? exception) => Schedule(() =>
             {
                 passwordTextBox.Text = string.Empty;
 
                 GetContainingFocusManager()!.ChangeFocus(passwordTextBox);
 
-                errorText.Text = error;
+                Logger.Log($"Failed to join room with password. {exception}");
+                errorText.Text = message;
                 errorText
                     .FadeIn()
                     .FlashColour(Color4.White, 200)
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
index c455020f9a..a4e808ff76 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
@@ -334,7 +334,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
             popoverContainer.HidePopover();
         }
 
-        public void Join(Room room, string? password, Action<Room>? onSuccess = null, Action<string>? onFailure = null) => Schedule(() =>
+        public void Join(Room room, string? password, Action<Room>? onSuccess = null, Action<string, Exception?>? onFailure = null) => Schedule(() =>
         {
             if (joiningRoomOperation != null)
                 return;
@@ -347,19 +347,19 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
                 joiningRoomOperation?.Dispose();
                 joiningRoomOperation = null;
                 onSuccess?.Invoke(room);
-            }, error =>
+            }, (message, exception) =>
             {
                 joiningRoomOperation?.Dispose();
                 joiningRoomOperation = null;
 
                 if (onFailure != null)
-                    onFailure(error);
+                    onFailure(message, exception);
                 else
-                    Logger.Log(error, level: LogLevel.Error);
+                    Logger.Error(exception, message);
             });
         });
 
-        protected abstract void JoinInternal(Room room, string? password, Action<Room> onSuccess, Action<string> onFailure);
+        protected abstract void JoinInternal(Room room, string? password, Action<Room> onSuccess, Action<string, Exception?> onFailure);
 
         public void OpenCopy(Room room)
         {
diff --git a/osu.Game/Screens/OnlinePlay/Match/DrawableMatchRoom.cs b/osu.Game/Screens/OnlinePlay/Match/DrawableMatchRoom.cs
deleted file mode 100644
index b10e83a05c..0000000000
--- a/osu.Game/Screens/OnlinePlay/Match/DrawableMatchRoom.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.ComponentModel;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Game.Beatmaps.Drawables;
-using osu.Game.Online.API;
-using osu.Game.Online.Rooms;
-using osu.Game.Screens.OnlinePlay.Lounge.Components;
-using osu.Game.Screens.OnlinePlay.Match.Components;
-using osuTK;
-
-namespace osu.Game.Screens.OnlinePlay.Match
-{
-    public partial class DrawableMatchRoom : DrawableRoom
-    {
-        public Action? OnEdit;
-
-        public new required Bindable<PlaylistItem?> SelectedItem
-        {
-            get => selectedItem;
-            set => selectedItem.Current = value;
-        }
-
-        public Drawable? ChangeSettingsButton { get; private set; }
-
-        [Resolved]
-        private IAPIProvider api { get; set; } = null!;
-
-        private readonly BindableWithCurrent<PlaylistItem?> selectedItem = new BindableWithCurrent<PlaylistItem?>();
-        private readonly bool allowEdit;
-
-        public DrawableMatchRoom(Room room, bool allowEdit = true)
-            : base(room)
-        {
-            this.allowEdit = allowEdit;
-
-            base.SelectedItem.BindTo(SelectedItem);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            if (allowEdit)
-            {
-                ButtonsContainer.Add(ChangeSettingsButton = new PurpleRoundedButton
-                {
-                    RelativeSizeAxes = Axes.Y,
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Size = new Vector2(120, 0.7f),
-                    Text = "Change settings",
-                    Action = () => OnEdit?.Invoke()
-                });
-            }
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Room.PropertyChanged += onRoomPropertyChanged;
-            updateRoomHost();
-        }
-
-        private void onRoomPropertyChanged(object? sender, PropertyChangedEventArgs e)
-        {
-            if (e.PropertyName == nameof(Room.Host))
-                updateRoomHost();
-        }
-
-        private void updateRoomHost()
-        {
-            if (ChangeSettingsButton != null)
-                ChangeSettingsButton.Alpha = Room.Host?.Equals(api.LocalUser.Value) == true ? 1 : 0;
-        }
-
-        protected override UpdateableBeatmapBackgroundSprite CreateBackground() => base.CreateBackground().With(d =>
-        {
-            d.BackgroundLoadDelay = 0;
-        });
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            Room.PropertyChanged -= onRoomPropertyChanged;
-        }
-    }
-}
diff --git a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
deleted file mode 100644
index eca59c8393..0000000000
--- a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
+++ /dev/null
@@ -1,572 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Audio.Sample;
-using osu.Framework.Bindables;
-using osu.Framework.Extensions.Color4Extensions;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Screens;
-using osu.Game.Audio;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics.Cursor;
-using osu.Game.Online.API;
-using osu.Game.Online.Rooms;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Mods;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Screens.Menu;
-using osu.Game.Screens.OnlinePlay.Match.Components;
-using osu.Game.Screens.OnlinePlay.Multiplayer;
-using osu.Game.Utils;
-using Container = osu.Framework.Graphics.Containers.Container;
-
-namespace osu.Game.Screens.OnlinePlay.Match
-{
-    [Cached(typeof(IPreviewTrackOwner))]
-    public abstract partial class RoomSubScreen : OnlinePlaySubScreen, IPreviewTrackOwner
-    {
-        public readonly Bindable<PlaylistItem?> SelectedItem = new Bindable<PlaylistItem?>();
-
-        public override bool? ApplyModTrackAdjustments => true;
-
-        protected override BackgroundScreen CreateBackground() => new RoomBackgroundScreen(Room.Playlist.FirstOrDefault())
-        {
-            SelectedItem = { BindTarget = SelectedItem }
-        };
-
-        public override bool DisallowExternalBeatmapRulesetChanges => true;
-
-        /// <summary>
-        /// A container that provides controls for selection of user mods.
-        /// This will be shown/hidden automatically when applicable.
-        /// </summary>
-        protected Drawable UserModsSection = null!;
-
-        /// <summary>
-        /// A container that provides controls for selection of the user style.
-        /// This will be shown/hidden automatically when applicable.
-        /// </summary>
-        protected Drawable UserStyleSection = null!;
-
-        /// <summary>
-        /// A container that will display the user's style.
-        /// </summary>
-        protected Container<DrawableRoomPlaylistItem> UserStyleDisplayContainer = null!;
-
-        private Sample? sampleStart;
-
-        /// <summary>
-        /// Any mods applied by/to the local user.
-        /// </summary>
-        protected readonly Bindable<IReadOnlyList<Mod>> UserMods = new Bindable<IReadOnlyList<Mod>>(Array.Empty<Mod>());
-
-        [Resolved(CanBeNull = true)]
-        private IOverlayManager? overlayManager { get; set; }
-
-        [Resolved]
-        private MusicController music { get; set; } = null!;
-
-        [Resolved]
-        private BeatmapManager beatmapManager { get; set; } = null!;
-
-        [Resolved]
-        protected RulesetStore Rulesets { get; private set; } = null!;
-
-        [Resolved]
-        protected IAPIProvider API { get; private set; } = null!;
-
-        [Resolved(canBeNull: true)]
-        protected OnlinePlayScreen? ParentScreen { get; private set; }
-
-        [Resolved]
-        private PreviewTrackManager previewTrackManager { get; set; } = null!;
-
-        [Resolved(canBeNull: true)]
-        protected IDialogOverlay? DialogOverlay { get; private set; }
-
-        [Cached(typeof(OnlinePlayBeatmapAvailabilityTracker))]
-        private readonly MultiplayerBeatmapAvailabilityTracker beatmapAvailabilityTracker = new MultiplayerBeatmapAvailabilityTracker();
-
-        protected IBindable<BeatmapAvailability> BeatmapAvailability => beatmapAvailabilityTracker.Availability;
-
-        public readonly Room Room;
-        private readonly bool allowEdit;
-
-        internal ModSelectOverlay UserModsSelectOverlay { get; private set; } = null!;
-
-        private IDisposable? userModsSelectOverlayRegistration;
-        private RoomSettingsOverlay settingsOverlay = null!;
-        private Drawable mainContent = null!;
-
-        /// <summary>
-        /// Creates a new <see cref="RoomSubScreen"/>.
-        /// </summary>
-        /// <param name="room">The <see cref="Room"/>.</param>
-        /// <param name="allowEdit">Whether to allow editing room settings post-creation.</param>
-        protected RoomSubScreen(Room room, bool allowEdit = true)
-        {
-            Room = room;
-            this.allowEdit = allowEdit;
-
-            Padding = new MarginPadding { Top = Header.HEIGHT };
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
-        {
-            sampleStart = audio.Samples.Get(@"SongSelect/confirm-selection");
-
-            InternalChild = new PopoverContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
-                {
-                    beatmapAvailabilityTracker,
-                    new MultiplayerRoomSounds(),
-                    new GridContainer
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        RowDimensions = new[]
-                        {
-                            new Dimension(),
-                            new Dimension(GridSizeMode.Absolute, 50)
-                        },
-                        Content = new[]
-                        {
-                            // Padded main content (drawable room + main content)
-                            new Drawable[]
-                            {
-                                new Container
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Padding = new MarginPadding
-                                    {
-                                        Horizontal = WaveOverlayContainer.WIDTH_PADDING,
-                                        Bottom = 30
-                                    },
-                                    Children = new[]
-                                    {
-                                        mainContent = new GridContainer
-                                        {
-                                            RelativeSizeAxes = Axes.Both,
-                                            RowDimensions = new[]
-                                            {
-                                                new Dimension(GridSizeMode.AutoSize),
-                                                new Dimension(GridSizeMode.Absolute, 10)
-                                            },
-                                            Content = new[]
-                                            {
-                                                new Drawable[]
-                                                {
-                                                    new OsuContextMenuContainer
-                                                    {
-                                                        RelativeSizeAxes = Axes.X,
-                                                        AutoSizeAxes = Axes.Y,
-                                                        Child = new DrawableMatchRoom(Room, allowEdit)
-                                                        {
-                                                            OnEdit = () => settingsOverlay.Show(),
-                                                            SelectedItem = SelectedItem
-                                                        }
-                                                    }
-                                                },
-                                                null,
-                                                new Drawable[]
-                                                {
-                                                    new Container
-                                                    {
-                                                        RelativeSizeAxes = Axes.Both,
-                                                        Children = new[]
-                                                        {
-                                                            new Container
-                                                            {
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                Masking = true,
-                                                                CornerRadius = 10,
-                                                                Child = new Box
-                                                                {
-                                                                    RelativeSizeAxes = Axes.Both,
-                                                                    Colour = Color4Extensions.FromHex(@"3e3a44") // Temporary.
-                                                                },
-                                                            },
-                                                            new Container
-                                                            {
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                Padding = new MarginPadding(20),
-                                                                Child = CreateMainContent(),
-                                                            },
-                                                            new Container
-                                                            {
-                                                                Anchor = Anchor.BottomLeft,
-                                                                Origin = Anchor.BottomLeft,
-                                                                RelativeSizeAxes = Axes.X,
-                                                                AutoSizeAxes = Axes.Y,
-                                                            },
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        },
-                                        new Container
-                                        {
-                                            RelativeSizeAxes = Axes.Both,
-                                            // Resolves 1px masking errors between the settings overlay and the room panel.
-                                            Padding = new MarginPadding(-1),
-                                            Child = settingsOverlay = CreateRoomSettingsOverlay(Room)
-                                        }
-                                    },
-                                },
-                            },
-                            // Footer
-                            new Drawable[]
-                            {
-                                new Container
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Children = new Drawable[]
-                                    {
-                                        new Box
-                                        {
-                                            RelativeSizeAxes = Axes.Both,
-                                            Colour = Color4Extensions.FromHex(@"28242d") // Temporary.
-                                        },
-                                        new Container
-                                        {
-                                            RelativeSizeAxes = Axes.Both,
-                                            Padding = new MarginPadding(5),
-                                            Child = CreateFooter()
-                                        },
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            };
-
-            LoadComponent(UserModsSelectOverlay = new RoomModSelectOverlay
-            {
-                SelectedItem = { BindTarget = SelectedItem },
-                SelectedMods = { BindTarget = UserMods },
-                IsValidMod = _ => false
-            });
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            SelectedItem.BindValueChanged(_ => updateSpecifics());
-            UserMods.BindValueChanged(_ => updateSpecifics());
-
-            beatmapAvailabilityTracker.Availability.BindValueChanged(_ => updateSpecifics());
-
-            userModsSelectOverlayRegistration = overlayManager?.RegisterBlockingOverlay(UserModsSelectOverlay);
-
-            Room.PropertyChanged += onRoomPropertyChanged;
-            updateSetupState();
-        }
-
-        private void onRoomPropertyChanged(object? sender, PropertyChangedEventArgs e)
-        {
-            if (e.PropertyName == nameof(Room.RoomID))
-                updateSetupState();
-        }
-
-        private void updateSetupState()
-        {
-            if (Room.RoomID == null)
-            {
-                // A new room is being created.
-                // The main content should be hidden until the settings overlay is hidden, signaling the room is ready to be displayed.
-                mainContent.Hide();
-                settingsOverlay.Show();
-            }
-            else
-            {
-                mainContent.Show();
-                settingsOverlay.Hide();
-            }
-        }
-
-        protected virtual bool IsConnected => API.State.Value == APIState.Online;
-
-        public override bool OnBackButton()
-        {
-            if (Room.RoomID == null)
-            {
-                if (!ensureExitConfirmed())
-                    return true;
-
-                settingsOverlay.Hide();
-                return base.OnBackButton();
-            }
-
-            if (UserModsSelectOverlay.State.Value == Visibility.Visible)
-            {
-                UserModsSelectOverlay.Hide();
-                return true;
-            }
-
-            if (settingsOverlay.State.Value == Visibility.Visible)
-            {
-                settingsOverlay.Hide();
-                return true;
-            }
-
-            return base.OnBackButton();
-        }
-
-        protected void ShowUserModSelect() => UserModsSelectOverlay.Show();
-
-        public override void OnEntering(ScreenTransitionEvent e)
-        {
-            base.OnEntering(e);
-            beginHandlingTrack();
-        }
-
-        public override void OnSuspending(ScreenTransitionEvent e)
-        {
-            // Should be a noop in most cases, but let's ensure beyond doubt that the beatmap is in a correct state.
-            updateSpecifics();
-
-            onLeaving();
-            base.OnSuspending(e);
-        }
-
-        public override void OnResuming(ScreenTransitionEvent e)
-        {
-            base.OnResuming(e);
-
-            updateSpecifics();
-
-            beginHandlingTrack();
-        }
-
-        protected bool ExitConfirmed { get; private set; }
-
-        public override bool OnExiting(ScreenExitEvent e)
-        {
-            if (!ensureExitConfirmed())
-                return true;
-
-            if (Room.RoomID != null)
-                PartRoom();
-
-            Mods.Value = Array.Empty<Mod>();
-
-            onLeaving();
-
-            return base.OnExiting(e);
-        }
-
-        /// <summary>
-        /// Parts from the current room.
-        /// </summary>
-        protected abstract void PartRoom();
-
-        private bool ensureExitConfirmed()
-        {
-            if (ExitConfirmed)
-                return true;
-
-            if (!IsConnected)
-                return true;
-
-            bool hasUnsavedChanges = Room.RoomID == null && Room.Playlist.Count > 0;
-
-            if (DialogOverlay == null || !hasUnsavedChanges)
-                return true;
-
-            // if the dialog is already displayed, block exiting until the user explicitly makes a decision.
-            if (DialogOverlay.CurrentDialog is ConfirmDiscardChangesDialog discardChangesDialog)
-            {
-                discardChangesDialog.Flash();
-                return false;
-            }
-
-            DialogOverlay.Push(new ConfirmDiscardChangesDialog(() =>
-            {
-                ExitConfirmed = true;
-                settingsOverlay.Hide();
-                this.Exit();
-            }));
-
-            return false;
-        }
-
-        protected void StartPlay()
-        {
-            if (SelectedItem.Value is not PlaylistItem item)
-                return;
-
-            item = item.With(
-                ruleset: GetGameplayRuleset().OnlineID,
-                beatmap: new Optional<IBeatmapInfo>(GetGameplayBeatmap()));
-
-            // User may be at song select or otherwise when the host starts gameplay.
-            // Ensure that they first return to this screen, else global bindables (beatmap etc.) may be in a bad state.
-            if (!this.IsCurrentScreen())
-            {
-                this.MakeCurrent();
-
-                Schedule(StartPlay);
-                return;
-            }
-
-            sampleStart?.Play();
-
-            // fallback is to allow this class to operate when there is no parent OnlineScreen (testing purposes).
-            var targetScreen = (Screen?)ParentScreen ?? this;
-
-            targetScreen.Push(CreateGameplayScreen(item));
-        }
-
-        /// <summary>
-        /// Creates the gameplay screen to be entered.
-        /// </summary>
-        /// <param name="selectedItem">The playlist item about to be played.</param>
-        /// <returns>The screen to enter.</returns>
-        protected abstract Screen CreateGameplayScreen(PlaylistItem selectedItem);
-
-        private void updateSpecifics()
-        {
-            if (!this.IsCurrentScreen() || SelectedItem.Value is not PlaylistItem item)
-                return;
-
-            var rulesetInstance = GetGameplayRuleset().CreateInstance();
-
-            Mod[] allowedMods = item.Freestyle
-                ? rulesetInstance.AllMods.OfType<Mod>().Where(m => ModUtils.IsValidFreeModForMatchType(m, Room.Type)).ToArray()
-                : item.AllowedMods.Select(m => m.ToMod(rulesetInstance)).ToArray();
-
-            // Remove any user mods that are no longer allowed.
-            Mod[] newUserMods = UserMods.Value.Where(m => allowedMods.Any(a => m.GetType() == a.GetType())).ToArray();
-            if (!newUserMods.SequenceEqual(UserMods.Value))
-                UserMods.Value = newUserMods;
-
-            // Retrieve the corresponding local beatmap, since we can't directly use the playlist's beatmap info
-            int beatmapId = GetGameplayBeatmap().OnlineID;
-            var localBeatmap = beatmapManager.QueryBeatmap(b => b.OnlineID == beatmapId);
-            Beatmap.Value = beatmapManager.GetWorkingBeatmap(localBeatmap);
-            UserModsSelectOverlay.Beatmap.Value = Beatmap.Value;
-
-            Mods.Value = GetGameplayMods().Select(m => m.ToMod(rulesetInstance)).ToArray();
-            Ruleset.Value = GetGameplayRuleset();
-
-            if (allowedMods.Length > 0)
-            {
-                UserModsSection.Show();
-                UserModsSelectOverlay.IsValidMod = m => allowedMods.Any(a => a.GetType() == m.GetType());
-            }
-            else
-            {
-                UserModsSection.Hide();
-                UserModsSelectOverlay.Hide();
-                UserModsSelectOverlay.IsValidMod = _ => false;
-            }
-
-            if (item.Freestyle)
-            {
-                UserStyleSection.Show();
-
-                PlaylistItem gameplayItem = SelectedItem.Value.With(ruleset: GetGameplayRuleset().OnlineID, beatmap: new Optional<IBeatmapInfo>(GetGameplayBeatmap()));
-                PlaylistItem? currentItem = UserStyleDisplayContainer.SingleOrDefault()?.Item;
-
-                if (gameplayItem.Equals(currentItem))
-                    return;
-
-                UserStyleDisplayContainer.Child = new DrawableRoomPlaylistItem(gameplayItem, true)
-                {
-                    AllowReordering = false,
-                    AllowEditing = true,
-                    RequestEdit = _ => OpenStyleSelection()
-                };
-            }
-            else
-                UserStyleSection.Hide();
-        }
-
-        protected virtual APIMod[] GetGameplayMods() => UserMods.Value.Select(m => new APIMod(m)).Concat(SelectedItem.Value!.RequiredMods).ToArray();
-
-        protected virtual RulesetInfo GetGameplayRuleset() => Rulesets.GetRuleset(SelectedItem.Value!.RulesetID)!;
-
-        protected virtual IBeatmapInfo GetGameplayBeatmap() => SelectedItem.Value!.Beatmap;
-
-        protected abstract void OpenStyleSelection();
-
-        private void beginHandlingTrack()
-        {
-            Beatmap.BindValueChanged(applyLoopingToTrack, true);
-        }
-
-        private void onLeaving()
-        {
-            UserModsSelectOverlay.Hide();
-            endHandlingTrack();
-
-            previewTrackManager.StopAnyPlaying(this);
-        }
-
-        private void endHandlingTrack()
-        {
-            Beatmap.ValueChanged -= applyLoopingToTrack;
-            cancelTrackLooping();
-        }
-
-        private void applyLoopingToTrack(ValueChangedEvent<WorkingBeatmap>? _ = null)
-        {
-            if (!this.IsCurrentScreen())
-                return;
-
-            var track = Beatmap.Value?.Track;
-
-            if (track != null)
-            {
-                Beatmap.Value!.PrepareTrackForPreview(true);
-                music.EnsurePlayingSomething();
-            }
-        }
-
-        private void cancelTrackLooping()
-        {
-            var track = Beatmap.Value?.Track;
-
-            if (track != null)
-                track.Looping = false;
-        }
-
-        /// <summary>
-        /// Creates the main centred content.
-        /// </summary>
-        protected abstract Drawable CreateMainContent();
-
-        /// <summary>
-        /// Creates the footer content.
-        /// </summary>
-        protected abstract Drawable CreateFooter();
-
-        /// <summary>
-        /// Creates the room settings overlay.
-        /// </summary>
-        /// <param name="room">The room to change the settings of.</param>
-        protected abstract RoomSettingsOverlay CreateRoomSettingsOverlay(Room room);
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            userModsSelectOverlayRegistration?.Dispose();
-            Room.PropertyChanged -= onRoomPropertyChanged;
-        }
-    }
-}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/GameplayChatDisplay.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/GameplayChatDisplay.cs
index befaf115ae..c7b65856e6 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/GameplayChatDisplay.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/GameplayChatDisplay.cs
@@ -6,9 +6,10 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Game.Input;
 using osu.Game.Input.Bindings;
-using osu.Game.Localisation;
 using osu.Game.Online.Rooms;
+using osu.Game.Resources.Localisation.Web;
 using osu.Game.Screens.OnlinePlay.Match.Components;
 using osu.Game.Screens.Play;
 
@@ -30,23 +31,29 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         private readonly Bindable<bool> expandedFromTextBoxFocus = new Bindable<bool>();
 
         private const float height = 100;
+        private const float width = 260;
 
         public override bool PropagateNonPositionalInputSubTree => true;
 
         public GameplayChatDisplay(Room room)
             : base(room, leaveChannelOnDispose: false)
         {
-            RelativeSizeAxes = Axes.X;
-
             Background.Alpha = 0.2f;
+            Width = width;
+        }
 
-            TextBox.PlaceholderText = ChatStrings.InGameInputPlaceholder;
-            TextBox.Focus = () => TextBox.PlaceholderText = Resources.Localisation.Web.ChatStrings.InputPlaceholder;
+        [BackgroundDependencyLoader]
+        private void load(RealmKeyBindingStore keyBindingStore)
+        {
+            resetPlaceholderText();
+            TextBox.Focus = () => TextBox.PlaceholderText = ChatStrings.InputPlaceholder;
             TextBox.FocusLost = () =>
             {
-                TextBox.PlaceholderText = ChatStrings.InGameInputPlaceholder;
+                resetPlaceholderText();
                 expandedFromTextBoxFocus.Value = false;
             };
+
+            void resetPlaceholderText() => TextBox.PlaceholderText = Localisation.ChatStrings.InGameInputPlaceholder(keyBindingStore.GetBindingsStringFor(GlobalAction.ToggleChatFocus));
         }
 
         protected override bool OnHover(HoverEvent e) => true; // use UI mouse cursor.
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs
index 42d240c60e..018d36069e 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs
@@ -12,7 +12,6 @@ using osu.Framework.Extensions.ExceptionExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Screens;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -35,7 +34,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
         [Resolved]
         private OngoingOperationTracker ongoingOperationTracker { get; set; } = null!;
 
-        private readonly BindableWithCurrent<PlaylistItem?> selectedItem = new BindableWithCurrent<PlaylistItem?>();
         private MatchSettings settings = null!;
 
         public MultiplayerMatchSettingsOverlay(Room room)
@@ -274,11 +272,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
                                                             RelativeSizeAxes = Axes.X,
                                                             Height = 40,
                                                             Text = "Select beatmap",
-                                                            Action = () =>
-                                                            {
-                                                                if (matchSubScreen.IsCurrentScreen())
-                                                                    matchSubScreen.Push(new MultiplayerMatchSongSelect(matchSubScreen.Room));
-                                                            }
+                                                            Action = () => matchSubScreen.ShowSongSelect()
                                                         }
                                                     }
                                                 }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerUserModSelectOverlay.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerUserModSelectOverlay.cs
new file mode 100644
index 0000000000..8463a4720c
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerUserModSelectOverlay.cs
@@ -0,0 +1,124 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Threading;
+using osu.Game.Configuration;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Utils;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
+{
+    public partial class MultiplayerUserModSelectOverlay : UserModSelectOverlay
+    {
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
+        private ModSettingChangeTracker? modSettingChangeTracker;
+        private ScheduledDelegate? debouncedModSettingsUpdate;
+
+        public MultiplayerUserModSelectOverlay()
+            : base(OverlayColourScheme.Plum)
+        {
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            client.RoomUpdated += onRoomUpdated;
+            SelectedMods.BindValueChanged(onSelectedModsChanged);
+
+            updateValidMods();
+        }
+
+        private void onRoomUpdated()
+        {
+            // Importantly, this is not scheduled because the client must not skip intermediate server states to validate the allowed mods.
+            updateValidMods();
+        }
+
+        private void onSelectedModsChanged(ValueChangedEvent<IReadOnlyList<Mod>> mods)
+        {
+            modSettingChangeTracker?.Dispose();
+
+            if (client.Room == null)
+                return;
+
+            client.ChangeUserMods(mods.NewValue).FireAndForget();
+
+            modSettingChangeTracker = new ModSettingChangeTracker(mods.NewValue);
+            modSettingChangeTracker.SettingChanged += _ =>
+            {
+                // Debounce changes to mod settings so as to not thrash the network.
+                debouncedModSettingsUpdate?.Cancel();
+                debouncedModSettingsUpdate = Scheduler.AddDelayed(() =>
+                {
+                    if (client.Room == null)
+                        return;
+
+                    client.ChangeUserMods(SelectedMods.Value).FireAndForget();
+                }, 500);
+            };
+        }
+
+        private void updateValidMods()
+        {
+            if (client.Room == null || client.LocalUser == null)
+                return;
+
+            MultiplayerPlaylistItem currentItem = client.Room.CurrentPlaylistItem;
+            Ruleset ruleset = rulesets.GetRuleset(client.LocalUser.RulesetId ?? currentItem.RulesetID)!.CreateInstance();
+            Mod[] allowedMods = currentItem.Freestyle
+                ? ruleset.AllMods.OfType<Mod>().Where(m => ModUtils.IsValidFreeModForMatchType(m, client.Room.Settings.MatchType)).ToArray()
+                : currentItem.AllowedMods.Select(m => m.ToMod(ruleset)).ToArray();
+
+            // Update the mod panels to reflect the ones which are valid for selection.
+            IsValidMod = allowedMods.Length > 0
+                ? m => allowedMods.Any(a => a.GetType() == m.GetType())
+                : _ => false;
+
+            // Remove any mods that are no longer allowed.
+            Mod[] newUserMods = SelectedMods.Value.Where(m => allowedMods.Any(a => m.GetType() == a.GetType())).ToArray();
+            if (!newUserMods.SequenceEqual(SelectedMods.Value))
+                SelectedMods.Value = newUserMods;
+
+            // The active mods include the playlist item's required mods which change separately from the selected mods.
+            IReadOnlyList<Mod> newActiveMods = ComputeActiveMods();
+            if (!newActiveMods.SequenceEqual(ActiveMods.Value))
+                ActiveMods.Value = newActiveMods;
+        }
+
+        protected override IReadOnlyList<Mod> ComputeActiveMods()
+        {
+            if (client.Room == null || client.LocalUser == null)
+                return [];
+
+            MultiplayerPlaylistItem currentItem = client.Room.CurrentPlaylistItem;
+            Ruleset ruleset = rulesets.GetRuleset(client.LocalUser.RulesetId ?? currentItem.RulesetID)!.CreateInstance();
+            return currentItem.RequiredMods.Select(m => m.ToMod(ruleset)).Concat(base.ComputeActiveMods()).ToArray();
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+                client.RoomUpdated -= onRoomUpdated;
+
+            modSettingChangeTracker?.Dispose();
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerHistoryList.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerHistoryList.cs
index d18bb011f0..14b1aa38be 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerHistoryList.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerHistoryList.cs
@@ -18,6 +18,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
         public MultiplayerHistoryList()
         {
             ShowItemOwners = true;
+            AllowShowingResults = true;
         }
 
         protected override FillFlowContainer<RearrangeableListItem<PlaylistItem>> CreateListFillFlowContainer() => new HistoryFillFlowContainer
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerPlaylist.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerPlaylist.cs
index 9feee0ae41..5af0fed48f 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerPlaylist.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerPlaylist.cs
@@ -5,6 +5,7 @@ using System;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Online.Multiplayer;
@@ -19,32 +20,24 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
     {
         public readonly Bindable<MultiplayerPlaylistDisplayMode> DisplayMode = new Bindable<MultiplayerPlaylistDisplayMode>();
 
-        public required Bindable<PlaylistItem?> SelectedItem
-        {
-            get => selectedItem;
-            set => selectedItem.Current = value;
-        }
-
         /// <summary>
-        /// Invoked when an item requests to be edited.
+        /// Invoked when the user requests to edit an item.
         /// </summary>
         public Action<PlaylistItem>? RequestEdit;
 
+        /// <summary>
+        /// Invoked when the user requests to view the results for an item.
+        /// </summary>
+        public Action<PlaylistItem>? RequestResults;
+
         [Resolved]
         private MultiplayerClient client { get; set; } = null!;
 
-        private readonly Room room;
-        private readonly BindableWithCurrent<PlaylistItem?> selectedItem = new BindableWithCurrent<PlaylistItem?>();
         private MultiplayerPlaylistTabControl playlistTabControl = null!;
         private MultiplayerQueueList queueList = null!;
         private MultiplayerHistoryList historyList = null!;
         private bool firstPopulation = true;
 
-        public MultiplayerPlaylist(Room room)
-        {
-            this.room = room;
-        }
-
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -65,17 +58,16 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
                     Masking = true,
                     Children = new Drawable[]
                     {
-                        queueList = new MultiplayerQueueList(room)
+                        queueList = new MultiplayerQueueList
                         {
                             RelativeSizeAxes = Axes.Both,
-                            SelectedItem = { BindTarget = selectedItem },
                             RequestEdit = item => RequestEdit?.Invoke(item)
                         },
                         historyList = new MultiplayerHistoryList
                         {
                             RelativeSizeAxes = Axes.Both,
                             Alpha = 0,
-                            SelectedItem = { BindTarget = selectedItem }
+                            RequestResults = item => RequestResults?.Invoke(item)
                         }
                     }
                 }
@@ -89,10 +81,12 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
             base.LoadComplete();
 
             DisplayMode.BindValueChanged(onDisplayModeChanged, true);
+
             client.ItemAdded += playlistItemAdded;
             client.ItemRemoved += playlistItemRemoved;
             client.ItemChanged += playlistItemChanged;
             client.RoomUpdated += onRoomUpdated;
+
             updateState();
         }
 
@@ -121,28 +115,28 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
 
                 firstPopulation = false;
             }
+
+            PlaylistItem? currentItem = client.Room == null ? null : new PlaylistItem(client.Room.CurrentPlaylistItem);
+            queueList.SelectedItem.Value = currentItem;
+            historyList.SelectedItem.Value = currentItem;
         }
 
-        private void playlistItemAdded(MultiplayerPlaylistItem item) => Schedule(() => addItemToLists(item));
+        private void playlistItemAdded(MultiplayerPlaylistItem item) => Scheduler.Add(() => addItemToLists(item));
 
-        private void playlistItemRemoved(long item) => Schedule(() => removeItemFromLists(item));
+        private void playlistItemRemoved(long item) => Scheduler.Add(() => removeItemFromLists(item));
 
-        private void playlistItemChanged(MultiplayerPlaylistItem item) => Schedule(() =>
+        private void playlistItemChanged(MultiplayerPlaylistItem item) => Scheduler.Add(() =>
         {
             if (client.Room == null)
                 return;
 
-            var newApiItem = new PlaylistItem(item);
-            var existingApiItemInQueue = queueList.Items.SingleOrDefault(i => i.ID == item.ID);
+            var existingItem = queueList.Items.SingleOrDefault(i => i.ID == item.ID);
 
             // Test if the only change between the two playlist items is the order.
-            if (existingApiItemInQueue != null && existingApiItemInQueue.With(playlistOrder: newApiItem.PlaylistOrder).Equals(newApiItem))
+            if (existingItem != null && existingItem.With(playlistOrder: item.PlaylistOrder).Equals(new PlaylistItem(item)))
             {
-                // Set the new playlist order directly without refreshing the DrawablePlaylistItem.
-                existingApiItemInQueue.PlaylistOrder = newApiItem.PlaylistOrder;
-
-                // The following isn't really required, but is here for safety and explicitness.
-                // MultiplayerQueueList internally binds to changes in Playlist to invalidate its own layout, which is mutated on every playlist operation.
+                // Set the new order directly and refresh the flow layout as an optimisation to avoid refreshing the items' visual state.
+                existingItem.PlaylistOrder = item.PlaylistOrder;
                 queueList.Invalidate();
             }
             else
@@ -154,22 +148,35 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
 
         private void addItemToLists(MultiplayerPlaylistItem item)
         {
-            var apiItem = client.Room?.Playlist.SingleOrDefault(i => i.ID == item.ID);
-
-            // Item could have been removed from the playlist while the local player was in gameplay.
-            if (apiItem == null)
+            if (client.Room == null)
                 return;
 
             if (item.Expired)
-                historyList.Items.Add(new PlaylistItem(apiItem));
+                historyList.Items.Add(new PlaylistItem(item));
             else
-                queueList.Items.Add(new PlaylistItem(apiItem));
+                queueList.Items.Add(new PlaylistItem(item));
         }
 
-        private void removeItemFromLists(long item)
+        private void removeItemFromLists(long itemId)
         {
-            queueList.Items.RemoveAll(i => i.ID == item);
-            historyList.Items.RemoveAll(i => i.ID == item);
+            if (client.Room == null)
+                return;
+
+            queueList.Items.RemoveAll(i => i.ID == itemId);
+            historyList.Items.RemoveAll(i => i.ID == itemId);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+            {
+                client.ItemAdded -= playlistItemAdded;
+                client.ItemRemoved -= playlistItemRemoved;
+                client.ItemChanged -= playlistItemChanged;
+                client.RoomUpdated -= onRoomUpdated;
+            }
         }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerQueueList.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerQueueList.cs
index 04bb9b69e6..dc6a713908 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerQueueList.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerQueueList.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.ObjectExtensions;
@@ -20,50 +19,20 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
     /// </summary>
     public partial class MultiplayerQueueList : DrawableRoomPlaylist
     {
-        private readonly Room room;
-
-        private QueueFillFlowContainer flow = null!;
-
-        public MultiplayerQueueList(Room room)
+        public MultiplayerQueueList()
         {
-            this.room = room;
             ShowItemOwners = true;
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            room.PropertyChanged += onRoomPropertyChanged;
-            updateRoomPlaylist();
-        }
-
-        private void onRoomPropertyChanged(object? sender, PropertyChangedEventArgs e)
-        {
-            if (e.PropertyName == nameof(Room.Playlist))
-                updateRoomPlaylist();
-        }
-
-        private void updateRoomPlaylist()
-            => flow.InvalidateLayout();
-
-        protected override FillFlowContainer<RearrangeableListItem<PlaylistItem>> CreateListFillFlowContainer() => flow = new QueueFillFlowContainer
+        protected override FillFlowContainer<RearrangeableListItem<PlaylistItem>> CreateListFillFlowContainer() => new QueueFillFlowContainer
         {
             Spacing = new Vector2(0, 2)
         };
 
         protected override DrawableRoomPlaylistItem CreateDrawablePlaylistItem(PlaylistItem item) => new QueuePlaylistItem(item);
 
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            room.PropertyChanged -= onRoomPropertyChanged;
-        }
-
         private partial class QueueFillFlowContainer : FillFlowContainer<RearrangeableListItem<PlaylistItem>>
         {
-            public new void InvalidateLayout() => base.InvalidateLayout();
-
             public override IEnumerable<Drawable> FlowingChildren => base.FlowingChildren.OfType<RearrangeableListItem<PlaylistItem>>().OrderBy(item => item.Model.PlaylistOrder);
         }
 
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerLoungeSubScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerLoungeSubScreen.cs
index 51c135f042..5e2619eae3 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerLoungeSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerLoungeSubScreen.cs
@@ -75,7 +75,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
 
         protected override OnlinePlaySubScreen CreateRoomSubScreen(Room room) => new MultiplayerMatchSubScreen(room);
 
-        protected override void JoinInternal(Room room, string? password, Action<Room> onSuccess, Action<string> onFailure)
+        protected override void JoinInternal(Room room, string? password, Action<Room> onSuccess, Action<string, Exception?> onFailure)
         {
             client.JoinRoom(room, password).ContinueWith(result =>
             {
@@ -86,9 +86,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                     Exception? exception = result.Exception?.AsSingular();
 
                     if (exception?.GetHubExceptionMessage() is string message)
-                        onFailure(message);
+                        onFailure(message, exception);
                     else
-                        onFailure($"Failed to join multiplayer room: {exception?.Message}");
+                        onFailure($"Failed to join multiplayer room. {exception?.Message}", exception);
                 }
             });
         }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
index 2b3243e01d..6d271a0077 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
@@ -1,19 +1,23 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
+using System;
 using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Logging;
 using osu.Framework.Screens;
-using osu.Framework.Threading;
+using osu.Game.Audio;
 using osu.Game.Beatmaps;
-using osu.Game.Configuration;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Online;
 using osu.Game.Online.API;
@@ -23,7 +27,7 @@ using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Dialog;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mods;
+using osu.Game.Screens.Menu;
 using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Match;
 using osu.Game.Screens.OnlinePlay.Match.Components;
@@ -31,263 +35,806 @@ using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Participants;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Spectate;
-using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.OnlinePlay.Playlists;
 using osu.Game.Users;
+using osu.Game.Utils;
 using osuTK;
 using ParticipantsList = osu.Game.Screens.OnlinePlay.Multiplayer.Participants.ParticipantsList;
 
 namespace osu.Game.Screens.OnlinePlay.Multiplayer
 {
     [Cached]
-    public partial class MultiplayerMatchSubScreen : RoomSubScreen, IHandlePresentBeatmap
+    public partial class MultiplayerMatchSubScreen : OnlinePlaySubScreen, IPreviewTrackOwner, IHandlePresentBeatmap
     {
+        /// <summary>
+        /// Footer height.
+        /// </summary>
+        private const float footer_height = 50;
+
+        /// <summary>
+        /// Padding between content and footer.
+        /// </summary>
+        private const float footer_padding = 30;
+
+        /// <summary>
+        /// Internal padding of the content.
+        /// </summary>
+        private const float content_padding = 20;
+
+        /// <summary>
+        /// Padding between columns of the content.
+        /// </summary>
+        private const float column_padding = 10;
+
+        /// <summary>
+        /// Padding between rows of the content.
+        /// </summary>
+        private const float row_padding = 10;
+
         public override string Title { get; }
 
         public override string ShortTitle => "room";
 
+        public override bool? ApplyModTrackAdjustments => true;
+
+        public override bool DisallowExternalBeatmapRulesetChanges => true;
+
+        /// <summary>
+        /// Whether the user has confirmed they want to exit this screen in the presence of unsaved changes.
+        /// </summary>
+        protected bool ExitConfirmed { get; private set; }
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private AudioManager audio { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; } = null!;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
+        [Resolved]
+        private PreviewTrackManager previewTrackManager { get; set; } = null!;
+
+        [Resolved]
+        private MusicController music { get; set; } = null!;
+
+        [Resolved]
+        private OnlinePlayScreen? parentScreen { get; set; }
+
+        [Resolved]
+        private IOverlayManager? overlayManager { get; set; }
+
+        [Resolved]
+        private IDialogOverlay? dialogOverlay { get; set; }
+
         [Resolved]
         private MultiplayerClient client { get; set; } = null!;
 
-        [Resolved(canBeNull: true)]
+        [Resolved]
         private OsuGame? game { get; set; }
 
-        private AddItemButton addItemButton = null!;
+        [Cached(typeof(OnlinePlayBeatmapAvailabilityTracker))]
+        private readonly OnlinePlayBeatmapAvailabilityTracker beatmapAvailabilityTracker = new MultiplayerBeatmapAvailabilityTracker();
+
+        private readonly Room room;
+
+        private Drawable roomContent = null!;
+        private MultiplayerMatchSettingsOverlay settingsOverlay = null!;
+
+        private FillFlowContainer userModsSection = null!;
+        private MultiplayerUserModSelectOverlay userModsSelectOverlay = null!;
+
+        private FillFlowContainer userStyleSection = null!;
+        private Container<DrawableRoomPlaylistItem> userStyleDisplayContainer = null!;
+
+        private Sample? sampleStart;
+        private IDisposable? userModsSelectOverlayRegistration;
+
+        private long lastPlaylistItemId;
+        private bool isRoomJoined;
 
         public MultiplayerMatchSubScreen(Room room)
-            : base(room)
         {
+            this.room = room;
+
             Title = room.RoomID == null ? "New room" : room.Name;
             Activity.Value = new UserActivity.InLobby(room);
+
+            Padding = new MarginPadding { Top = Header.HEIGHT };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            sampleStart = audio.Samples.Get(@"SongSelect/confirm-selection");
+
+            InternalChild = new OsuContextMenuContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = new PopoverContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        beatmapAvailabilityTracker,
+                        new MultiplayerRoomSounds(),
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding
+                            {
+                                Horizontal = WaveOverlayContainer.WIDTH_PADDING,
+                                Bottom = footer_height + footer_padding
+                            },
+                            Children = new[]
+                            {
+                                roomContent = new GridContainer
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    RowDimensions = new[]
+                                    {
+                                        new Dimension(GridSizeMode.AutoSize),
+                                        new Dimension(GridSizeMode.Absolute, row_padding),
+                                    },
+                                    Content = new[]
+                                    {
+                                        new Drawable[]
+                                        {
+                                            new MultiplayerRoomPanel(room)
+                                            {
+                                                OnEdit = () => settingsOverlay.Show()
+                                            }
+                                        },
+                                        null,
+                                        new Drawable[]
+                                        {
+                                            new Container
+                                            {
+                                                RelativeSizeAxes = Axes.Both,
+                                                Masking = true,
+                                                CornerRadius = 10,
+                                                Children = new Drawable[]
+                                                {
+                                                    new Box
+                                                    {
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Colour = Color4Extensions.FromHex(@"3e3a44") // Temporary.
+                                                    },
+                                                    new GridContainer
+                                                    {
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Padding = new MarginPadding(content_padding),
+                                                        ColumnDimensions = new[]
+                                                        {
+                                                            new Dimension(),
+                                                            new Dimension(GridSizeMode.Absolute, column_padding),
+                                                            new Dimension(),
+                                                            new Dimension(GridSizeMode.Absolute, column_padding),
+                                                            new Dimension(),
+                                                        },
+                                                        Content = new[]
+                                                        {
+                                                            new Drawable?[]
+                                                            {
+                                                                new GridContainer
+                                                                {
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    RowDimensions = new[]
+                                                                    {
+                                                                        new Dimension(GridSizeMode.AutoSize)
+                                                                    },
+                                                                    Content = new[]
+                                                                    {
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new ParticipantsListHeader()
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new ParticipantsList
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.Both
+                                                                            },
+                                                                        }
+                                                                    }
+                                                                },
+                                                                null,
+                                                                new GridContainer
+                                                                {
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    RowDimensions = new[]
+                                                                    {
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(GridSizeMode.Absolute, 5),
+                                                                        new Dimension(),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                    },
+                                                                    Content = new[]
+                                                                    {
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new OverlinedHeader("Beatmap queue")
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new AddItemButton
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                Height = 40,
+                                                                                Text = "Add item",
+                                                                                Action = () => ShowSongSelect()
+                                                                            },
+                                                                        },
+                                                                        null,
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new MultiplayerPlaylist
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.Both,
+                                                                                RequestEdit = ShowSongSelect,
+                                                                                RequestResults = showResults
+                                                                            }
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            userModsSection = new FillFlowContainer
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                AutoSizeAxes = Axes.Y,
+                                                                                Margin = new MarginPadding { Top = 10 },
+                                                                                Alpha = 0,
+                                                                                Children = new Drawable[]
+                                                                                {
+                                                                                    new OverlinedHeader("Extra mods"),
+                                                                                    new FillFlowContainer
+                                                                                    {
+                                                                                        AutoSizeAxes = Axes.Both,
+                                                                                        Direction = FillDirection.Horizontal,
+                                                                                        Spacing = new Vector2(10, 0),
+                                                                                        Children = new Drawable[]
+                                                                                        {
+                                                                                            new UserModSelectButton
+                                                                                            {
+                                                                                                Anchor = Anchor.CentreLeft,
+                                                                                                Origin = Anchor.CentreLeft,
+                                                                                                Width = 90,
+                                                                                                Height = 30,
+                                                                                                Text = "Select",
+                                                                                                Action = showUserModSelect,
+                                                                                            },
+                                                                                            new MultiplayerUserModDisplay
+                                                                                            {
+                                                                                                Anchor = Anchor.CentreLeft,
+                                                                                                Origin = Anchor.CentreLeft,
+                                                                                                Scale = new Vector2(0.8f),
+                                                                                            },
+                                                                                        }
+                                                                                    },
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            userStyleSection = new FillFlowContainer
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                AutoSizeAxes = Axes.Y,
+                                                                                Margin = new MarginPadding { Top = 10 },
+                                                                                Alpha = 0,
+                                                                                Children = new Drawable[]
+                                                                                {
+                                                                                    new OverlinedHeader("Difficulty"),
+                                                                                    userStyleDisplayContainer = new Container<DrawableRoomPlaylistItem>
+                                                                                    {
+                                                                                        RelativeSizeAxes = Axes.X,
+                                                                                        AutoSizeAxes = Axes.Y
+                                                                                    }
+                                                                                }
+                                                                            },
+                                                                        },
+                                                                    },
+                                                                },
+                                                                null,
+                                                                new GridContainer
+                                                                {
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    RowDimensions = new[]
+                                                                    {
+                                                                        new Dimension(GridSizeMode.AutoSize)
+                                                                    },
+                                                                    Content = new[]
+                                                                    {
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new OverlinedHeader("Chat")
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new MatchChatDisplay(room)
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.Both
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                },
+                                settingsOverlay = new MultiplayerMatchSettingsOverlay(room)
+                            }
+                        },
+                        new Container
+                        {
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            RelativeSizeAxes = Axes.X,
+                            Height = footer_height,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4Extensions.FromHex(@"28242d") // Temporary.
+                                },
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding(5),
+                                    Child = new MultiplayerMatchFooter()
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            LoadComponent(userModsSelectOverlay = new MultiplayerUserModSelectOverlay
+            {
+                Beatmap = { BindTarget = Beatmap }
+            });
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            BeatmapAvailability.BindValueChanged(updateBeatmapAvailability, true);
-            UserMods.BindValueChanged(onUserModsChanged);
+            userModsSelectOverlayRegistration = overlayManager?.RegisterBlockingOverlay(userModsSelectOverlay);
 
-            client.LoadRequested += onLoadRequested;
             client.RoomUpdated += onRoomUpdated;
+            client.SettingsChanged += onSettingsChanged;
+            client.ItemChanged += onItemChanged;
+            client.UserStyleChanged += onUserStyleChanged;
+            client.UserModsChanged += onUserModsChanged;
+            client.LoadRequested += onLoadRequested;
 
-            if (!client.IsConnected.Value)
-                handleRoomLost();
+            beatmapAvailabilityTracker.Availability.BindValueChanged(onBeatmapAvailabilityChanged, true);
+
+            onRoomUpdated();
+            updateGameplayState();
+            updateUserActivity();
         }
 
-        protected override bool IsConnected => base.IsConnected && client.IsConnected.Value;
-
-        protected override Drawable CreateMainContent() => new Container
+        /// <summary>
+        /// Responds to changes in the active room to adjust the visibility of the settings and main content.
+        /// Only the settings overlay is visible while the room isn't created, and only the main content is visible after creation.
+        /// </summary>
+        private void onRoomUpdated() => Scheduler.AddOnce(() =>
         {
-            RelativeSizeAxes = Axes.Both,
-            Padding = new MarginPadding { Horizontal = 5, Vertical = 10 },
-            Child = new OsuContextMenuContainer
+            bool newIsRoomJoined = client.Room != null;
+
+            if (newIsRoomJoined)
             {
-                RelativeSizeAxes = Axes.Both,
-                Child = new GridContainer
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    ColumnDimensions = new[]
-                    {
-                        new Dimension(),
-                        new Dimension(GridSizeMode.Absolute, 10),
-                        new Dimension(),
-                        new Dimension(GridSizeMode.Absolute, 10),
-                        new Dimension(),
-                    },
-                    Content = new[]
-                    {
-                        new Drawable?[]
-                        {
-                            new GridContainer
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                RowDimensions = new[]
-                                {
-                                    new Dimension(GridSizeMode.AutoSize)
-                                },
-                                Content = new[]
-                                {
-                                    new Drawable[] { new ParticipantsListHeader() },
-                                    new Drawable[]
-                                    {
-                                        new ParticipantsList
-                                        {
-                                            RelativeSizeAxes = Axes.Both
-                                        },
-                                    }
-                                }
-                            },
-                            null,
-                            new GridContainer
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                RowDimensions = new[]
-                                {
-                                    new Dimension(GridSizeMode.AutoSize),
-                                    new Dimension(GridSizeMode.AutoSize),
-                                    new Dimension(GridSizeMode.Absolute, 5),
-                                    new Dimension(),
-                                    new Dimension(GridSizeMode.AutoSize),
-                                    new Dimension(GridSizeMode.AutoSize),
-                                },
-                                Content = new[]
-                                {
-                                    new Drawable[] { new OverlinedHeader("Beatmap queue") },
-                                    new Drawable[]
-                                    {
-                                        addItemButton = new AddItemButton
-                                        {
-                                            RelativeSizeAxes = Axes.X,
-                                            Height = 40,
-                                            Text = "Add item",
-                                            Action = () => OpenSongSelection()
-                                        },
-                                    },
-                                    null,
-                                    new Drawable[]
-                                    {
-                                        new MultiplayerPlaylist(Room)
-                                        {
-                                            RelativeSizeAxes = Axes.Both,
-                                            RequestEdit = OpenSongSelection,
-                                            SelectedItem = SelectedItem
-                                        }
-                                    },
-                                    new[]
-                                    {
-                                        UserModsSection = new FillFlowContainer
-                                        {
-                                            RelativeSizeAxes = Axes.X,
-                                            AutoSizeAxes = Axes.Y,
-                                            Margin = new MarginPadding { Top = 10 },
-                                            Alpha = 0,
-                                            Children = new Drawable[]
-                                            {
-                                                new OverlinedHeader("Extra mods"),
-                                                new FillFlowContainer
-                                                {
-                                                    AutoSizeAxes = Axes.Both,
-                                                    Direction = FillDirection.Horizontal,
-                                                    Spacing = new Vector2(10, 0),
-                                                    Children = new Drawable[]
-                                                    {
-                                                        new UserModSelectButton
-                                                        {
-                                                            Anchor = Anchor.CentreLeft,
-                                                            Origin = Anchor.CentreLeft,
-                                                            Width = 90,
-                                                            Height = 30,
-                                                            Text = "Select",
-                                                            Action = ShowUserModSelect,
-                                                        },
-                                                        new ModDisplay
-                                                        {
-                                                            Anchor = Anchor.CentreLeft,
-                                                            Origin = Anchor.CentreLeft,
-                                                            Current = UserMods,
-                                                            Scale = new Vector2(0.8f),
-                                                        },
-                                                    }
-                                                },
-                                            }
-                                        }
-                                    },
-                                    new[]
-                                    {
-                                        UserStyleSection = new FillFlowContainer
-                                        {
-                                            RelativeSizeAxes = Axes.X,
-                                            AutoSizeAxes = Axes.Y,
-                                            Margin = new MarginPadding { Top = 10 },
-                                            Alpha = 0,
-                                            Children = new Drawable[]
-                                            {
-                                                new OverlinedHeader("Difficulty"),
-                                                UserStyleDisplayContainer = new Container<DrawableRoomPlaylistItem>
-                                                {
-                                                    RelativeSizeAxes = Axes.X,
-                                                    AutoSizeAxes = Axes.Y
-                                                }
-                                            }
-                                        },
-                                    },
-                                },
-                            },
-                            null,
-                            new GridContainer
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Content = new[]
-                                {
-                                    new Drawable[] { new OverlinedHeader("Chat") },
-                                    new Drawable[] { new MatchChatDisplay(Room) { RelativeSizeAxes = Axes.Both } }
-                                },
-                                RowDimensions = new[]
-                                {
-                                    new Dimension(GridSizeMode.AutoSize),
-                                    new Dimension(),
-                                }
-                            },
-                        }
-                    }
-                }
+                roomContent.Show();
+                settingsOverlay.Hide();
             }
-        };
+            else if (isRoomJoined)
+            {
+                Logger.Log($"{this} exiting due to loss of room or connection");
+
+                if (this.IsCurrentScreen())
+                    this.Exit();
+                else
+                    ValidForResume = false;
+            }
+            else
+            {
+                Debug.Assert(!isRoomJoined && !newIsRoomJoined);
+
+                // A new room is being created.
+                // The main content should be hidden until the settings overlay is hidden, signaling the room is ready to be displayed.
+                roomContent.Hide();
+                settingsOverlay.Show();
+            }
+
+            isRoomJoined = newIsRoomJoined;
+        });
 
         /// <summary>
-        /// Opens the song selection screen to add or edit an item.
+        /// Responds to changes in the room's settings to update the gameplay state and local user's activity.
+        /// </summary>
+        private void onSettingsChanged(MultiplayerRoomSettings settings)
+        {
+            if (settings.PlaylistItemId != lastPlaylistItemId)
+            {
+                Scheduler.AddOnce(updateGameplayState);
+                lastPlaylistItemId = settings.PlaylistItemId;
+            }
+
+            updateUserActivity();
+        }
+
+        /// <summary>
+        /// Responds to changes in the active playlist item to update the gameplay state.
+        /// </summary>
+        private void onItemChanged(MultiplayerPlaylistItem item)
+        {
+            if (item.ID == client.Room?.Settings.PlaylistItemId)
+                Scheduler.AddOnce(updateGameplayState);
+        }
+
+        /// <summary>
+        /// Responds to changes in the local user's style to update the gameplay state.
+        /// </summary>
+        private void onUserStyleChanged(MultiplayerRoomUser user)
+        {
+            if (user.Equals(client.LocalUser))
+                Scheduler.AddOnce(updateGameplayState);
+        }
+
+        /// <summary>
+        /// Responds to changes in the local user's mods style to update the gameplay state.
+        /// </summary>
+        private void onUserModsChanged(MultiplayerRoomUser user)
+        {
+            if (user.Equals(client.LocalUser))
+                Scheduler.AddOnce(updateGameplayState);
+        }
+
+        /// <summary>
+        /// Responds to notifications from the server that a gameplay session is ready to attempt to start the gameplay session.
+        /// </summary>
+        private void onLoadRequested()
+        {
+            if (client.Room == null || client.LocalUser == null)
+                return;
+
+            // In the case of spectating, IMultiplayerClient.LoadRequested can be fired while the game is still spectating a previous session.
+            // For now, we want to game to switch to the new game so need to request exiting from the play screen.
+            if (!parentScreen.IsCurrentScreen())
+            {
+                parentScreen.MakeCurrent();
+                Schedule(onLoadRequested);
+                return;
+            }
+
+            if (!this.IsCurrentScreen())
+            {
+                this.MakeCurrent();
+                Schedule(onLoadRequested);
+                return;
+            }
+
+            // Ensure all the gameplay states are up-to-date, forgoing any misordering/scheduling shenanigans.
+            updateGameplayState();
+
+            // ... And then check that the set gameplay state is valid.
+            // When spectating, we'll receive LoadRequested() from the server even though we may not yet have the beatmap.
+            // In that case, this method will be invoked again after availability changes in onBeatmapAvailabilityChanged().
+            if (Beatmap.IsDefault)
+            {
+                Logger.Log("Aborting gameplay start - beatmap not downloaded.");
+                return;
+            }
+
+            // Start the gameplay session.
+            sampleStart?.Play();
+
+            int[] userIds = client.CurrentMatchPlayingUserIds.ToArray();
+            MultiplayerRoomUser[] users = userIds.Select(id => client.Room.Users.First(u => u.UserID == id)).ToArray();
+
+            // fallback is to allow this class to operate when there is no parent OnlineScreen (testing purposes).
+            var targetScreen = (Screen?)parentScreen ?? this;
+
+            switch (client.LocalUser.State)
+            {
+                case MultiplayerUserState.Spectating:
+                    targetScreen.Push(new MultiSpectatorScreen(room, users.Take(PlayerGrid.MAX_PLAYERS).ToArray()));
+                    break;
+
+                default:
+                    targetScreen.Push(new MultiplayerPlayerLoader(() => new MultiplayerPlayer(room, new PlaylistItem(client.Room.CurrentPlaylistItem), users)));
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Responds to changes in the local user's beatmap availability to notify the server and prepare the gameplay session.
+        /// </summary>
+        private void onBeatmapAvailabilityChanged(ValueChangedEvent<BeatmapAvailability> e)
+        {
+            if (client.Room == null || client.LocalUser == null)
+                return;
+
+            client.ChangeBeatmapAvailability(e.NewValue).FireAndForget();
+
+            switch (e.NewValue.State)
+            {
+                case DownloadState.LocallyAvailable:
+                    updateGameplayState();
+
+                    // Optimistically enter spectator if the match is in progress while spectating.
+                    if (client.LocalUser.State == MultiplayerUserState.Spectating && (client.Room.State == MultiplayerRoomState.WaitingForLoad || client.Room.State == MultiplayerRoomState.Playing))
+                        onLoadRequested();
+                    break;
+
+                case DownloadState.NotDownloaded:
+                    updateGameplayState();
+
+                    if (client.LocalUser.State == MultiplayerUserState.Ready)
+                        client.ChangeState(MultiplayerUserState.Idle);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Updates the local user's activity to publish their presence in the room.
+        /// </summary>
+        private void updateUserActivity()
+        {
+            if (client.Room == null)
+                return;
+
+            if (Activity.Value is not UserActivity.InLobby existing || existing.RoomName != client.Room.Settings.Name)
+                Activity.Value = new UserActivity.InLobby(client.Room);
+        }
+
+        /// <summary>
+        /// Updates the global beatmap/ruleset/mods in preparation for a new gameplay session.
+        /// </summary>
+        private void updateGameplayState()
+        {
+            if (client.Room == null || client.LocalUser == null)
+                return;
+
+            MultiplayerPlaylistItem item = client.Room.CurrentPlaylistItem;
+            int gameplayBeatmapId = client.LocalUser.BeatmapId ?? item.BeatmapID;
+            int gameplayRulesetId = client.LocalUser.RulesetId ?? item.RulesetID;
+
+            RulesetInfo ruleset = rulesets.GetRuleset(gameplayRulesetId)!;
+            Ruleset rulesetInstance = ruleset.CreateInstance();
+
+            // Update global gameplay state to correspond to the new selection.
+            // Retrieve the corresponding local beatmap, since we can't directly use the playlist's beatmap info
+            var localBeatmap = beatmapManager.QueryBeatmap($@"{nameof(BeatmapInfo.OnlineID)} == $0 AND {nameof(BeatmapInfo.MD5Hash)} == {nameof(BeatmapInfo.OnlineMD5Hash)}", gameplayBeatmapId);
+            Beatmap.Value = beatmapManager.GetWorkingBeatmap(localBeatmap);
+            Ruleset.Value = ruleset;
+            Mods.Value = client.LocalUser.Mods.Concat(item.RequiredMods).Select(m => m.ToMod(rulesetInstance)).ToArray();
+
+            bool freemods = item.Freestyle || item.AllowedMods.Any();
+            bool freestyle = item.Freestyle;
+
+            if (freemods)
+                userModsSection.Show();
+            else
+            {
+                userModsSection.Hide();
+                userModsSelectOverlay.Hide();
+            }
+
+            if (freestyle)
+            {
+                userStyleSection.Show();
+
+                PlaylistItem apiItem = new PlaylistItem(item).With(beatmap: new Optional<IBeatmapInfo>(new APIBeatmap { OnlineID = gameplayBeatmapId }), ruleset: gameplayRulesetId);
+
+                if (!apiItem.Equals(userStyleDisplayContainer.SingleOrDefault()?.Item))
+                {
+                    userStyleDisplayContainer.Child = new DrawableRoomPlaylistItem(apiItem, true)
+                    {
+                        AllowReordering = false,
+                        AllowEditing = true,
+                        RequestEdit = _ => showUserStyleSelect()
+                    };
+                }
+            }
+            else
+                userStyleSection.Hide();
+        }
+
+        /// <summary>
+        /// Shows the song selection screen to add or edit an item.
         /// </summary>
         /// <param name="itemToEdit">An optional playlist item to edit. If null, a new item will be added instead.</param>
-        internal void OpenSongSelection(PlaylistItem? itemToEdit = null)
+        public void ShowSongSelect(PlaylistItem? itemToEdit = null)
         {
             if (!this.IsCurrentScreen())
                 return;
 
-            this.Push(new MultiplayerMatchSongSelect(Room, itemToEdit));
+            this.Push(new MultiplayerMatchSongSelect(room, itemToEdit));
         }
 
-        protected override void OpenStyleSelection()
+        /// <summary>
+        /// Shows the user mod selection.
+        /// </summary>
+        private void showUserModSelect()
         {
-            if (!this.IsCurrentScreen() || SelectedItem.Value is not PlaylistItem item)
+            if (!this.IsCurrentScreen())
                 return;
 
-            this.Push(new MultiplayerMatchFreestyleSelect(Room, item));
+            userModsSelectOverlay.Show();
         }
 
-        protected override Drawable CreateFooter() => new MultiplayerMatchFooter();
-
-        protected override RoomSettingsOverlay CreateRoomSettingsOverlay(Room room) => new MultiplayerMatchSettingsOverlay(room);
-
-        protected override APIMod[] GetGameplayMods()
+        /// <summary>
+        /// Shows the user style selection.
+        /// </summary>
+        private void showUserStyleSelect()
         {
-            // Using the room's reported status makes the server authoritative.
-            return client.LocalUser?.Mods != null ? client.LocalUser.Mods.Concat(SelectedItem.Value!.RequiredMods).ToArray() : base.GetGameplayMods();
+            if (!this.IsCurrentScreen() || client.Room == null || client.LocalUser == null)
+                return;
+
+            MultiplayerPlaylistItem item = client.Room.CurrentPlaylistItem;
+            this.Push(new MultiplayerMatchFreestyleSelect(room, new PlaylistItem(item)));
         }
 
-        protected override RulesetInfo GetGameplayRuleset()
+        /// <summary>
+        /// Shows the results screen for a playlist item.
+        /// </summary>
+        private void showResults(PlaylistItem item)
         {
-            // Using the room's reported status makes the server authoritative.
-            return client.LocalUser?.RulesetId != null ? Rulesets.GetRuleset(client.LocalUser.RulesetId.Value)! : base.GetGameplayRuleset();
+            if (!this.IsCurrentScreen() || client.Room == null || client.LocalUser == null)
+                return;
+
+            // fallback is to allow this class to operate when there is no parent OnlineScreen (testing purposes).
+            var targetScreen = (Screen?)parentScreen ?? this;
+            targetScreen.Push(new PlaylistItemUserBestResultsScreen(client.Room.RoomID, item, client.LocalUser.UserID));
         }
 
-        protected override IBeatmapInfo GetGameplayBeatmap()
+        public override void OnEntering(ScreenTransitionEvent e)
         {
-            // Using the room's reported status makes the server authoritative.
-            return client.LocalUser?.BeatmapId != null ? new APIBeatmap { OnlineID = client.LocalUser.BeatmapId.Value } : base.GetGameplayBeatmap();
+            base.OnEntering(e);
+            beginHandlingTrack();
         }
 
-        [Resolved(canBeNull: true)]
-        private IDialogOverlay? dialogOverlay { get; set; }
+        public override void OnSuspending(ScreenTransitionEvent e)
+        {
+            onLeaving();
+            base.OnSuspending(e);
+        }
 
-        private bool exitConfirmed;
+        public override void OnResuming(ScreenTransitionEvent e)
+        {
+            base.OnResuming(e);
+            beginHandlingTrack();
+
+            // Required to update beatmap/ruleset when resuming from style selection.
+            updateGameplayState();
+        }
 
         public override bool OnExiting(ScreenExitEvent e)
         {
-            // room has not been created yet or we're offline; exit immediately.
-            if (client.Room == null || !IsConnected)
-                return base.OnExiting(e);
+            if (!ensureExitConfirmed())
+                return true;
 
-            if (!exitConfirmed && dialogOverlay != null)
+            client.LeaveRoom().FireAndForget();
+
+            onLeaving();
+            return base.OnExiting(e);
+        }
+
+        public override bool OnBackButton()
+        {
+            if (room.RoomID == null)
+            {
+                if (!ensureExitConfirmed())
+                    return true;
+
+                settingsOverlay.Hide();
+                return base.OnBackButton();
+            }
+
+            if (userModsSelectOverlay.State.Value == Visibility.Visible)
+            {
+                userModsSelectOverlay.Hide();
+                return true;
+            }
+
+            if (settingsOverlay.State.Value == Visibility.Visible)
+            {
+                settingsOverlay.Hide();
+                return true;
+            }
+
+            return base.OnBackButton();
+        }
+
+        private void onLeaving()
+        {
+            // Must hide this overlay because it is added to a global container.
+            userModsSelectOverlay.Hide();
+
+            endHandlingTrack();
+        }
+
+        /// <summary>
+        /// Handles changes in the track to keep it looping while active.
+        /// </summary>
+        private void beginHandlingTrack()
+        {
+            Beatmap.BindValueChanged(applyLoopingToTrack, true);
+        }
+
+        /// <summary>
+        /// Stops looping the current track and stops handling further changes to the track.
+        /// </summary>
+        private void endHandlingTrack()
+        {
+            Beatmap.ValueChanged -= applyLoopingToTrack;
+            Beatmap.Value.Track.Looping = false;
+
+            previewTrackManager.StopAnyPlaying(this);
+        }
+
+        /// <summary>
+        /// Invoked on changes to the beatmap to loop the track. See: <see cref="beginHandlingTrack"/>.
+        /// </summary>
+        /// <param name="beatmap">The beatmap change event.</param>
+        private void applyLoopingToTrack(ValueChangedEvent<WorkingBeatmap> beatmap)
+        {
+            if (!this.IsCurrentScreen())
+                return;
+
+            beatmap.NewValue.PrepareTrackForPreview(true);
+            music.EnsurePlayingSomething();
+        }
+
+        /// <summary>
+        /// Prompts the user to discard unsaved changes to the room before exiting.
+        /// </summary>
+        /// <returns><c>true</c> if the user has confirmed they want to exit.</returns>
+        private bool ensureExitConfirmed()
+        {
+            if (ExitConfirmed)
+                return true;
+
+            if (api.State.Value != APIState.Online || !client.IsConnected.Value)
+                return true;
+
+            if (dialogOverlay == null)
+                return true;
+
+            bool hasUnsavedChanges = room.RoomID == null && room.Playlist.Count > 0;
+
+            if (hasUnsavedChanges)
+            {
+                // if the dialog is already displayed, block exiting until the user explicitly makes a decision.
+                if (dialogOverlay.CurrentDialog is ConfirmDiscardChangesDialog discardChangesDialog)
+                {
+                    discardChangesDialog.Flash();
+                    return false;
+                }
+
+                dialogOverlay.Push(new ConfirmDiscardChangesDialog(() =>
+                {
+                    ExitConfirmed = true;
+                    settingsOverlay.Hide();
+                    this.Exit();
+                }));
+
+                return false;
+            }
+
+            if (client.Room != null)
             {
                 if (dialogOverlay.CurrentDialog is ConfirmDialog confirmDialog)
                     confirmDialog.PerformOkAction();
@@ -295,148 +842,15 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                 {
                     dialogOverlay.Push(new ConfirmDialog("Are you sure you want to leave this multiplayer match?", () =>
                     {
-                        exitConfirmed = true;
-                        if (this.IsCurrentScreen())
-                            this.Exit();
+                        ExitConfirmed = true;
+                        this.Exit();
                     }));
                 }
 
-                return true;
+                return false;
             }
 
-            return base.OnExiting(e);
-        }
-
-        protected override void PartRoom() => client.LeaveRoom();
-
-        private ModSettingChangeTracker? modSettingChangeTracker;
-        private ScheduledDelegate? debouncedModSettingsUpdate;
-
-        private void onUserModsChanged(ValueChangedEvent<IReadOnlyList<Mod>> mods)
-        {
-            modSettingChangeTracker?.Dispose();
-
-            if (client.Room == null)
-                return;
-
-            client.ChangeUserMods(mods.NewValue).FireAndForget();
-
-            modSettingChangeTracker = new ModSettingChangeTracker(mods.NewValue);
-            modSettingChangeTracker.SettingChanged += onModSettingsChanged;
-        }
-
-        private void onModSettingsChanged(Mod mod)
-        {
-            // Debounce changes to mod settings so as to not thrash the network.
-            debouncedModSettingsUpdate?.Cancel();
-            debouncedModSettingsUpdate = Scheduler.AddDelayed(() =>
-            {
-                if (client.Room == null)
-                    return;
-
-                client.ChangeUserMods(UserMods.Value).FireAndForget();
-            }, 500);
-        }
-
-        private void updateBeatmapAvailability(ValueChangedEvent<BeatmapAvailability> availability)
-        {
-            if (client.Room == null)
-                return;
-
-            client.ChangeBeatmapAvailability(availability.NewValue).FireAndForget();
-
-            switch (availability.NewValue.State)
-            {
-                case DownloadState.LocallyAvailable:
-                    if (client.LocalUser?.State == MultiplayerUserState.Spectating
-                        && (client.Room?.State == MultiplayerRoomState.WaitingForLoad || client.Room?.State == MultiplayerRoomState.Playing))
-                    {
-                        onLoadRequested();
-                    }
-
-                    break;
-
-                case DownloadState.Unknown:
-                    // Don't do anything rash in an unknown state.
-                    break;
-
-                default:
-                    // while this flow is handled server-side, this covers the edge case of the local user being in a ready state and then deleting the current beatmap.
-                    if (client.LocalUser?.State == MultiplayerUserState.Ready)
-                        client.ChangeState(MultiplayerUserState.Idle);
-                    break;
-            }
-        }
-
-        private void onRoomUpdated()
-        {
-            // may happen if the client is kicked or otherwise removed from the room.
-            if (client.Room == null)
-            {
-                handleRoomLost();
-                return;
-            }
-
-            SelectedItem.Value = Room.Playlist.SingleOrDefault(i => i.ID == client.Room.Settings.PlaylistItemId);
-
-            addItemButton.Alpha = localUserCanAddItem ? 1 : 0;
-
-            Activity.Value = new UserActivity.InLobby(Room);
-        }
-
-        private bool localUserCanAddItem => client.IsHost || Room.QueueMode != QueueMode.HostOnly;
-
-        private void handleRoomLost() => Schedule(() =>
-        {
-            Logger.Log($"{this} exiting due to loss of room or connection");
-
-            if (this.IsCurrentScreen())
-                this.Exit();
-            else
-                ValidForResume = false;
-        });
-
-        private void onLoadRequested()
-        {
-            // In the case of spectating, IMultiplayerClient.LoadRequested can be fired while the game is still spectating a previous session.
-            // For now, we want to game to switch to the new game so need to request exiting from the play screen.
-            if (!ParentScreen.IsCurrentScreen())
-            {
-                ParentScreen.MakeCurrent();
-
-                Schedule(onLoadRequested);
-                return;
-            }
-
-            // The beatmap is queried asynchronously when the selected item changes.
-            // This is an issue with MultiSpectatorScreen which is effectively in an always "ready" state and receives LoadRequested() callbacks
-            // even when it is not truly ready (i.e. the beatmap hasn't been selected by the client yet). For the time being, a simple fix to this is to ignore the callback.
-            // Note that spectator will be entered automatically when the client is capable of doing so via beatmap availability callbacks (see: updateBeatmapAvailability()).
-            if (client.LocalUser?.State == MultiplayerUserState.Spectating && (SelectedItem.Value == null || Beatmap.IsDefault))
-                return;
-
-            if (BeatmapAvailability.Value.State != DownloadState.LocallyAvailable)
-                return;
-
-            StartPlay();
-        }
-
-        protected override Screen CreateGameplayScreen(PlaylistItem selectedItem)
-        {
-            Debug.Assert(client.LocalUser != null);
-            Debug.Assert(client.Room != null);
-
-            int[] userIds = client.CurrentMatchPlayingUserIds.ToArray();
-            MultiplayerRoomUser[] users = userIds.Select(id => client.Room.Users.First(u => u.UserID == id)).ToArray();
-
-            switch (client.LocalUser.State)
-            {
-                case MultiplayerUserState.Spectating:
-                    return new MultiSpectatorScreen(Room, users.Take(PlayerGrid.MAX_PLAYERS).ToArray());
-
-                default:
-                    return new MultiplayerPlayerLoader(() => new MultiplayerPlayer(Room, selectedItem, users));
-            }
+            return true;
         }
 
         public void PresentBeatmap(WorkingBeatmap beatmap, RulesetInfo ruleset)
@@ -444,33 +858,76 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             if (!this.IsCurrentScreen())
                 return;
 
-            if (!localUserCanAddItem)
+            if (client.Room == null || client.LocalUser == null)
+                return;
+
+            if (client.Room.CanAddPlaylistItems(client.LocalUser) != true)
                 return;
 
             // If there's only one playlist item and we are the host, assume we want to change it. Else add a new one.
-            PlaylistItem? itemToEdit = client.IsHost && Room.Playlist.Count == 1 ? Room.Playlist.Single() : null;
+            PlaylistItem? itemToEdit = client.IsHost && room.Playlist.Count == 1 ? room.Playlist.Single() : null;
 
-            OpenSongSelection(itemToEdit);
+            ShowSongSelect(itemToEdit);
 
             // Re-run PresentBeatmap now that we've pushed a song select that can handle it.
             game?.PresentBeatmap(beatmap.BeatmapSetInfo, b => b.ID == beatmap.BeatmapInfo.ID);
         }
 
+        // Block all input to this screen during gameplay/etc when the parent screen is no longer current.
+        // Normally this would be handled by ScreenStack, but we are in a child ScreenStack.
+        public override bool PropagatePositionalInputSubTree => base.PropagatePositionalInputSubTree && (parentScreen?.IsCurrentScreen() ?? this.IsCurrentScreen());
+
+        // Block all input to this screen during gameplay/etc when the parent screen is no longer current.
+        // Normally this would be handled by ScreenStack, but we are in a child ScreenStack.
+        public override bool PropagateNonPositionalInputSubTree => base.PropagateNonPositionalInputSubTree && (parentScreen?.IsCurrentScreen() ?? this.IsCurrentScreen());
+
+        protected override BackgroundScreen CreateBackground() => new MultiplayerRoomBackgroundScreen();
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
 
+            userModsSelectOverlayRegistration?.Dispose();
+
             if (client.IsNotNull())
             {
                 client.RoomUpdated -= onRoomUpdated;
+                client.SettingsChanged -= onSettingsChanged;
+                client.ItemChanged -= onItemChanged;
+                client.UserStyleChanged -= onUserStyleChanged;
+                client.UserModsChanged -= onUserModsChanged;
                 client.LoadRequested -= onLoadRequested;
             }
-
-            modSettingChangeTracker?.Dispose();
         }
 
         public partial class AddItemButton : PurpleRoundedButton
         {
+            [Resolved]
+            private MultiplayerClient client { get; set; } = null!;
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                client.RoomUpdated += onRoomUpdated;
+                onRoomUpdated();
+            }
+
+            private void onRoomUpdated()
+            {
+                if (client.Room == null || client.LocalUser == null)
+                    return;
+
+                Alpha = client.Room.CanAddPlaylistItems(client.LocalUser) ? 1 : 0;
+            }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                if (client.IsNotNull())
+                    client.RoomUpdated -= onRoomUpdated;
+            }
         }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs
index 3d4b46f49e..d6f5529d4a 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs
@@ -15,8 +15,8 @@ using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
-using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Ranking;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Users;
 
 namespace osu.Game.Screens.OnlinePlay.Multiplayer
@@ -25,6 +25,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
     {
         protected override bool PauseOnFocusLost => false;
 
+        protected override bool ShowLeaderboard => true;
+
         protected override UserActivity InitialActivity => new UserActivity.InMultiplayerGame(Beatmap.Value.BeatmapInfo, Ruleset.Value);
 
         [Resolved]
@@ -33,10 +35,13 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         private IBindable<bool> isConnected = null!;
 
         private readonly TaskCompletionSource<bool> resultsReady = new TaskCompletionSource<bool>();
-        private readonly MultiplayerRoomUser[] users;
 
         private LoadingLayer loadingDisplay = null!;
-        private MultiplayerGameplayLeaderboard multiplayerLeaderboard = null!;
+
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private readonly MultiplayerLeaderboardProvider leaderboardProvider;
+
+        private GameplayMatchScoreDisplay teamScoreDisplay = null!;
 
         /// <summary>
         /// Construct a multiplayer player.
@@ -55,7 +60,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                 AlwaysShowLeaderboard = true,
             })
         {
-            this.users = users;
+            leaderboardProvider = new MultiplayerLeaderboardProvider(users);
         }
 
         [BackgroundDependencyLoader]
@@ -71,26 +76,24 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                 Expanded = { BindTarget = LeaderboardExpandedState },
             }, chat => HUDOverlay.LeaderboardFlow.Insert(2, chat));
 
-            HUDOverlay.Add(loadingDisplay = new LoadingLayer(true) { Depth = float.MaxValue });
-        }
-
-        protected override GameplayLeaderboard CreateGameplayLeaderboard() => multiplayerLeaderboard = new MultiplayerGameplayLeaderboard(users);
-
-        protected override void AddLeaderboardToHUD(GameplayLeaderboard leaderboard)
-        {
-            Debug.Assert(leaderboard == multiplayerLeaderboard);
-
-            HUDOverlay.LeaderboardFlow.Insert(0, leaderboard);
-
-            if (multiplayerLeaderboard.TeamScores.Count >= 2)
+            LoadComponentAsync(teamScoreDisplay = new GameplayMatchScoreDisplay
             {
-                LoadComponentAsync(new GameplayMatchScoreDisplay
+                Expanded = { BindTarget = HUDOverlay.ShowHud },
+                Alpha = 0,
+            }, scoreDisplay => HUDOverlay.LeaderboardFlow.Insert(1, scoreDisplay));
+            LoadComponentAsync(leaderboardProvider, loaded =>
+            {
+                AddInternal(loaded);
+
+                if (loaded.HasTeams)
                 {
-                    Team1Score = { BindTarget = multiplayerLeaderboard.TeamScores.First().Value },
-                    Team2Score = { BindTarget = multiplayerLeaderboard.TeamScores.Last().Value },
-                    Expanded = { BindTarget = HUDOverlay.ShowHud },
-                }, scoreDisplay => HUDOverlay.LeaderboardFlow.Insert(1, scoreDisplay));
-            }
+                    teamScoreDisplay.Alpha = 1;
+                    teamScoreDisplay.Team1Score.BindTarget = leaderboardProvider.TeamScores.First().Value;
+                    teamScoreDisplay.Team2Score.BindTarget = leaderboardProvider.TeamScores.Last().Value;
+                }
+            });
+
+            HUDOverlay.Add(loadingDisplay = new LoadingLayer(true) { Depth = float.MaxValue });
         }
 
         protected override void LoadAsyncComplete()
@@ -195,8 +198,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         {
             Debug.Assert(Room.RoomID != null);
 
-            return multiplayerLeaderboard.TeamScores.Count == 2
-                ? new MultiplayerTeamResultsScreen(score, Room.RoomID.Value, PlaylistItem, multiplayerLeaderboard.TeamScores)
+            return leaderboardProvider.TeamScores.Count == 2
+                ? new MultiplayerTeamResultsScreen(score, Room.RoomID.Value, PlaylistItem, leaderboardProvider.TeamScores)
                 {
                     IsLocalPlay = true,
                 }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomBackgroundScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomBackgroundScreen.cs
new file mode 100644
index 0000000000..6cb3b7c688
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomBackgroundScreen.cs
@@ -0,0 +1,41 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Components;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer
+{
+    public partial class MultiplayerRoomBackgroundScreen : OnlinePlayBackgroundScreen
+    {
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            client.RoomUpdated += onRoomUpdated;
+            onRoomUpdated();
+        }
+
+        private void onRoomUpdated() => Scheduler.AddOnce(() =>
+        {
+            if (client.Room == null)
+                return;
+
+            PlaylistItem = new PlaylistItem(client.Room.CurrentPlaylistItem);
+        });
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+                client.RoomUpdated -= onRoomUpdated;
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomPanel.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomPanel.cs
new file mode 100644
index 0000000000..e52133b46b
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomPanel.cs
@@ -0,0 +1,78 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Lounge.Components;
+using osu.Game.Screens.OnlinePlay.Match.Components;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer
+{
+    /// <summary>
+    /// A <see cref="RoomPanel"/> to be displayed in a multiplayer lobby.
+    /// </summary>
+    public partial class MultiplayerRoomPanel : RoomPanel
+    {
+        public Action? OnEdit { get; set; }
+
+        public Drawable ChangeSettingsButton { get; private set; } = null!;
+
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        public MultiplayerRoomPanel(Room room)
+            : base(room)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            ButtonsContainer.Add(ChangeSettingsButton = new PurpleRoundedButton
+            {
+                RelativeSizeAxes = Axes.Y,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(120, 0.7f),
+                Text = "Change settings",
+                Action = () => OnEdit?.Invoke()
+            });
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            client.RoomUpdated += onRoomUpdated;
+            onRoomUpdated();
+        }
+
+        private void onRoomUpdated() => Scheduler.AddOnce(() =>
+        {
+            if (client.Room == null || client.LocalUser == null)
+                return;
+
+            ChangeSettingsButton.Alpha = client.IsHost ? 1 : 0;
+            SelectedItem.Value = new PlaylistItem(client.Room.CurrentPlaylistItem);
+        });
+
+        protected override UpdateableBeatmapBackgroundSprite CreateBackground() => base.CreateBackground().With(d =>
+        {
+            d.BackgroundLoadDelay = 0;
+        });
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+                client.RoomUpdated -= onRoomUpdated;
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerUserModDisplay.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerUserModDisplay.cs
new file mode 100644
index 0000000000..8937feed5e
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerUserModDisplay.cs
@@ -0,0 +1,67 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer
+{
+    public partial class MultiplayerUserModDisplay : CompositeDrawable
+    {
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
+        private ModDisplay modDisplay = null!;
+
+        public MultiplayerUserModDisplay()
+        {
+            AutoSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChild = modDisplay = new ModDisplay();
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            client.RoomUpdated += onRoomUpdated;
+            onRoomUpdated();
+        }
+
+        private void onRoomUpdated() => Scheduler.AddOnce(() =>
+        {
+            if (client.Room == null || client.LocalUser == null)
+                return;
+
+            MultiplayerPlaylistItem currentItem = client.Room.CurrentPlaylistItem;
+            Ruleset ruleset = rulesets.GetRuleset(client.LocalUser.RulesetId ?? currentItem.RulesetID)!.CreateInstance();
+            Mod[] userMods = client.LocalUser.Mods.Select(m => m.ToMod(ruleset)).ToArray();
+
+            if (!userMods.SequenceEqual(modDisplay.Current.Value))
+                modDisplay.Current.Value = userMods;
+        });
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+                client.RoomUpdated -= onRoomUpdated;
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
index 33c3c60ed3..85b6966eaa 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
@@ -15,6 +15,7 @@ using osu.Game.Online.Rooms;
 using osu.Game.Online.Spectator;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Screens.Spectate;
 using osu.Game.Users;
 using osuTK;
@@ -47,17 +48,18 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         [Resolved]
         private MultiplayerClient multiplayerClient { get; set; } = null!;
 
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private MultiSpectatorLeaderboardProvider leaderboardProvider { get; set; }
+
         private IAggregateAudioAdjustment? boundAdjustments;
 
         private readonly PlayerArea[] instances;
         private MasterGameplayClockContainer masterClockContainer = null!;
         private SpectatorSyncManager syncManager = null!;
         private PlayerGrid grid = null!;
-        private MultiSpectatorLeaderboard leaderboard = null!;
         private PlayerArea? currentAudioSource;
 
         private readonly Room room;
-        private readonly MultiplayerRoomUser[] users;
 
         /// <summary>
         /// Creates a new <see cref="MultiSpectatorScreen"/>.
@@ -68,9 +70,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             : base(users.Select(u => u.UserID).ToArray())
         {
             this.room = room;
-            this.users = users;
 
             instances = new PlayerArea[Users.Count];
+            leaderboardProvider = new MultiSpectatorLeaderboardProvider(users);
         }
 
         [BackgroundDependencyLoader]
@@ -133,25 +135,25 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             for (int i = 0; i < Users.Count; i++)
                 grid.Add(instances[i] = new PlayerArea(Users[i], syncManager.CreateManagedClock()));
 
-            LoadComponentAsync(leaderboard = new MultiSpectatorLeaderboard(users)
-            {
-                Expanded = { Value = true },
-            }, _ =>
+            LoadComponentAsync(leaderboardProvider, _ =>
             {
+                AddInternal(leaderboardProvider);
                 foreach (var instance in instances)
-                    leaderboard.AddClock(instance.UserId, instance.SpectatorPlayerClock);
+                    leaderboardProvider.AddClock(instance.UserId, instance.SpectatorPlayerClock);
 
-                leaderboardFlow.Insert(0, leaderboard);
-
-                if (leaderboard.TeamScores.Count == 2)
+                if (leaderboardProvider.TeamScores.Count == 2)
                 {
                     LoadComponentAsync(new MatchScoreDisplay
                     {
-                        Team1Score = { BindTarget = leaderboard.TeamScores.First().Value },
-                        Team2Score = { BindTarget = leaderboard.TeamScores.Last().Value },
+                        Team1Score = { BindTarget = leaderboardProvider.TeamScores.First().Value },
+                        Team2Score = { BindTarget = leaderboardProvider.TeamScores.Last().Value },
                     }, scoreDisplayContainer.Add);
                 }
             });
+            leaderboardFlow.Insert(0, new DrawableGameplayLeaderboard
+            {
+                Expanded = { Value = true }
+            });
 
             LoadComponentAsync(new GameplayChatDisplay(room)
             {
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsLoungeSubScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsLoungeSubScreen.cs
index eccbaf7930..cc4065a82b 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsLoungeSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsLoungeSubScreen.cs
@@ -60,7 +60,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             return criteria;
         }
 
-        protected override void JoinInternal(Room room, string? password, Action<Room> onSuccess, Action<string> onFailure)
+        protected override void JoinInternal(Room room, string? password, Action<Room> onSuccess, Action<string, Exception?> onFailure)
         {
             var joinRoomRequest = new JoinRoomRequest(room, password);
 
@@ -68,7 +68,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             joinRoomRequest.Failure += exception =>
             {
                 if (exception is not OperationCanceledException)
-                    onFailure(exception.Message);
+                    onFailure($"Failed to open playlist. {exception.Message}", exception);
             };
 
             api.Queue(joinRoomRequest);
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomPanel.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomPanel.cs
new file mode 100644
index 0000000000..d6c0f4dcbc
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomPanel.cs
@@ -0,0 +1,36 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Lounge.Components;
+
+namespace osu.Game.Screens.OnlinePlay.Playlists
+{
+    /// <summary>
+    /// A <see cref="RoomPanel"/> to be displayed in a playlists lobby.
+    /// </summary>
+    public partial class PlaylistsRoomPanel : RoomPanel
+    {
+        public new required Bindable<PlaylistItem?> SelectedItem
+        {
+            get => selectedItem.Current;
+            set => selectedItem.Current = value;
+        }
+
+        private readonly BindableWithCurrent<PlaylistItem?> selectedItem = new BindableWithCurrent<PlaylistItem?>();
+
+        public PlaylistsRoomPanel(Room room)
+            : base(room)
+        {
+            base.SelectedItem.BindTo(SelectedItem);
+        }
+
+        protected override UpdateableBeatmapBackgroundSprite CreateBackground() => base.CreateBackground().With(d =>
+        {
+            d.BackgroundLoadDelay = 0;
+        });
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
index 89416e66bf..9834598ac0 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
@@ -191,9 +191,8 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                                 {
                                     new Drawable[]
                                     {
-                                        new DrawableMatchRoom(room, false)
+                                        new PlaylistsRoomPanel(room)
                                         {
-                                            OnEdit = () => settingsOverlay.Show(),
                                             SelectedItem = SelectedItem
                                         }
                                     },
@@ -251,12 +250,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                                                                             SelectedItem = { BindTarget = SelectedItem },
                                                                             AllowSelection = true,
                                                                             AllowShowingResults = true,
-                                                                            RequestResults = item =>
-                                                                            {
-                                                                                Debug.Assert(room.RoomID != null);
-                                                                                parentScreen?.Push(new PlaylistItemUserBestResultsScreen(room.RoomID.Value, item,
-                                                                                    api.LocalUser.Value.Id));
-                                                                            }
+                                                                            RequestResults = showResults
                                                                         }
                                                                     },
                                                                     new Drawable[]
@@ -443,6 +437,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             {
                 SelectedItem = { BindTarget = SelectedItem },
                 SelectedMods = { BindTarget = UserMods },
+                Beatmap = { BindTarget = Beatmap },
                 IsValidMod = _ => false
             });
         }
@@ -470,6 +465,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             });
 
             updateSetupState();
+            updateUserScore();
             updateGameplayState();
         }
 
@@ -485,6 +481,10 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                 case nameof(Room.RoomID):
                     updateSetupState();
                     break;
+
+                case nameof(Room.UserScore):
+                    updateUserScore();
+                    break;
             }
         }
 
@@ -512,12 +512,32 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                     progressSection.Alpha = room.MaxAttempts != null ? 1 : 0;
                     drawablePlaylist.Items.ReplaceRange(0, drawablePlaylist.Items.Count, room.Playlist);
 
+                    updateUserScore();
+
                     // Select an initial item for the user to help them get into a playable state quicker.
                     SelectedItem.Value = room.Playlist.FirstOrDefault();
                 });
             }
         }
 
+        /// <summary>
+        /// Responds to changes in <see cref="Room.UserScore"/> to mark playlist items as completed.
+        /// </summary>
+        private void updateUserScore()
+        {
+            if (room.UserScore == null)
+                return;
+
+            if (drawablePlaylist.Items.Count == 0)
+                return;
+
+            foreach (var item in room.UserScore.PlaylistItemAttempts)
+            {
+                if (item.Passed)
+                    drawablePlaylist.Items.Single(i => i.ID == item.PlaylistItemID).MarkCompleted();
+            }
+        }
+
         /// <summary>
         /// Adjusts the rate at which the <see cref="Room"/> is updated.
         /// </summary>
@@ -597,8 +617,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
             // Update global gameplay state to correspond to the new selection.
             // Retrieve the corresponding local beatmap, since we can't directly use the playlist's beatmap info
-            int beatmapId = gameplayBeatmap.OnlineID;
-            var localBeatmap = beatmapManager.QueryBeatmap(b => b.OnlineID == beatmapId);
+            var localBeatmap = beatmapManager.QueryBeatmap($@"{nameof(BeatmapInfo.OnlineID)} == $0 AND {nameof(BeatmapInfo.MD5Hash)} == {nameof(BeatmapInfo.OnlineMD5Hash)}", gameplayBeatmap.OnlineID);
             Beatmap.Value = beatmapManager.GetWorkingBeatmap(localBeatmap);
             Ruleset.Value = gameplayRuleset;
             Mods.Value = UserMods.Value.Concat(item.RequiredMods.Select(m => m.ToMod(rulesetInstance))).ToArray();
@@ -691,6 +710,21 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             });
         }
 
+        /// <summary>
+        /// Shows the results screen for a playlist item.
+        /// </summary>
+        private void showResults(PlaylistItem item)
+        {
+            if (!this.IsCurrentScreen())
+                return;
+
+            Debug.Assert(room.RoomID != null);
+
+            // fallback is to allow this class to operate when there is no parent OnlineScreen (testing purposes).
+            var targetScreen = (Screen?)parentScreen ?? this;
+            targetScreen.Push(new PlaylistItemUserBestResultsScreen(room.RoomID.Value, item, api.LocalUser.Value.OnlineID));
+        }
+
         /// <summary>
         /// May be invoked by the owner of the room to permanently close the room ahead of its intended end date.
         /// </summary>
diff --git a/osu.Game/Screens/Play/GameplayState.cs b/osu.Game/Screens/Play/GameplayState.cs
index 851e95495f..80546ef6da 100644
--- a/osu.Game/Screens/Play/GameplayState.cs
+++ b/osu.Game/Screens/Play/GameplayState.cs
@@ -62,6 +62,8 @@ namespace osu.Game.Screens.Play
         /// </summary>
         public bool HasQuit { get; set; }
 
+        public bool HasCompleted => HasPassed || HasFailed || HasQuit;
+
         /// <summary>
         /// A bindable tracking the last judgement result applied to any hit object.
         /// </summary>
diff --git a/osu.Game/Screens/Play/HUD/GameplayLeaderboard.cs b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
similarity index 69%
rename from osu.Game/Screens/Play/HUD/GameplayLeaderboard.cs
rename to osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
index f6694505dc..005cd784c4 100644
--- a/osu.Game/Screens/Play/HUD/GameplayLeaderboard.cs
+++ b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboard.cs
@@ -3,40 +3,48 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Caching;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Configuration;
 using osu.Game.Graphics.Containers;
-using osu.Game.Users;
+using osu.Game.Screens.Select.Leaderboards;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Screens.Play.HUD
 {
-    public abstract partial class GameplayLeaderboard : CompositeDrawable
+    public partial class DrawableGameplayLeaderboard : CompositeDrawable
     {
         private readonly Cached sorting = new Cached();
 
         public Bindable<bool> Expanded = new Bindable<bool>();
 
-        protected readonly FillFlowContainer<GameplayLeaderboardScore> Flow;
+        protected readonly FillFlowContainer<DrawableGameplayLeaderboardScore> Flow;
 
         private bool requiresScroll;
         private readonly OsuScrollContainer scroll;
 
-        public GameplayLeaderboardScore? TrackedScore { get; private set; }
+        public DrawableGameplayLeaderboardScore? TrackedScore { get; private set; }
+
+        [Resolved]
+        private IGameplayLeaderboardProvider? leaderboardProvider { get; set; }
+
+        private readonly IBindableList<GameplayLeaderboardScore> scores = new BindableList<GameplayLeaderboardScore>();
+        private readonly Bindable<bool> configVisibility = new Bindable<bool>();
 
         private const int max_panels = 8;
 
         /// <summary>
         /// Create a new leaderboard.
         /// </summary>
-        protected GameplayLeaderboard()
+        public DrawableGameplayLeaderboard()
         {
-            Width = GameplayLeaderboardScore.EXTENDED_WIDTH + GameplayLeaderboardScore.SHEAR_WIDTH;
+            Width = DrawableGameplayLeaderboardScore.EXTENDED_WIDTH + DrawableGameplayLeaderboardScore.SHEAR_WIDTH;
 
             InternalChildren = new Drawable[]
             {
@@ -44,10 +52,10 @@ namespace osu.Game.Screens.Play.HUD
                 {
                     ClampExtension = 0,
                     RelativeSizeAxes = Axes.Both,
-                    Child = Flow = new FillFlowContainer<GameplayLeaderboardScore>
+                    Child = Flow = new FillFlowContainer<DrawableGameplayLeaderboardScore>
                     {
                         RelativeSizeAxes = Axes.X,
-                        X = GameplayLeaderboardScore.SHEAR_WIDTH,
+                        X = DrawableGameplayLeaderboardScore.SHEAR_WIDTH,
                         AutoSizeAxes = Axes.Y,
                         Direction = FillDirection.Vertical,
                         Spacing = new Vector2(2.5f),
@@ -58,26 +66,39 @@ namespace osu.Game.Screens.Play.HUD
             };
         }
 
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            config.BindWith(OsuSetting.GameplayLeaderboard, configVisibility);
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
+            if (leaderboardProvider != null)
+            {
+                scores.BindTo(leaderboardProvider.Scores);
+                scores.BindCollectionChanged((_, _) =>
+                {
+                    Clear();
+                    foreach (var score in scores)
+                        Add(score);
+                }, true);
+            }
+
             Scheduler.AddDelayed(sort, 1000, true);
+            configVisibility.BindValueChanged(_ => this.FadeTo(configVisibility.Value ? 1 : 0, 100, Easing.OutQuint), true);
         }
 
         /// <summary>
         /// Adds a player to the leaderboard.
         /// </summary>
-        /// <param name="user">The player.</param>
-        /// <param name="isTracked">
-        /// Whether the player should be tracked on the leaderboard.
-        /// Set to <c>true</c> for the local player or a player whose replay is currently being played.
-        /// </param>
-        public ILeaderboardScore Add(IUser? user, bool isTracked)
+        public void Add(GameplayLeaderboardScore score)
         {
-            var drawable = CreateLeaderboardScoreDrawable(user, isTracked);
+            var drawable = CreateLeaderboardScoreDrawable(score);
 
-            if (isTracked)
+            if (score.Tracked)
             {
                 if (TrackedScore != null)
                     throw new InvalidOperationException("Cannot track more than one score.");
@@ -92,10 +113,8 @@ namespace osu.Game.Screens.Play.HUD
             drawable.DisplayOrder.BindValueChanged(_ => sorting.Invalidate(), true);
 
             int displayCount = Math.Min(Flow.Count, max_panels);
-            Height = displayCount * (GameplayLeaderboardScore.PANEL_HEIGHT + Flow.Spacing.Y);
+            Height = displayCount * (DrawableGameplayLeaderboardScore.PANEL_HEIGHT + Flow.Spacing.Y);
             requiresScroll = displayCount != Flow.Count;
-
-            return drawable;
         }
 
         public void Clear()
@@ -105,8 +124,8 @@ namespace osu.Game.Screens.Play.HUD
             scroll.ScrollToStart(false);
         }
 
-        protected virtual GameplayLeaderboardScore CreateLeaderboardScoreDrawable(IUser? user, bool isTracked) =>
-            new GameplayLeaderboardScore(user, isTracked);
+        protected virtual DrawableGameplayLeaderboardScore CreateLeaderboardScoreDrawable(GameplayLeaderboardScore score) =>
+            new DrawableGameplayLeaderboardScore(score);
 
         protected override void Update()
         {
@@ -119,7 +138,7 @@ namespace osu.Game.Screens.Play.HUD
                 scroll.ScrollTo(scrollTarget);
             }
 
-            const float panel_height = GameplayLeaderboardScore.PANEL_HEIGHT;
+            const float panel_height = DrawableGameplayLeaderboardScore.PANEL_HEIGHT;
 
             float fadeBottom = (float)(scroll.Current + scroll.DrawHeight);
             float fadeTop = (float)(scroll.Current + panel_height);
@@ -170,15 +189,14 @@ namespace osu.Game.Screens.Play.HUD
 
             for (int i = 0; i < Flow.Count; i++)
             {
-                Flow.SetLayoutPosition(orderedByScore[i], i);
-                orderedByScore[i].ScorePosition = CheckValidScorePosition(orderedByScore[i], i + 1) ? i + 1 : null;
+                var score = orderedByScore[i];
+                Flow.SetLayoutPosition(score, i);
+                score.ScorePosition = i + 1 == Flow.Count && leaderboardProvider?.IsPartial == true && score.Tracked ? null : i + 1;
             }
 
             sorting.Validate();
         }
 
-        protected virtual bool CheckValidScorePosition(GameplayLeaderboardScore score, int position) => true;
-
         private partial class InputDisabledScrollContainer : OsuScrollContainer
         {
             public InputDisabledScrollContainer()
diff --git a/osu.Game/Screens/Play/HUD/GameplayLeaderboardScore.cs b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboardScore.cs
similarity index 95%
rename from osu.Game/Screens/Play/HUD/GameplayLeaderboardScore.cs
rename to osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboardScore.cs
index 3d46517a68..b14e31983c 100644
--- a/osu.Game/Screens/Play/HUD/GameplayLeaderboardScore.cs
+++ b/osu.Game/Screens/Play/HUD/DrawableGameplayLeaderboardScore.cs
@@ -14,6 +14,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Online.API;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Users;
 using osu.Game.Users.Drawables;
 using osu.Game.Utils;
@@ -22,7 +23,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Screens.Play.HUD
 {
-    public partial class GameplayLeaderboardScore : CompositeDrawable, ILeaderboardScore
+    public partial class DrawableGameplayLeaderboardScore : CompositeDrawable
     {
         public const float EXTENDED_WIDTH = regular_width + top_player_left_width_extension;
 
@@ -112,19 +113,27 @@ namespace osu.Game.Screens.Play.HUD
         private bool isFriend;
 
         /// <summary>
-        /// Creates a new <see cref="GameplayLeaderboardScore"/>.
+        /// Creates a new <see cref="DrawableGameplayLeaderboardScore"/>.
         /// </summary>
-        /// <param name="user">The score's player.</param>
-        /// <param name="tracked">Whether the player is the local user or a replay player.</param>
-        public GameplayLeaderboardScore(IUser? user, bool tracked)
+        public DrawableGameplayLeaderboardScore(GameplayLeaderboardScore score)
         {
-            User = user;
-            Tracked = tracked;
+            User = score.User;
+            Tracked = score.Tracked;
+            TotalScore.BindTo(score.TotalScore);
+            Accuracy.BindTo(score.Accuracy);
+            Combo.BindTo(score.Combo);
+            HasQuit.BindTo(score.HasQuit);
+            DisplayOrder.BindTo(score.DisplayOrder);
+            GetDisplayScore = score.GetDisplayScore;
+
+            if (score.TeamColour != null)
+            {
+                BackgroundColour = score.TeamColour.Value;
+                TextColour = Color4.White;
+            }
 
             AutoSizeAxes = Axes.X;
             Height = PANEL_HEIGHT;
-
-            GetDisplayScore = _ => TotalScore.Value;
         }
 
         [BackgroundDependencyLoader]
diff --git a/osu.Game/Screens/Play/HUD/ILeaderboardScore.cs b/osu.Game/Screens/Play/HUD/ILeaderboardScore.cs
deleted file mode 100644
index 1a5d7fd9a8..0000000000
--- a/osu.Game/Screens/Play/HUD/ILeaderboardScore.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Bindables;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Screens.Play.HUD
-{
-    public interface ILeaderboardScore
-    {
-        BindableLong TotalScore { get; }
-        BindableDouble Accuracy { get; }
-        BindableInt Combo { get; }
-
-        BindableBool HasQuit { get; }
-
-        /// <summary>
-        /// An optional value to guarantee stable ordering.
-        /// Lower numbers will appear higher in cases of <see cref="TotalScore"/> ties.
-        /// </summary>
-        Bindable<long> DisplayOrder { get; }
-
-        /// <summary>
-        /// A custom function which handles converting a score to a display score using a provide <see cref="ScoringMode"/>.
-        /// </summary>
-        /// <remarks>
-        /// If no function is provided, <see cref="TotalScore"/> will be used verbatim.</remarks>
-        Func<ScoringMode, long> GetDisplayScore { set; }
-    }
-}
diff --git a/osu.Game/Screens/Play/HUD/SoloGameplayLeaderboard.cs b/osu.Game/Screens/Play/HUD/SoloGameplayLeaderboard.cs
deleted file mode 100644
index e9bb1d2101..0000000000
--- a/osu.Game/Screens/Play/HUD/SoloGameplayLeaderboard.cs
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Game.Configuration;
-using osu.Game.Online.API.Requests;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Scoring;
-using osu.Game.Scoring.Legacy;
-using osu.Game.Screens.Select;
-using osu.Game.Users;
-
-namespace osu.Game.Screens.Play.HUD
-{
-    public partial class SoloGameplayLeaderboard : GameplayLeaderboard
-    {
-        private const int duration = 100;
-
-        private readonly Bindable<bool> configVisibility = new Bindable<bool>();
-
-        private readonly Bindable<PlayBeatmapDetailArea.TabType> scoreSource = new Bindable<PlayBeatmapDetailArea.TabType>();
-
-        private readonly IUser trackingUser;
-
-        public readonly IBindableList<ScoreInfo> Scores = new BindableList<ScoreInfo>();
-
-        [Resolved]
-        private ScoreProcessor scoreProcessor { get; set; } = null!;
-
-        /// <summary>
-        /// Whether the leaderboard should be visible regardless of the configuration value.
-        /// This is true by default, but can be changed.
-        /// </summary>
-        public readonly Bindable<bool> AlwaysVisible = new Bindable<bool>(true);
-
-        public SoloGameplayLeaderboard(IUser trackingUser)
-        {
-            this.trackingUser = trackingUser;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            config.BindWith(OsuSetting.GameplayLeaderboard, configVisibility);
-            config.BindWith(OsuSetting.BeatmapDetailTab, scoreSource);
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Scores.BindCollectionChanged((_, _) => Scheduler.AddOnce(showScores), true);
-
-            // Alpha will be updated via `updateVisibility` below.
-            Alpha = 0;
-
-            AlwaysVisible.BindValueChanged(_ => updateVisibility());
-            configVisibility.BindValueChanged(_ => updateVisibility(), true);
-        }
-
-        private void showScores()
-        {
-            Clear();
-
-            if (!Scores.Any())
-                return;
-
-            foreach (var s in Scores)
-            {
-                var score = Add(s.User, false);
-
-                score.GetDisplayScore = s.GetDisplayScore;
-                score.TotalScore.Value = s.TotalScore;
-                score.Accuracy.Value = s.Accuracy;
-                score.Combo.Value = s.MaxCombo;
-                score.DisplayOrder.Value = s.OnlineID > 0 ? s.OnlineID : s.Date.ToUnixTimeSeconds();
-            }
-
-            ILeaderboardScore local = Add(trackingUser, true);
-
-            local.GetDisplayScore = scoreProcessor.GetDisplayScore;
-            local.TotalScore.BindTarget = scoreProcessor.TotalScore;
-            local.Accuracy.BindTarget = scoreProcessor.Accuracy;
-            local.Combo.BindTarget = scoreProcessor.HighestCombo;
-
-            // Local score should always show lower than any existing scores in cases of ties.
-            local.DisplayOrder.Value = long.MaxValue;
-        }
-
-        protected override bool CheckValidScorePosition(GameplayLeaderboardScore score, int position)
-        {
-            // change displayed position to '-' when there are 50 already submitted scores and tracked score is last
-            if (score.Tracked && scoreSource.Value != PlayBeatmapDetailArea.TabType.Local)
-            {
-                if (position == Flow.Count && Flow.Count > GetScoresRequest.MAX_SCORES_PER_REQUEST)
-                    return false;
-            }
-
-            return base.CheckValidScorePosition(score, position);
-        }
-
-        private void updateVisibility() =>
-            this.FadeTo(AlwaysVisible.Value || configVisibility.Value ? 1 : 0, duration);
-    }
-}
diff --git a/osu.Game/Screens/Play/HUDOverlay.cs b/osu.Game/Screens/Play/HUDOverlay.cs
index 75a28a4240..733675dfb1 100644
--- a/osu.Game/Screens/Play/HUDOverlay.cs
+++ b/osu.Game/Screens/Play/HUDOverlay.cs
@@ -14,6 +14,7 @@ using osu.Framework.Graphics.Primitives;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Configuration;
+using osu.Game.Input;
 using osu.Game.Input.Bindings;
 using osu.Game.Localisation;
 using osu.Game.Overlays;
@@ -195,7 +196,7 @@ namespace osu.Game.Screens.Play
         }
 
         [BackgroundDependencyLoader(true)]
-        private void load(OsuConfigManager config, INotificationOverlay notificationOverlay)
+        private void load(OsuConfigManager config, RealmKeyBindingStore keyBindingStore, INotificationOverlay notificationOverlay)
         {
             if (drawableRuleset != null)
             {
@@ -214,7 +215,7 @@ namespace osu.Game.Screens.Play
 
                 notificationOverlay?.Post(new SimpleNotification
                 {
-                    Text = NotificationsStrings.ScoreOverlayDisabled(config.LookupKeyBindings(GlobalAction.ToggleInGameInterface))
+                    Text = NotificationsStrings.ScoreOverlayDisabled(keyBindingStore.GetBindingsStringFor(GlobalAction.ToggleInGameInterface))
                 });
             }
 
diff --git a/osu.Game/Screens/Play/Player.cs b/osu.Game/Screens/Play/Player.cs
index a738a40993..127142e24b 100644
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@@ -58,6 +58,11 @@ namespace osu.Game.Screens.Play
 
         public override bool AllowUserExit => false; // handled by HoldForMenuButton
 
+        /// <summary>
+        /// Raised after all gameplay has finished.
+        /// </summary>
+        public event Action OnShowingResults;
+
         protected override bool PlayExitSound => !isRestarting;
 
         protected override UserActivity InitialActivity => new UserActivity.InSoloGame(Beatmap.Value.BeatmapInfo, Ruleset.Value);
@@ -112,6 +117,12 @@ namespace osu.Game.Screens.Play
         /// </summary>
         public IBindable<bool> ShowingOverlayComponents = new Bindable<bool>();
 
+        /// <summary>
+        /// A flag which can be checked to decide whether we are in a state where settings that affect
+        /// game balance should be allowed to be applied at the current point in time.
+        /// </summary>
+        public virtual bool AllowCriticalSettingsAdjustment { get; } = true;
+
         // Should match PlayerLoader for consistency. Cached here for the rare case we push a Player
         // without the loading screen (one such usage is the skin editor's scene library).
         [Cached]
@@ -135,6 +146,8 @@ namespace osu.Game.Screens.Play
 
         public BreakOverlay BreakOverlay;
 
+        private LetterboxOverlay letterboxOverlay;
+
         /// <summary>
         /// Whether the gameplay is currently in a break.
         /// </summary>
@@ -277,6 +290,12 @@ namespace osu.Game.Screens.Play
             var rulesetSkinProvider = new RulesetSkinProvidingContainer(ruleset, playableBeatmap, Beatmap.Value.Skin);
             GameplayClockContainer.Add(new GameplayScrollWheelHandling());
 
+            // needs to exist in frame stable content, but is used by underlay layers so make sure assigned early.
+            breakTracker = new BreakTracker(DrawableRuleset.GameplayStartTime, ScoreProcessor)
+            {
+                Breaks = Beatmap.Value.Beatmap.Breaks
+            };
+
             // load the skinning hierarchy first.
             // this is intentionally done in two stages to ensure things are in a loaded state before exposing the ruleset to skin sources.
             GameplayClockContainer.Add(rulesetSkinProvider);
@@ -292,7 +311,7 @@ namespace osu.Game.Screens.Play
                     Children = new[]
                     {
                         // underlay and gameplay should have access to the skinning sources.
-                        createUnderlayComponents(),
+                        createUnderlayComponents(Beatmap.Value),
                         createGameplayComponents(Beatmap.Value)
                     }
                 },
@@ -335,10 +354,13 @@ namespace osu.Game.Screens.Play
             dependencies.CacheAs(DrawableRuleset.FrameStableClock);
             dependencies.CacheAs<IGameplayClock>(DrawableRuleset.FrameStableClock);
 
+            letterboxOverlay.Clock = DrawableRuleset.FrameStableClock;
+            letterboxOverlay.ProcessCustomClock = false;
+
             // add the overlay components as a separate step as they proxy some elements from the above underlay/gameplay components.
             // also give the overlays the ruleset skin provider to allow rulesets to potentially override HUD elements (used to disable combo counters etc.)
             // we may want to limit this in the future to disallow rulesets from outright replacing elements the user expects to be there.
-            failAnimationContainer.Add(createOverlayComponents(Beatmap.Value));
+            failAnimationContainer.Add(createOverlayComponents());
 
             if (!DrawableRuleset.AllowGameplayOverlays)
             {
@@ -409,14 +431,22 @@ namespace osu.Game.Screens.Play
 
         protected virtual GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart) => new MasterGameplayClockContainer(beatmap, gameplayStart);
 
-        private Drawable createUnderlayComponents()
+        private Drawable createUnderlayComponents(WorkingBeatmap working)
         {
             var container = new Container
             {
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
                 {
-                    DimmableStoryboard = new DimmableStoryboard(GameplayState.Storyboard, GameplayState.Mods) { RelativeSizeAxes = Axes.Both },
+                    DimmableStoryboard = new DimmableStoryboard(GameplayState.Storyboard, GameplayState.Mods)
+                    {
+                        RelativeSizeAxes = Axes.Both
+                    },
+                    letterboxOverlay = new LetterboxOverlay
+                    {
+                        BreakTracker = breakTracker,
+                        Alpha = working.Beatmap.LetterboxInBreaks ? 1 : 0,
+                    },
                     new KiaiGameplayFountains(),
                 },
             };
@@ -434,15 +464,12 @@ namespace osu.Game.Screens.Play
                         ScoreProcessor,
                         HealthProcessor,
                         new ComboEffects(ScoreProcessor),
-                        breakTracker = new BreakTracker(DrawableRuleset.GameplayStartTime, ScoreProcessor)
-                        {
-                            Breaks = working.Beatmap.Breaks
-                        }
+                        breakTracker,
                     }),
             }
         };
 
-        private Drawable createOverlayComponents(IWorkingBeatmap working)
+        private Drawable createOverlayComponents()
         {
             var container = new Container
             {
@@ -450,13 +477,6 @@ namespace osu.Game.Screens.Play
                 Children = new[]
                 {
                     DimmableStoryboard.OverlayLayerContainer.CreateProxy(),
-                    new LetterboxOverlay
-                    {
-                        Clock = DrawableRuleset.FrameStableClock,
-                        ProcessCustomClock = false,
-                        BreakTracker = breakTracker,
-                        Alpha = working.Beatmap.LetterboxInBreaks ? 1 : 0,
-                    },
                     HUDOverlay = new HUDOverlay(DrawableRuleset, GameplayState.Mods, Configuration.AlwaysShowLeaderboard)
                     {
                         HoldToQuit =
@@ -858,6 +878,7 @@ namespace osu.Game.Screens.Play
                     // This player instance may already be in the process of exiting.
                     return;
 
+                OnShowingResults?.Invoke();
                 this.Push(CreateResults(prepareScoreForDisplayTask.GetResultSafely()));
             }, Time.Current + delay, 50);
 
@@ -914,34 +935,30 @@ namespace osu.Game.Screens.Play
 
         #region Gameplay leaderboard
 
+        protected virtual bool ShowLeaderboard => false;
+
         protected readonly Bindable<bool> LeaderboardExpandedState = new BindableBool();
 
         private void loadLeaderboard()
         {
+            if (!ShowLeaderboard)
+                return;
+
             HUDOverlay.HoldingForHUD.BindValueChanged(_ => updateLeaderboardExpandedState());
             LocalUserPlaying.BindValueChanged(_ => updateLeaderboardExpandedState(), true);
 
-            var gameplayLeaderboard = CreateGameplayLeaderboard();
-
-            if (gameplayLeaderboard != null)
+            var gameplayLeaderboard = new DrawableGameplayLeaderboard();
+            LoadComponentAsync(gameplayLeaderboard, leaderboard =>
             {
-                LoadComponentAsync(gameplayLeaderboard, leaderboard =>
-                {
-                    if (!LoadedBeatmapSuccessfully)
-                        return;
+                if (!LoadedBeatmapSuccessfully)
+                    return;
 
-                    leaderboard.Expanded.BindTo(LeaderboardExpandedState);
+                leaderboard.Expanded.BindTo(LeaderboardExpandedState);
 
-                    AddLeaderboardToHUD(leaderboard);
-                });
-            }
+                HUDOverlay.LeaderboardFlow.Add(leaderboard);
+            });
         }
 
-        [CanBeNull]
-        protected virtual GameplayLeaderboard CreateGameplayLeaderboard() => null;
-
-        protected virtual void AddLeaderboardToHUD(GameplayLeaderboard leaderboard) => HUDOverlay.LeaderboardFlow.Add(leaderboard);
-
         private void updateLeaderboardExpandedState() =>
             LeaderboardExpandedState.Value = !LocalUserPlaying.Value || HUDOverlay.HoldingForHUD.Value;
 
diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index bd4b62fd59..d22717abd4 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -8,6 +8,7 @@ using ManagedBass.Fx;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Bindables;
+using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -302,8 +303,7 @@ namespace osu.Game.Screens.Play
 
             Debug.Assert(CurrentPlayer != null);
 
-            highPerformanceSession?.Dispose();
-            highPerformanceSession = null;
+            endHighPerformance();
 
             // prepare for a retry.
             CurrentPlayer = null;
@@ -349,8 +349,7 @@ namespace osu.Game.Screens.Play
             BackgroundBrightnessReduction = false;
             Beatmap.Value.Track.RemoveAdjustment(AdjustableProperty.Volume, volumeAdjustment);
 
-            highPerformanceSession?.Dispose();
-            highPerformanceSession = null;
+            endHighPerformance();
 
             return base.OnExiting(e);
         }
@@ -565,6 +564,8 @@ namespace osu.Game.Screens.Play
 
         private void pushWhenLoaded()
         {
+            Debug.Assert(ThreadSafety.IsUpdateThread);
+
             if (!this.IsCurrentScreen()) return;
 
             if (!readyForPush)
@@ -587,7 +588,9 @@ namespace osu.Game.Screens.Play
             scheduledPushPlayer = Scheduler.AddDelayed(() =>
                 {
                     // ensure that once we have reached this "point of no return", readyForPush will be false for all future checks (until a new player instance is prepared).
-                    var consumedPlayer = consumePlayer();
+                    Player consumedPlayer = consumePlayer();
+
+                    consumedPlayer.OnShowingResults += endHighPerformance;
 
                     ContentOut();
 
@@ -623,6 +626,14 @@ namespace osu.Game.Screens.Play
             scheduledPushPlayer = null;
         }
 
+        private void endHighPerformance()
+        {
+            Debug.Assert(ThreadSafety.IsUpdateThread);
+
+            highPerformanceSession?.Dispose();
+            highPerformanceSession = null;
+        }
+
         #region Disposal
 
         protected override void Dispose(bool isDisposing)
@@ -635,8 +646,8 @@ namespace osu.Game.Screens.Play
                 DisposalTask = LoadTask?.ContinueWith(_ => CurrentPlayer?.Dispose());
             }
 
+            // This is only a failsafe; should be disposed more immediately by `endHighPerformance` call.
             highPerformanceSession?.Dispose();
-            highPerformanceSession = null;
         }
 
         #endregion
diff --git a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
index cef5884d39..b0b4f6cc5d 100644
--- a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
+++ b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
@@ -60,14 +60,11 @@ namespace osu.Game.Screens.Play.PlayerSettings
         [Resolved]
         private Player? player { get; set; }
 
-        [Resolved]
-        private IGameplayClock? gameplayClock { get; set; }
-
-        private double lastPlayAverage;
+        private double lastPlayMedian;
         private double lastPlayBeatmapOffset;
         private HitEventTimingDistributionGraph? lastPlayGraph;
 
-        private SettingsButton? useAverageButton;
+        private SettingsButton? calibrateFromLastPlayButton;
 
         private IDisposable? beatmapOffsetSubscription;
 
@@ -196,7 +193,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
 
             var hitEvents = score.NewValue.HitEvents;
 
-            if (!(hitEvents.CalculateAverageHitError() is double average))
+            if (!(hitEvents.CalculateMedianHitError() is double median))
                 return;
 
             referenceScoreContainer.Children = new Drawable[]
@@ -210,7 +207,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
             // affecting unstable rate here is used as a substitute of determining if a hit event represents a *timed* hit event,
             // i.e. an user input that the user had to *time to the track*,
             // i.e. one that it *makes sense to use* when doing anything with timing and offsets.
-            if (hitEvents.Count(HitEventExtensions.AffectsUnstableRate) < 10)
+            if (hitEvents.Count(HitEventExtensions.AffectsUnstableRate) < 50)
             {
                 referenceScoreContainer.AddRange(new Drawable[]
                 {
@@ -226,7 +223,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
                 return;
             }
 
-            lastPlayAverage = average;
+            lastPlayMedian = median;
             lastPlayBeatmapOffset = Current.Value;
 
             LinkFlowContainer globalOffsetText;
@@ -239,7 +236,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
                     Height = 50,
                 },
                 new AverageHitError(hitEvents),
-                useAverageButton = new SettingsButton
+                calibrateFromLastPlayButton = new SettingsButton
                 {
                     Text = BeatmapOffsetControlStrings.CalibrateUsingLastPlay,
                     Action = () =>
@@ -247,7 +244,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
                         if (Current.Disabled)
                             return;
 
-                        Current.Value = lastPlayBeatmapOffset - lastPlayAverage;
+                        Current.Value = lastPlayBeatmapOffset - lastPlayMedian;
                         lastAppliedScore.Value = ReferenceScore.Value;
                     },
                 },
@@ -281,33 +278,13 @@ namespace osu.Game.Screens.Play.PlayerSettings
 
             bool allow = allowOffsetAdjust;
 
-            if (useAverageButton != null)
-                useAverageButton.Enabled.Value = allow && !Precision.AlmostEquals(lastPlayAverage, adjustmentSinceLastPlay, Current.Precision / 2);
+            if (calibrateFromLastPlayButton != null)
+                calibrateFromLastPlayButton.Enabled.Value = allow && !Precision.AlmostEquals(lastPlayMedian, adjustmentSinceLastPlay, Current.Precision / 2);
 
             Current.Disabled = !allow;
         }
 
-        private bool allowOffsetAdjust
-        {
-            get
-            {
-                // General limitations to ensure players don't do anything too weird.
-                // These match stable for now.
-                if (player is SubmittingPlayer)
-                {
-                    Debug.Assert(gameplayClock != null);
-
-                    // TODO: the blocking conditions should probably display a message.
-                    if (!player.IsBreakTime.Value && gameplayClock.CurrentTime - gameplayClock.GameplayStartTime > 10000)
-                        return false;
-
-                    if (gameplayClock.IsPaused.Value)
-                        return false;
-                }
-
-                return true;
-            }
-        }
+        private bool allowOffsetAdjust => player?.AllowCriticalSettingsAdjustment != false;
 
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
diff --git a/osu.Game/Screens/Play/ReplayPlayer.cs b/osu.Game/Screens/Play/ReplayPlayer.cs
index ba572f6014..c997a67dea 100644
--- a/osu.Game/Screens/Play/ReplayPlayer.cs
+++ b/osu.Game/Screens/Play/ReplayPlayer.cs
@@ -8,7 +8,6 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
@@ -16,9 +15,9 @@ using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Play.PlayerSettings;
 using osu.Game.Screens.Ranking;
+using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Users;
 
 namespace osu.Game.Screens.Play
@@ -34,6 +33,9 @@ namespace osu.Game.Screens.Play
 
         private PlaybackSettings playbackSettings;
 
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private readonly SoloGameplayLeaderboardProvider leaderboardProvider = new SoloGameplayLeaderboardProvider();
+
         protected override UserActivity InitialActivity => new UserActivity.WatchingReplay(Score.ScoreInfo);
 
         private bool isAutoplayPlayback => GameplayState.Mods.OfType<ModAutoplay>().Any();
@@ -47,6 +49,8 @@ namespace osu.Game.Screens.Play
             return base.CheckModsAllowFailure();
         }
 
+        protected override bool ShowLeaderboard => true;
+
         public ReplayPlayer(Score score, PlayerConfiguration configuration = null)
             : this((_, _) => score, configuration)
         {
@@ -75,6 +79,8 @@ namespace osu.Game.Screens.Play
             if (!LoadedBeatmapSuccessfully)
                 return;
 
+            AddInternal(leaderboardProvider);
+
             playbackSettings = new PlaybackSettings
             {
                 Depth = float.MaxValue,
@@ -97,15 +103,6 @@ namespace osu.Game.Screens.Play
         // Don't re-import replay scores as they're already present in the database.
         protected override Task ImportScore(Score score) => Task.CompletedTask;
 
-        public readonly BindableList<ScoreInfo> LeaderboardScores = new BindableList<ScoreInfo>();
-
-        protected override GameplayLeaderboard CreateGameplayLeaderboard() =>
-            new SoloGameplayLeaderboard(Score.ScoreInfo.User)
-            {
-                AlwaysVisible = { Value = true },
-                Scores = { BindTarget = LeaderboardScores }
-            };
-
         protected override ResultsScreen CreateResults(ScoreInfo score) => new SoloResultsScreen(score)
         {
             // Only show the relevant button otherwise things look silly.
diff --git a/osu.Game/Screens/Play/SoloPlayer.cs b/osu.Game/Screens/Play/SoloPlayer.cs
index f4cf2da364..e4e42e2f08 100644
--- a/osu.Game/Screens/Play/SoloPlayer.cs
+++ b/osu.Game/Screens/Play/SoloPlayer.cs
@@ -5,28 +5,34 @@
 
 using System;
 using System.Diagnostics;
-using System.Threading.Tasks;
-using osu.Framework.Bindables;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
 using osu.Game.Extensions;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Online.Solo;
 using osu.Game.Scoring;
-using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Select.Leaderboards;
 
 namespace osu.Game.Screens.Play
 {
     public partial class SoloPlayer : SubmittingPlayer
     {
-        public SoloPlayer()
-            : this(null)
+        protected override bool ShowLeaderboard => true;
+
+        [Cached(typeof(IGameplayLeaderboardProvider))]
+        private readonly SoloGameplayLeaderboardProvider leaderboardProvider = new SoloGameplayLeaderboardProvider();
+
+        public SoloPlayer([CanBeNull] PlayerConfiguration configuration = null)
+            : base(configuration)
         {
         }
 
-        protected SoloPlayer(PlayerConfiguration configuration = null)
-            : base(configuration)
+        [BackgroundDependencyLoader]
+        private void load()
         {
+            AddInternal(leaderboardProvider);
         }
 
         protected override APIRequest<APIScoreToken> CreateTokenRequest()
@@ -43,32 +49,13 @@ namespace osu.Game.Screens.Play
             return new CreateSoloScoreRequest(Beatmap.Value.BeatmapInfo, rulesetId, Game.VersionHash);
         }
 
-        public readonly BindableList<ScoreInfo> LeaderboardScores = new BindableList<ScoreInfo>();
-
-        protected override GameplayLeaderboard CreateGameplayLeaderboard() =>
-            new SoloGameplayLeaderboard(Score.ScoreInfo.User)
-            {
-                AlwaysVisible = { Value = false },
-                Scores = { BindTarget = LeaderboardScores }
-            };
-
         protected override bool ShouldExitOnTokenRetrievalFailure(Exception exception) => false;
 
-        protected override Task ImportScore(Score score)
-        {
-            // Before importing a score, stop binding the leaderboard with its score source.
-            // This avoids a case where the imported score may cause a leaderboard refresh
-            // (if the leaderboard's source is local).
-            LeaderboardScores.UnbindBindings();
-
-            return base.ImportScore(score);
-        }
-
         protected override APIRequest<MultiplayerScore> CreateSubmissionRequest(Score score, long token)
         {
-            IBeatmapInfo beatmap = score.ScoreInfo.BeatmapInfo;
+            IBeatmapInfo beatmap = score.ScoreInfo.BeatmapInfo!;
 
-            Debug.Assert(beatmap!.OnlineID > 0);
+            Debug.Assert(beatmap.OnlineID > 0);
 
             return new SubmitSoloScoreRequest(score.ScoreInfo, token, beatmap.OnlineID);
         }
diff --git a/osu.Game/Screens/Play/SubmittingPlayer.cs b/osu.Game/Screens/Play/SubmittingPlayer.cs
index dc3e5f08ac..7becb2b33e 100644
--- a/osu.Game/Screens/Play/SubmittingPlayer.cs
+++ b/osu.Game/Screens/Play/SubmittingPlayer.cs
@@ -186,6 +186,24 @@ namespace osu.Game.Screens.Play
         /// <returns>Whether gameplay should be immediately exited as a result. Returning false allows the gameplay session to continue. Defaults to true.</returns>
         protected virtual bool ShouldExitOnTokenRetrievalFailure(Exception exception) => true;
 
+        public override bool AllowCriticalSettingsAdjustment
+        {
+            get
+            {
+                // General limitations to ensure players don't do anything too weird.
+                // These match stable for now.
+
+                // TODO: the blocking conditions should probably display a message.
+                if (!IsBreakTime.Value && GameplayClockContainer.CurrentTime - GameplayClockContainer.GameplayStartTime > 10000)
+                    return false;
+
+                if (GameplayClockContainer.IsPaused.Value)
+                    return false;
+
+                return base.AllowCriticalSettingsAdjustment;
+            }
+        }
+
         protected override async Task PrepareScoreForResultsAsync(Score score)
         {
             await base.PrepareScoreForResultsAsync(score).ConfigureAwait(false);
diff --git a/osu.Game/Screens/Ranking/ResultsScreen.cs b/osu.Game/Screens/Ranking/ResultsScreen.cs
index 6da731588f..8d5e6c05c3 100644
--- a/osu.Game/Screens/Ranking/ResultsScreen.cs
+++ b/osu.Game/Screens/Ranking/ResultsScreen.cs
@@ -86,6 +86,9 @@ namespace osu.Game.Screens.Ranking
 
         private Sample? popInSample;
 
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
+
         protected ResultsScreen(ScoreInfo? score)
         {
             Score = score;
diff --git a/osu.Game/Screens/Ranking/Statistics/StatisticItemContainer.cs b/osu.Game/Screens/Ranking/Statistics/StatisticItemContainer.cs
index 6e18ae1fe4..8caf8d66b5 100644
--- a/osu.Game/Screens/Ranking/Statistics/StatisticItemContainer.cs
+++ b/osu.Game/Screens/Ranking/Statistics/StatisticItemContainer.cs
@@ -1,15 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Localisation;
 using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
-using osuTK;
 
 namespace osu.Game.Screens.Ranking.Statistics
 {
@@ -53,7 +50,9 @@ namespace osu.Game.Screens.Ranking.Statistics
                         Padding = new MarginPadding(5),
                         Children = new[]
                         {
-                            createHeader(item),
+                            LocalisableString.IsNullOrEmpty(item.Name)
+                                ? Empty()
+                                : new StatisticItemHeader { Text = item.Name },
                             new Container
                             {
                                 RelativeSizeAxes = Axes.X,
@@ -66,37 +65,5 @@ namespace osu.Game.Screens.Ranking.Statistics
                 }
             };
         }
-
-        private static Drawable createHeader(StatisticItem item)
-        {
-            if (LocalisableString.IsNullOrEmpty(item.Name))
-                return Empty();
-
-            return new FillFlowContainer
-            {
-                RelativeSizeAxes = Axes.X,
-                Height = 20,
-                Direction = FillDirection.Horizontal,
-                Spacing = new Vector2(5, 0),
-                Children = new Drawable[]
-                {
-                    new Circle
-                    {
-                        Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
-                        Height = 9,
-                        Width = 4,
-                        Colour = Color4Extensions.FromHex("#00FFAA")
-                    },
-                    new OsuSpriteText
-                    {
-                        Anchor = Anchor.CentreLeft,
-                        Origin = Anchor.CentreLeft,
-                        Text = item.Name,
-                        Font = OsuFont.GetFont(size: StatisticItem.FONT_SIZE, weight: FontWeight.SemiBold),
-                    }
-                }
-            };
-        }
     }
 }
diff --git a/osu.Game/Screens/Ranking/Statistics/StatisticItemHeader.cs b/osu.Game/Screens/Ranking/Statistics/StatisticItemHeader.cs
new file mode 100644
index 0000000000..6b496e10dd
--- /dev/null
+++ b/osu.Game/Screens/Ranking/Statistics/StatisticItemHeader.cs
@@ -0,0 +1,68 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+
+namespace osu.Game.Screens.Ranking.Statistics
+{
+    public partial class StatisticItemHeader : CompositeDrawable, IHasText
+    {
+        public LocalisableString Text
+        {
+            get => text;
+            set
+            {
+                if (text == value) return;
+
+                text = value;
+                if (IsLoaded)
+                    spriteText.Text = value;
+            }
+        }
+
+        private LocalisableString text;
+        private OsuSpriteText spriteText = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            InternalChild = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                Height = 20,
+                Direction = FillDirection.Horizontal,
+                Spacing = new Vector2(5, 0),
+                Children = new Drawable[]
+                {
+                    new Circle
+                    {
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                        Height = 9,
+                        Width = 4,
+                        Colour = Color4Extensions.FromHex("#00FFAA")
+                    },
+                    spriteText = new OsuSpriteText
+                    {
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                        Text = text,
+                        Font = OsuFont.GetFont(size: StatisticItem.FONT_SIZE, weight: FontWeight.SemiBold),
+                    }
+                }
+            };
+        }
+    }
+}
diff --git a/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs b/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs
index ad868e58f0..c33514e343 100644
--- a/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs
+++ b/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs
@@ -304,7 +304,10 @@ namespace osu.Game.Screens.Ranking.Statistics
             this.FadeOut(250, Easing.OutQuint);
 
             if (wasOpened)
+            {
                 popOutSample?.Play();
+                this.HidePopover(); // targeted at the user tag control
+            }
         }
 
         protected override void Dispose(bool isDisposing)
diff --git a/osu.Game/Screens/Ranking/UserTag.cs b/osu.Game/Screens/Ranking/UserTag.cs
index d44e531330..9a93df91b5 100644
--- a/osu.Game/Screens/Ranking/UserTag.cs
+++ b/osu.Game/Screens/Ranking/UserTag.cs
@@ -9,17 +9,24 @@ namespace osu.Game.Screens.Ranking
     public record UserTag
     {
         public long Id { get; }
-        public string Name { get; }
+        public string FullName { get; }
+        public string? GroupName { get; }
+        public string DisplayName { get; }
         public string Description { get; }
 
         public BindableInt VoteCount { get; } = new BindableInt();
         public BindableBool Voted { get; } = new BindableBool();
+        public BindableBool Updating { get; } = new BindableBool();
 
         public UserTag(APITag tag)
         {
             Id = tag.Id;
-            Name = tag.Name;
+            FullName = tag.Name;
             Description = tag.Description;
+
+            string[] splitName = FullName.Split('/');
+            GroupName = splitName.Length > 1 ? splitName[0] : null;
+            DisplayName = splitName[^1];
         }
     }
 }
diff --git a/osu.Game/Screens/Ranking/UserTagControl.cs b/osu.Game/Screens/Ranking/UserTagControl.cs
index ae4a918ae5..da9dfd66d3 100644
--- a/osu.Game/Screens/Ranking/UserTagControl.cs
+++ b/osu.Game/Screens/Ranking/UserTagControl.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Linq;
+using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Caching;
@@ -19,6 +20,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
 using osu.Game.Extensions;
@@ -32,8 +34,8 @@ using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
+using osu.Game.Screens.Ranking.Statistics;
 using osuTK;
-using osuTK.Input;
 
 namespace osu.Game.Screens.Ranking
 {
@@ -46,14 +48,16 @@ namespace osu.Game.Screens.Ranking
         private readonly Cached layout = new Cached();
 
         private FillFlowContainer<DrawableUserTag> tagFlow = null!;
-        private LoadingLayer loadingLayer = null!;
 
         private BindableList<UserTag> displayedTags { get; } = new BindableList<UserTag>();
-        private BindableList<UserTag> extraTags { get; } = new BindableList<UserTag>();
 
-        private Bindable<APITag[]?> allTags = null!;
+        private Bindable<APITag[]?> apiTags = null!;
+        private BindableDictionary<long, UserTag> relevantTagsById { get; } = new BindableDictionary<long, UserTag>();
+
         private readonly Bindable<APIBeatmap?> apiBeatmap = new Bindable<APIBeatmap?>();
 
+        private AddNewTagUserTag addNewTagUserTag = null!;
+
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
@@ -66,47 +70,57 @@ namespace osu.Game.Screens.Ranking
         private void load(SessionStatics sessionStatics)
         {
             AutoSizeAxes = Axes.Y;
+
             InternalChildren = new Drawable[]
             {
-                new FillFlowContainer
+                new GridContainer
                 {
-                    Direction = FillDirection.Vertical,
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
-                    Spacing = new Vector2(8),
-                    Children = new Drawable[]
+                    Padding = new MarginPadding(10),
+                    ColumnDimensions =
+                    [
+                        new Dimension(),
+                        new Dimension(GridSizeMode.AutoSize)
+                    ],
+                    RowDimensions = [new Dimension(GridSizeMode.AutoSize, minSize: 40)],
+                    Content = new[]
                     {
-                        tagFlow = new FillFlowContainer<DrawableUserTag>
+                        new Drawable[]
                         {
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                            Direction = FillDirection.Full,
-                            LayoutDuration = 300,
-                            LayoutEasing = Easing.OutQuint,
-                            Spacing = new Vector2(4),
-                        },
-                        new AddTagsButton
-                        {
-                            Anchor = Anchor.TopCentre,
-                            Origin = Anchor.TopCentre,
-                            OnTagSelected = onExtraTagSelected,
-                            AvailableTags = { BindTarget = extraTags },
-                        },
-                    },
-                },
-                loadingLayer = new LoadingLayer
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    State = { Value = Visibility.Visible }
+                            new FillFlowContainer
+                            {
+                                Direction = FillDirection.Vertical,
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
+                                Spacing = new Vector2(8),
+                                Children = new Drawable[]
+                                {
+                                    tagFlow = new FillFlowContainer<DrawableUserTag>
+                                    {
+                                        RelativeSizeAxes = Axes.X,
+                                        AutoSizeAxes = Axes.Y,
+                                        Direction = FillDirection.Full,
+                                        Spacing = new Vector2(4),
+                                        Child = addNewTagUserTag = new AddNewTagUserTag
+                                        {
+                                            AvailableTags = { BindTarget = relevantTagsById },
+                                            OnTagSelected = toggleVote,
+                                        },
+                                    },
+                                },
+                            },
+                        }
+                    }
                 },
             };
 
-            allTags = sessionStatics.GetBindable<APITag[]?>(Static.AllBeatmapTags);
+            apiTags = sessionStatics.GetBindable<APITag[]?>(Static.AllBeatmapTags);
 
-            if (allTags.Value == null)
+            if (apiTags.Value == null)
             {
                 var listTagsRequest = new ListTagsRequest();
-                listTagsRequest.Success += tags => allTags.Value = tags.Tags.ToArray();
+                listTagsRequest.Success += tags => apiTags.Value = tags.Tags.ToArray();
                 api.Queue(listTagsRequest);
             }
 
@@ -115,28 +129,11 @@ namespace osu.Game.Screens.Ranking
             api.Queue(getBeatmapSetRequest);
         }
 
-        private void onExtraTagSelected(UserTag tag)
-        {
-            loadingLayer.Show();
-            extraTags.Remove(tag);
-
-            var req = new AddBeatmapTagRequest(beatmapInfo.OnlineID, tag.Id);
-            req.Success += () =>
-            {
-                tag.Voted.Value = true;
-                tag.VoteCount.Value += 1;
-                displayedTags.Add(tag);
-                loadingLayer.Hide();
-            };
-            req.Failure += _ => extraTags.Add(tag);
-            api.Queue(req);
-        }
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            allTags.BindValueChanged(_ => updateTags());
+            apiTags.BindValueChanged(_ => updateTags());
             apiBeatmap.BindValueChanged(_ => updateTags());
             updateTags();
 
@@ -145,27 +142,32 @@ namespace osu.Game.Screens.Ranking
 
         private void updateTags()
         {
-            if (allTags.Value == null || apiBeatmap.Value?.TopTags == null)
+            if (apiTags.Value == null || apiBeatmap.Value == null)
                 return;
 
-            var allTagsById = allTags.Value.ToDictionary(t => t.Id);
-            var ownTagIds = apiBeatmap.Value.OwnTagIds?.ToHashSet() ?? new HashSet<long>();
+            relevantTagsById.Clear();
+            relevantTagsById.AddRange(apiTags.Value
+                                             .Where(t => t.RulesetId == null || t.RulesetId == beatmapInfo.Ruleset.OnlineID)
+                                             .Select(t => new KeyValuePair<long, UserTag>(t.Id, new UserTag(t))));
 
-            foreach (var topTag in apiBeatmap.Value.TopTags)
+            foreach (var topTag in apiBeatmap.Value.TopTags ?? [])
             {
-                if (allTagsById.Remove(topTag.TagId, out var tag))
+                if (relevantTagsById.TryGetValue(topTag.TagId, out var tag))
                 {
-                    displayedTags.Add(new UserTag(tag)
-                    {
-                        VoteCount = { Value = topTag.VoteCount },
-                        Voted = { Value = ownTagIds.Contains(tag.Id) }
-                    });
+                    tag.VoteCount.Value = topTag.VoteCount;
+                    tag.Updating.Value = false;
+                    displayedTags.Add(tag);
                 }
             }
 
-            extraTags.AddRange(allTagsById.Select(t => new UserTag(t.Value)));
-
-            loadingLayer.Hide();
+            foreach (long ownTagId in apiBeatmap.Value.OwnTagIds ?? [])
+            {
+                if (relevantTagsById.TryGetValue(ownTagId, out var tag))
+                {
+                    tag.Voted.Value = true;
+                    tag.Updating.Value = false;
+                }
+            }
         }
 
         private void displayTags(object? sender, NotifyCollectionChangedEventArgs e)
@@ -179,7 +181,7 @@ namespace osu.Game.Screens.Ranking
                     for (int i = 0; i < e.NewItems!.Count; i++)
                     {
                         var tag = (UserTag)e.NewItems[i]!;
-                        var drawableTag = new DrawableUserTag(tag);
+                        var drawableTag = new DrawableUserTag(tag) { OnSelected = toggleVote };
                         tagFlow.Insert(tagFlow.Count, drawableTag);
                         tag.VoteCount.BindValueChanged(voteCountChanged, true);
                         layout.Invalidate();
@@ -194,7 +196,7 @@ namespace osu.Game.Screens.Ranking
                     {
                         var tag = (UserTag)e.OldItems[i]!;
                         tag.VoteCount.ValueChanged -= voteCountChanged;
-                        tagFlow.Remove(oldItems[e.OldStartingIndex + i], true);
+                        tagFlow.Remove(oldItems[1 + e.OldStartingIndex + i], true);
                     }
 
                     break;
@@ -203,20 +205,58 @@ namespace osu.Game.Screens.Ranking
                 case NotifyCollectionChangedAction.Reset:
                 {
                     tagFlow.Clear();
+                    tagFlow.Add(addNewTagUserTag);
                     break;
                 }
             }
         }
 
+        private void toggleVote(UserTag tag)
+        {
+            if (tag.Updating.Value)
+                return;
+
+            tag.Updating.Value = true;
+
+            APIRequest request;
+
+            switch (tag.Voted.Value)
+            {
+                case true:
+                    var removeReq = new RemoveBeatmapTagRequest(beatmapInfo.OnlineID, tag.Id);
+                    removeReq.Success += () =>
+                    {
+                        tag.VoteCount.Value -= 1;
+                        tag.Voted.Value = false;
+                    };
+                    request = removeReq;
+                    break;
+
+                case false:
+                    var addReq = new AddBeatmapTagRequest(beatmapInfo.OnlineID, tag.Id);
+                    addReq.Success += () =>
+                    {
+                        tag.VoteCount.Value += 1;
+                        tag.Voted.Value = true;
+                        if (!displayedTags.Contains(tag))
+                            displayedTags.Add(tag);
+                    };
+                    request = addReq;
+                    break;
+            }
+
+            request.Success += () => tag.Updating.Value = false;
+            request.Failure += _ => tag.Updating.Value = false;
+
+            api.Queue(request);
+        }
+
         private void voteCountChanged(ValueChangedEvent<int> _)
         {
             var tagsWithNoVotes = displayedTags.Where(t => t.VoteCount.Value == 0).ToArray();
 
             foreach (var tag in tagsWithNoVotes)
-            {
                 displayedTags.Remove(tag);
-                extraTags.Add(tag);
-            }
 
             layout.Invalidate();
         }
@@ -233,62 +273,71 @@ namespace osu.Game.Screens.Ranking
                                  .Select((tag, index) => new KeyValuePair<UserTag, int>(tag, index)));
 
                 foreach (var drawableTag in tagFlow)
-                    tagFlow.SetLayoutPosition(drawableTag, sortedTags[drawableTag.UserTag]);
+                {
+                    if (drawableTag == addNewTagUserTag)
+                        tagFlow.SetLayoutPosition(drawableTag, float.MinValue);
+                    else
+                        tagFlow.SetLayoutPosition(drawableTag, sortedTags[drawableTag.UserTag]);
+                }
 
                 layout.Validate();
             }
         }
 
+        protected override bool OnClick(ClickEvent e) => true;
+
         private partial class DrawableUserTag : OsuAnimatedButton
         {
             public readonly UserTag UserTag;
 
+            public Action<UserTag>? OnSelected { get; set; }
+
             private readonly Bindable<int> voteCount = new Bindable<int>();
             private readonly BindableBool voted = new BindableBool();
             private readonly Bindable<bool> confirmed = new BindableBool();
+            private readonly BindableBool updating = new BindableBool();
 
-            private Box mainBackground = null!;
+            protected Box MainBackground { get; private set; } = null!;
             private Box voteBackground = null!;
-            private OsuSpriteText tagNameText = null!;
-            private OsuSpriteText voteCountText = null!;
-            private LoadingSpinner spinner = null!;
+
+            protected OsuSpriteText TagCategoryText { get; private set; } = null!;
+            protected OsuSpriteText TagNameText { get; private set; } = null!;
+            protected VoteCountText VoteCountText { get; private set; } = null!;
+
+            private readonly bool showVoteCount;
+
+            private LoadingLayer loadingLayer = null!;
 
             [Resolved]
             private OsuColour colours { get; set; } = null!;
 
-            [Resolved]
-            private Bindable<WorkingBeatmap> beatmap { get; set; } = null!;
-
-            [Resolved]
-            private IAPIProvider api { get; set; } = null!;
-
-            private APIRequest? requestInFlight;
-
-            public DrawableUserTag(UserTag userTag)
+            public DrawableUserTag(UserTag userTag, bool showVoteCount = true)
             {
                 UserTag = userTag;
+                this.showVoteCount = showVoteCount;
                 voteCount.BindTo(userTag.VoteCount);
+                updating.BindTo(userTag.Updating);
                 voted.BindTo(userTag.Voted);
 
                 AutoSizeAxes = Axes.Both;
+
+                ScaleOnMouseDown = 0.95f;
             }
 
             [BackgroundDependencyLoader]
             private void load()
             {
-                Anchor = Anchor.Centre;
-                Origin = Anchor.Centre;
-                CornerRadius = 8;
+                CornerRadius = 5;
                 Masking = true;
                 EdgeEffect = new EdgeEffectParameters
                 {
                     Colour = colours.Lime1,
-                    Radius = 5,
+                    Radius = 6,
                     Type = EdgeEffectType.Glow,
                 };
                 Content.AddRange(new Drawable[]
                 {
-                    mainBackground = new Box
+                    MainBackground = new Box
                     {
                         RelativeSizeAxes = Axes.Both,
                         Depth = float.MaxValue,
@@ -297,42 +346,62 @@ namespace osu.Game.Screens.Ranking
                     {
                         AutoSizeAxes = Axes.Both,
                         Direction = FillDirection.Horizontal,
-                        Padding = new MarginPadding { Left = 6, Right = 3, Vertical = 3, },
-                        Spacing = new Vector2(5),
-                        Children = new Drawable[]
+                        Children = new[]
                         {
-                            tagNameText = new OsuSpriteText
+                            TagCategoryText = new OsuSpriteText
                             {
-                                Text = UserTag.Name,
+                                Alpha = UserTag.GroupName != null ? 0.6f : 0,
+                                Text = UserTag.GroupName ?? default(LocalisableString),
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
+                                Margin = new MarginPadding { Horizontal = 6 }
                             },
                             new Container
                             {
                                 AutoSizeAxes = Axes.Both,
-                                CornerRadius = 5,
-                                Masking = true,
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
                                 Children = new Drawable[]
                                 {
-                                    voteBackground = new Box
+                                    new Box
                                     {
                                         RelativeSizeAxes = Axes.Both,
+                                        Alpha = 0.1f,
+                                        Blending = BlendingParameters.Additive,
                                     },
-                                    voteCountText = new OsuSpriteText
+                                    TagNameText = new OsuSpriteText
                                     {
+                                        Text = UserTag.DisplayName,
+                                        Font = OsuFont.Default.With(weight: FontWeight.SemiBold),
+                                        Anchor = Anchor.CentreLeft,
+                                        Origin = Anchor.CentreLeft,
                                         Margin = new MarginPadding { Horizontal = 6, Vertical = 3, },
                                     },
-                                    spinner = new LoadingSpinner(withBox: true)
+                                }
+                            },
+                            showVoteCount
+                                ? new Container
+                                {
+                                    RelativeSizeAxes = Axes.Y,
+                                    AutoSizeAxes = Axes.X,
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    Children = new Drawable[]
                                     {
-                                        Alpha = 0,
-                                        Size = new Vector2(18),
+                                        voteBackground = new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                        },
+                                        VoteCountText = new VoteCountText(voteCount)
+                                        {
+                                            Margin = new MarginPadding { Horizontal = 6 },
+                                        },
                                     }
                                 }
-                            }
+                                : Empty(),
                         }
-                    }
+                    },
+                    loadingLayer = new LoadingLayer(dimBackground: true),
                 });
 
                 TooltipText = UserTag.Description;
@@ -344,100 +413,65 @@ namespace osu.Game.Screens.Ranking
 
                 const double transition_duration = 300;
 
-                voteCount.BindValueChanged(_ =>
+                updating.BindValueChanged(u => loadingLayer.State.Value = u.NewValue ? Visibility.Visible : Visibility.Hidden);
+
+                if (showVoteCount)
                 {
-                    voteCountText.Text = voteCount.Value.ToLocalisableString();
-                    confirmed.Value = voteCount.Value >= 10;
-                }, true);
-                voted.BindValueChanged(v =>
-                {
-                    if (v.NewValue)
+                    voteCount.BindValueChanged(_ =>
                     {
-                        voteBackground.FadeColour(colours.Lime3, transition_duration, Easing.OutQuint);
-                        voteCountText.FadeColour(Colour4.Black, transition_duration, Easing.OutQuint);
-                    }
-                    else
+                        confirmed.Value = voteCount.Value >= 10;
+                    }, true);
+                    voted.BindValueChanged(v =>
                     {
-                        voteBackground.FadeColour(colours.Gray2, transition_duration, Easing.OutQuint);
-                        voteCountText.FadeColour(Colour4.White, transition_duration, Easing.OutQuint);
-                    }
-                }, true);
-                confirmed.BindValueChanged(c =>
-                {
-                    if (c.NewValue)
+                        if (v.NewValue)
+                        {
+                            voteBackground.FadeColour(colours.Lime2, transition_duration, Easing.OutQuint);
+                            VoteCountText.FadeColour(Colour4.Black, transition_duration, Easing.OutQuint);
+                        }
+                        else
+                        {
+                            voteBackground.FadeColour(colours.Gray2, transition_duration, Easing.OutQuint);
+                            VoteCountText.FadeColour(Colour4.White, transition_duration, Easing.OutQuint);
+                        }
+                    }, true);
+
+                    confirmed.BindValueChanged(c =>
                     {
-                        mainBackground.FadeColour(colours.Lime1, transition_duration, Easing.OutQuint);
-                        tagNameText.FadeColour(Colour4.Black, transition_duration, Easing.OutQuint);
-                        FadeEdgeEffectTo(0.5f, transition_duration, Easing.OutQuint);
-                    }
-                    else
-                    {
-                        mainBackground.FadeColour(colours.Gray4, transition_duration, Easing.OutQuint);
-                        tagNameText.FadeColour(Colour4.White, transition_duration, Easing.OutQuint);
-                        FadeEdgeEffectTo(0f, transition_duration, Easing.OutQuint);
-                    }
-                }, true);
+                        if (c.NewValue)
+                        {
+                            MainBackground.FadeColour(colours.Lime2, transition_duration, Easing.OutQuint);
+                            TagCategoryText.FadeColour(Colour4.Black, transition_duration, Easing.OutQuint);
+                            TagNameText.FadeColour(Colour4.Black, transition_duration, Easing.OutQuint);
+                            FadeEdgeEffectTo(0.3f, transition_duration, Easing.OutQuint);
+                        }
+                        else
+                        {
+                            MainBackground.FadeColour(colours.Gray6, transition_duration, Easing.OutQuint);
+                            TagCategoryText.FadeColour(Colour4.White, transition_duration, Easing.OutQuint);
+                            TagNameText.FadeColour(Colour4.White, transition_duration, Easing.OutQuint);
+                            FadeEdgeEffectTo(0f, transition_duration, Easing.OutQuint);
+                        }
+                    }, true);
+                }
+
                 FinishTransforms(true);
 
-                Action = () =>
-                {
-                    if (requestInFlight != null)
-                        return;
-
-                    spinner.Show();
-
-                    APIRequest request;
-
-                    switch (voted.Value)
-                    {
-                        case true:
-                            var removeReq = new RemoveBeatmapTagRequest(beatmap.Value.BeatmapInfo.OnlineID, UserTag.Id);
-                            removeReq.Success += () =>
-                            {
-                                voteCount.Value -= 1;
-                                voted.Value = false;
-                            };
-                            request = removeReq;
-                            break;
-
-                        case false:
-                            var addReq = new AddBeatmapTagRequest(beatmap.Value.BeatmapInfo.OnlineID, UserTag.Id);
-                            addReq.Success += () =>
-                            {
-                                voteCount.Value += 1;
-                                voted.Value = true;
-                            };
-                            request = addReq;
-                            break;
-                    }
-
-                    request.Success += () =>
-                    {
-                        spinner.Hide();
-                        requestInFlight = null;
-                    };
-                    request.Failure += _ =>
-                    {
-                        spinner.Hide();
-                        requestInFlight = null;
-                    };
-                    api.Queue(requestInFlight = request);
-                };
+                Action = () => OnSelected?.Invoke(UserTag);
             }
         }
 
-        private partial class AddTagsButton : GrayButton, IHasPopover
+        private partial class AddNewTagUserTag : DrawableUserTag, IHasPopover
         {
-            public BindableList<UserTag> AvailableTags { get; } = new BindableList<UserTag>();
+            public BindableDictionary<long, UserTag> AvailableTags { get; } = new BindableDictionary<long, UserTag>();
 
             public Action<UserTag>? OnTagSelected { get; set; }
 
-            public AddTagsButton()
-                : base(FontAwesome.Solid.Plus)
-            {
-                Size = new Vector2(30);
+            [Resolved]
+            private OverlayColourProvider overlayColourProvider { get; set; } = null!;
 
-                Action = this.ShowPopover;
+            public AddNewTagUserTag()
+                : base(new UserTag(new APITag { Name = "+/add" }), false)
+            {
             }
 
             protected override void LoadComplete()
@@ -445,6 +479,12 @@ namespace osu.Game.Screens.Ranking
                 base.LoadComplete();
 
                 AvailableTags.BindCollectionChanged((_, _) => Enabled.Value = AvailableTags.Count > 0, true);
+                Action = this.ShowPopover;
+
+                MainBackground.FadeColour(overlayColourProvider.Background2);
+                TagCategoryText.FadeColour(overlayColourProvider.Colour0);
+                TagNameText.FadeColour(overlayColourProvider.Colour0);
+                FadeEdgeEffectTo(0);
             }
 
             public Popover GetPopover() => new AddTagsPopover
@@ -459,37 +499,50 @@ namespace osu.Game.Screens.Ranking
             private SearchTextBox searchBox = null!;
             private SearchContainer searchContainer = null!;
 
-            public BindableList<UserTag> AvailableTags { get; } = new BindableList<UserTag>();
+            public BindableDictionary<long, UserTag> AvailableTags { get; } = new BindableDictionary<long, UserTag>();
 
             public Action<UserTag>? OnSelected { get; set; }
 
+            private CancellationTokenSource? loadCancellationTokenSource;
+
             [BackgroundDependencyLoader]
             private void load()
             {
-                Child = new OsuScrollContainer
+                AllowableAnchors = new[]
                 {
-                    Width = 250,
-                    Height = 250,
-                    ScrollbarOverlapsContent = false,
-                    Children = new Drawable[]
+                    Anchor.TopCentre,
+                    Anchor.BottomCentre,
+                };
+
+                Children = new Drawable[]
+                {
+                    new Container
                     {
-                        searchBox = new SearchTextBox
+                        Size = new Vector2(400, 300),
+                        Children = new Drawable[]
                         {
-                            HoldFocus = true,
-                            RelativeSizeAxes = Axes.X,
-                        },
-                        searchContainer = new SearchContainer
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                            Direction = FillDirection.Vertical,
-                            Padding = new MarginPadding { Right = 5, Top = 50, },
-                            Spacing = new Vector2(10),
-                            ChildrenEnumerable = AvailableTags.Select(tag => new DrawableAddableTag(tag)
+                            searchBox = new SearchTextBox
                             {
-                                Action = () => select(tag)
-                            })
-                        }
+                                HoldFocus = true,
+                                RelativeSizeAxes = Axes.X,
+                                Depth = float.MinValue,
+                            },
+                            new OsuScrollContainer
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                Y = 40,
+                                Height = 260,
+                                ScrollbarOverlapsContent = false,
+                                Child = searchContainer = new SearchContainer
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Padding = new MarginPadding { Right = 5, Bottom = 10 },
+                                    Direction = FillDirection.Vertical,
+                                    Spacing = new Vector2(10),
+                                }
+                            }
+                        },
                     },
                 };
             }
@@ -498,21 +551,38 @@ namespace osu.Game.Screens.Ranking
             {
                 base.LoadComplete();
 
+                AvailableTags.BindCollectionChanged((_, _) =>
+                {
+                    loadCancellationTokenSource?.Cancel();
+                    loadCancellationTokenSource = new CancellationTokenSource();
+
+                    LoadComponentsAsync(createItems(AvailableTags.Values), loaded =>
+                    {
+                        searchContainer.Clear();
+                        searchContainer.AddRange(loaded);
+                    }, loadCancellationTokenSource.Token);
+                }, true);
                 searchBox.Current.BindValueChanged(_ => searchContainer.SearchTerm = searchBox.Current.Value, true);
             }
 
+            private IEnumerable<Drawable> createItems(IEnumerable<UserTag> tags)
+            {
+                var grouped = tags.GroupBy(tag => tag.GroupName).OrderBy(group => group.Key);
+
+                foreach (var group in grouped)
+                {
+                    var drawableGroup = new GroupFlow(group.Key);
+
+                    foreach (var tag in group.OrderBy(t => t.FullName))
+                        drawableGroup.Add(new DrawableAddableTag(tag) { Action = () => OnSelected?.Invoke(tag) });
+
+                    yield return drawableGroup;
+                }
+            }
+
             public override bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
             {
-                if (base.OnPressed(e))
-                    return true;
-
-                if (e.Repeat)
-                    return false;
-
-                if (State.Value == Visibility.Hidden)
-                    return false;
-
-                if (e.Action == GlobalAction.Select)
+                if (e.Action == GlobalAction.Select && !e.Repeat)
                 {
                     attemptSelect();
                     return true;
@@ -521,69 +591,113 @@ namespace osu.Game.Screens.Ranking
                 return false;
             }
 
-            protected override bool OnKeyDown(KeyDownEvent e)
-            {
-                if (e.Key == Key.Enter)
-                {
-                    attemptSelect();
-                    return true;
-                }
-
-                return base.OnKeyDown(e);
-            }
-
             private void attemptSelect()
             {
-                var visibleItems = searchContainer.OfType<DrawableAddableTag>().Where(d => d.IsPresent).ToArray();
+                var visibleItems = searchContainer.ChildrenOfType<DrawableAddableTag>().Where(d => d.IsPresent).ToArray();
 
                 if (visibleItems.Length == 1)
-                    select(visibleItems.Single().Tag);
+                    OnSelected?.Invoke(visibleItems.Single().Tag);
             }
 
-            private void select(UserTag tag)
+            private partial class GroupFlow : FillFlowContainer, IFilterable
             {
-                OnSelected?.Invoke(tag);
-                this.HidePopover();
+                public IEnumerable<LocalisableString> FilterTerms { get; }
+
+                public bool MatchingFilter
+                {
+                    set => Alpha = value ? 1 : 0;
+                }
+
+                public bool FilteringActive { set { } }
+
+                public GroupFlow(string? name)
+                {
+                    RelativeSizeAxes = Axes.X;
+                    AutoSizeAxes = Axes.Y;
+                    Direction = FillDirection.Vertical;
+                    Spacing = new Vector2(5);
+
+                    Add(new StatisticItemHeader { Text = name ?? "uncategorised" });
+
+                    FilterTerms = name == null ? [] : [name];
+                }
             }
 
             private partial class DrawableAddableTag : OsuAnimatedButton, IFilterable
             {
                 public readonly UserTag Tag;
 
+                private Box votedBackground = null!;
+                private SpriteIcon votedIcon = null!;
+
+                private readonly Bindable<bool> voted = new Bindable<bool>();
+                private readonly BindableBool updating = new BindableBool();
+
+                private LoadingLayer loadingLayer = null!;
+
                 public DrawableAddableTag(UserTag tag)
                 {
                     Tag = tag;
 
                     RelativeSizeAxes = Axes.X;
                     AutoSizeAxes = Axes.Y;
-                    Anchor = Origin = Anchor.Centre;
+
+                    ScaleOnMouseDown = 0.95f;
+
+                    voted.BindTo(Tag.Voted);
+                    updating.BindTo(Tag.Updating);
                 }
 
+                [Resolved]
+                private OsuColour colours { get; set; } = null!;
+
                 [BackgroundDependencyLoader]
-                private void load(OsuColour colours, OverlayColourProvider? colourProvider)
+                private void load()
                 {
                     Content.AddRange(new Drawable[]
                     {
                         new Box
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Colour = colourProvider?.Background3 ?? colours.GreySeaFoamDark,
+                            Colour = colours.Gray7,
                             Depth = float.MaxValue,
                         },
+                        new Container
+                        {
+                            RelativeSizeAxes = Axes.Y,
+                            Width = 30,
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreRight,
+                            Depth = float.MaxValue,
+                            Children = new Drawable[]
+                            {
+                                votedBackground = new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                },
+                                votedIcon = new SpriteIcon
+                                {
+                                    Size = new Vector2(16),
+                                    Icon = FontAwesome.Solid.ThumbsUp,
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                }
+                            }
+                        },
                         new FillFlowContainer
                         {
                             RelativeSizeAxes = Axes.X,
                             AutoSizeAxes = Axes.Y,
                             Direction = FillDirection.Vertical,
                             Spacing = new Vector2(2),
-                            Padding = new MarginPadding(5),
+                            Padding = new MarginPadding(5) { Right = 35 },
                             Children = new Drawable[]
                             {
-                                new OsuTextFlowContainer(t => t.Font = OsuFont.Default.With(weight: FontWeight.Bold))
+                                new OsuTextFlowContainer(t => t.Font = OsuFont.Default.With(weight: FontWeight.SemiBold))
                                 {
                                     RelativeSizeAxes = Axes.X,
                                     AutoSizeAxes = Axes.Y,
-                                    Text = Tag.Name,
+                                    Text = Tag.DisplayName,
                                 },
                                 new OsuTextFlowContainer(t => t.Font = OsuFont.Default.With(size: 14))
                                 {
@@ -592,14 +706,78 @@ namespace osu.Game.Screens.Ranking
                                     Text = Tag.Description,
                                 }
                             }
-                        }
+                        },
+                        loadingLayer = new LoadingLayer(dimBackground: true),
                     });
                 }
 
-                public IEnumerable<LocalisableString> FilterTerms => [Tag.Name, Tag.Description];
+                public IEnumerable<LocalisableString> FilterTerms => [Tag.FullName, Tag.Description];
 
                 public bool MatchingFilter { set => Alpha = value ? 1 : 0; }
                 public bool FilteringActive { set { } }
+
+                protected override void LoadComplete()
+                {
+                    base.LoadComplete();
+
+                    voted.BindValueChanged(_ =>
+                    {
+                        votedBackground.FadeColour(voted.Value ? colours.Lime2 : colours.Gray2, 250, Easing.OutQuint);
+                        votedIcon.FadeColour(voted.Value ? Colour4.Black : Colour4.White, 250, Easing.OutQuint);
+                    }, true);
+                    FinishTransforms(true);
+
+                    updating.BindValueChanged(u => loadingLayer.State.Value = u.NewValue ? Visibility.Visible : Visibility.Hidden);
+                }
+            }
+        }
+
+        private partial class VoteCountText : CompositeDrawable
+        {
+            private OsuSpriteText? text;
+
+            private readonly Bindable<int> voteCount;
+
+            public VoteCountText(Bindable<int> voteCount)
+            {
+                RelativeSizeAxes = Axes.Y;
+                AutoSizeAxes = Axes.X;
+
+                this.voteCount = voteCount.GetBoundCopy();
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                voteCount.BindValueChanged(count =>
+                {
+                    OsuSpriteText? previousText = text;
+
+                    AddInternal(text = new OsuSpriteText
+                    {
+                        Anchor = Anchor.CentreLeft,
+                        Origin = Anchor.CentreLeft,
+                        Font = OsuFont.GetFont(weight: FontWeight.SemiBold),
+                        Text = voteCount.Value.ToLocalisableString(),
+                    });
+
+                    if (previousText != null)
+                    {
+                        const double transition_duration = 500;
+
+                        bool isIncrease = count.NewValue > count.OldValue;
+
+                        text.MoveToY(isIncrease ? 20 : -20)
+                            .MoveToY(0, transition_duration, Easing.OutExpo);
+
+                        previousText.BypassAutoSizeAxes = Axes.Both;
+                        previousText.MoveToY(isIncrease ? -20 : 20, transition_duration, Easing.OutExpo).Expire();
+
+                        AutoSizeDuration = 300;
+                        AutoSizeEasing = Easing.OutQuint;
+                    }
+                }, true);
             }
         }
     }
diff --git a/osu.Game/Screens/Select/BeatmapDetails.cs b/osu.Game/Screens/Select/BeatmapDetails.cs
index 2bb60716ff..6a6a4cddf3 100644
--- a/osu.Game/Screens/Select/BeatmapDetails.cs
+++ b/osu.Game/Screens/Select/BeatmapDetails.cs
@@ -133,7 +133,7 @@ namespace osu.Game.Screens.Select
                                             {
                                                 description = new MetadataSectionDescription(query => songSelect?.Search(query)),
                                                 source = new MetadataSectionSource(query => songSelect?.Search(query)),
-                                                tags = new MetadataSectionTags(query => songSelect?.Search(query)),
+                                                tags = new MetadataSectionMapperTags(query => songSelect?.Search(query)),
                                             },
                                         },
                                     },
diff --git a/osu.Game/Screens/Select/BeatmapInfoWedge.cs b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
index fd1c944689..5a09780943 100644
--- a/osu.Game/Screens/Select/BeatmapInfoWedge.cs
+++ b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
@@ -263,7 +263,6 @@ namespace osu.Game.Screens.Select
                             },
                             new BeatmapSetOnlineStatusPill
                             {
-                                AutoSizeAxes = Axes.Both,
                                 Anchor = Anchor.TopRight,
                                 Origin = Anchor.TopRight,
                                 Shear = -wedged_container_shear,
diff --git a/osu.Game/Screens/Select/Carousel/SetPanelContent.cs b/osu.Game/Screens/Select/Carousel/SetPanelContent.cs
index 8d6fbbf256..c3ded16bd2 100644
--- a/osu.Game/Screens/Select/Carousel/SetPanelContent.cs
+++ b/osu.Game/Screens/Select/Carousel/SetPanelContent.cs
@@ -77,7 +77,6 @@ namespace osu.Game.Screens.Select.Carousel
                                 },
                             new BeatmapSetOnlineStatusPill
                             {
-                                AutoSizeAxes = Axes.Both,
                                 Origin = Anchor.CentreLeft,
                                 Anchor = Anchor.CentreLeft,
                                 TextSize = 11,
diff --git a/osu.Game/Screens/Select/Filter/Operator.cs b/osu.Game/Screens/Select/Filter/Operator.cs
index 706daf631f..e9d9af548e 100644
--- a/osu.Game/Screens/Select/Filter/Operator.cs
+++ b/osu.Game/Screens/Select/Filter/Operator.cs
@@ -11,6 +11,7 @@ namespace osu.Game.Screens.Select.Filter
         Less,
         LessOrEqual,
         Equal,
+        NotEqual,
         GreaterOrEqual,
         Greater
     }
diff --git a/osu.Game/Screens/Select/FilterQueryParser.cs b/osu.Game/Screens/Select/FilterQueryParser.cs
index 78f3bab114..1094d88730 100644
--- a/osu.Game/Screens/Select/FilterQueryParser.cs
+++ b/osu.Game/Screens/Select/FilterQueryParser.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Screens.Select
     public static class FilterQueryParser
     {
         private static readonly Regex query_syntax_regex = new Regex(
-            @"\b(?<key>\w+)(?<op>(:|=|(>|<)(:|=)?))(?<value>("".*""[!]?)|(\S*))",
+            @"\b(?<key>\w+)(?<op>(!?(:|=)|(>|<)(:|=)?))(?<value>("".*""[!]?)|(\S*))",
             RegexOptions.Compiled | RegexOptions.IgnoreCase);
 
         internal static void ApplyQueries(FilterCriteria criteria, string query)
@@ -129,6 +129,10 @@ namespace osu.Game.Screens.Select
                 case ":":
                     return Operator.Equal;
 
+                case "!=":
+                case "!:":
+                    return Operator.NotEqual;
+
                 case "<":
                     return Operator.Less;
 
diff --git a/osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboard.cs b/osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboard.cs
index 46705aaa28..f5fefa52b5 100644
--- a/osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboard.cs
+++ b/osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboard.cs
@@ -3,21 +3,16 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
-using osu.Game.Database;
-using osu.Game.Extensions;
 using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using Realms;
 
 namespace osu.Game.Screens.Select.Leaderboards
 {
@@ -67,6 +62,8 @@ namespace osu.Game.Screens.Select.Leaderboards
             }
         }
 
+        private readonly Bindable<LeaderboardScores?> fetchedScores = new Bindable<LeaderboardScores?>();
+
         [Resolved]
         private IBindable<RulesetInfo> ruleset { get; set; } = null!;
 
@@ -74,17 +71,7 @@ namespace osu.Game.Screens.Select.Leaderboards
         private IBindable<IReadOnlyList<Mod>> mods { get; set; } = null!;
 
         [Resolved]
-        private IAPIProvider api { get; set; } = null!;
-
-        [Resolved]
-        private RulesetStore rulesets { get; set; } = null!;
-
-        [Resolved]
-        private RealmAccess realm { get; set; } = null!;
-
-        private IDisposable? scoreSubscription;
-
-        private GetScoresRequest? scoreRetrievalRequest;
+        private LeaderboardManager leaderboardManager { get; set; } = null!;
 
         [BackgroundDependencyLoader]
         private void load()
@@ -95,84 +82,38 @@ namespace osu.Game.Screens.Select.Leaderboards
                 if (filterMods)
                     RefetchScores();
             };
+            ((IBindable<LeaderboardScores?>)fetchedScores).BindTo(leaderboardManager.Scores);
         }
 
         protected override bool IsOnlineScope => Scope != BeatmapLeaderboardScope.Local;
 
         protected override APIRequest? FetchScores(CancellationToken cancellationToken)
         {
-            scoreRetrievalRequest?.Cancel();
-            scoreRetrievalRequest = null;
-
             var fetchBeatmapInfo = BeatmapInfo;
+            var fetchRuleset = ruleset.Value ?? fetchBeatmapInfo?.Ruleset;
 
-            if (fetchBeatmapInfo == null)
-            {
-                SetErrorState(LeaderboardState.NoneSelected);
-                return null;
-            }
+            leaderboardManager.FetchWithCriteriaAsync(new LeaderboardCriteria(fetchBeatmapInfo, fetchRuleset, Scope, filterMods ? mods.Value.ToArray() : null))
+                              .ContinueWith(t =>
+                              {
+                                  if (t.Exception != null && !t.IsCanceled)
+                                  {
+                                      Schedule(() => SetErrorState(LeaderboardState.NetworkFailure));
+                                      return;
+                                  }
 
-            var fetchRuleset = ruleset.Value ?? fetchBeatmapInfo.Ruleset;
+                                  fetchedScores.UnbindEvents();
+                                  fetchedScores.BindValueChanged(scores =>
+                                  {
+                                      if (scores.NewValue == null) return;
 
-            if (Scope == BeatmapLeaderboardScope.Local)
-            {
-                subscribeToLocalScores(fetchBeatmapInfo, cancellationToken);
-                return null;
-            }
+                                      if (scores.NewValue.FailState == null)
+                                          Schedule(() => SetScores(scores.NewValue.TopScores, scores.NewValue.UserScore));
+                                      else
+                                          Schedule(() => SetErrorState((LeaderboardState)scores.NewValue.FailState));
+                                  }, true);
+                              }, cancellationToken);
 
-            if (!api.IsLoggedIn)
-            {
-                SetErrorState(LeaderboardState.NotLoggedIn);
-                return null;
-            }
-
-            if (!fetchRuleset.IsLegacyRuleset())
-            {
-                SetErrorState(LeaderboardState.RulesetUnavailable);
-                return null;
-            }
-
-            if (fetchBeatmapInfo.OnlineID <= 0 || fetchBeatmapInfo.Status <= BeatmapOnlineStatus.Pending)
-            {
-                SetErrorState(LeaderboardState.BeatmapUnavailable);
-                return null;
-            }
-
-            if (Scope.RequiresSupporter(filterMods) && !api.LocalUser.Value.IsSupporter)
-            {
-                SetErrorState(LeaderboardState.NotSupporter);
-                return null;
-            }
-
-            if (Scope == BeatmapLeaderboardScope.Team && api.LocalUser.Value.Team == null)
-            {
-                SetErrorState(LeaderboardState.NoTeam);
-                return null;
-            }
-
-            IReadOnlyList<Mod>? requestMods = null;
-
-            if (filterMods && !mods.Value.Any())
-                // add nomod for the request
-                requestMods = new Mod[] { new ModNoMod() };
-            else if (filterMods)
-                requestMods = mods.Value;
-
-            var newRequest = new GetScoresRequest(fetchBeatmapInfo, fetchRuleset, Scope, requestMods);
-            newRequest.Success += response => Schedule(() =>
-            {
-                // Request may have changed since fetch request.
-                // Can't rely on request cancellation due to Schedule inside SetScores so let's play it safe.
-                if (!newRequest.Equals(scoreRetrievalRequest))
-                    return;
-
-                SetScores(
-                    response.Scores.Select(s => s.ToScoreInfo(rulesets, fetchBeatmapInfo)).OrderByTotalScore(),
-                    response.UserScore?.CreateScoreInfo(rulesets, fetchBeatmapInfo)
-                );
-            });
-
-            return scoreRetrievalRequest = newRequest;
+            return null;
         }
 
         protected override LeaderboardScore CreateDrawableScore(ScoreInfo model, int index) => new LeaderboardScore(model, index, IsOnlineScope, Scope != BeatmapLeaderboardScope.Friend)
@@ -184,59 +125,5 @@ namespace osu.Game.Screens.Select.Leaderboards
         {
             Action = () => ScoreSelected?.Invoke(model)
         };
-
-        private void subscribeToLocalScores(BeatmapInfo beatmapInfo, CancellationToken cancellationToken)
-        {
-            Debug.Assert(beatmapInfo != null);
-
-            scoreSubscription?.Dispose();
-            scoreSubscription = null;
-
-            scoreSubscription = realm.RegisterForNotifications(r =>
-                r.All<ScoreInfo>().Filter($"{nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $0"
-                                          + $" AND {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
-                                          + $" AND {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $1"
-                                          + $" AND {nameof(ScoreInfo.DeletePending)} == false"
-                    , beatmapInfo.ID, ruleset.Value.ShortName), localScoresChanged);
-
-            void localScoresChanged(IRealmCollection<ScoreInfo> sender, ChangeSet? changes)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                    return;
-
-                // This subscription may fire from changes to linked beatmaps, which we don't care about.
-                // It's currently not possible for a score to be modified after insertion, so we can safely ignore callbacks with only modifications.
-                if (changes?.HasCollectionChanges() == false)
-                    return;
-
-                var scores = sender.AsEnumerable();
-
-                if (filterMods && !mods.Value.Any())
-                {
-                    // we need to filter out all scores that have any mods to get all local nomod scores
-                    scores = scores.Where(s => !s.Mods.Any());
-                }
-                else if (filterMods)
-                {
-                    // otherwise find all the scores that have all of the currently selected mods (similar to how web applies mod filters)
-                    // we're creating and using a string HashSet representation of selected mods so that it can be translated into the DB query itself
-                    var selectedMods = mods.Value.Select(m => m.Acronym).ToHashSet();
-
-                    scores = scores.Where(s => selectedMods.SetEquals(s.Mods.Select(m => m.Acronym)));
-                }
-
-                scores = scores.Detach().OrderByTotalScore();
-
-                SetScores(scores);
-            }
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            scoreSubscription?.Dispose();
-            scoreRetrievalRequest?.Cancel();
-        }
     }
 }
diff --git a/osu.Game/Screens/Select/Leaderboards/GameplayLeaderboardScore.cs b/osu.Game/Screens/Select/Leaderboards/GameplayLeaderboardScore.cs
new file mode 100644
index 0000000000..2655fd8dba
--- /dev/null
+++ b/osu.Game/Screens/Select/Leaderboards/GameplayLeaderboardScore.cs
@@ -0,0 +1,113 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Online.Spectator;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Scoring.Legacy;
+using osu.Game.Users;
+
+namespace osu.Game.Screens.Select.Leaderboards
+{
+    /// <summary>
+    /// Represents a score shown on a gameplay leaderboard.
+    /// The score is expected to update itself as gameplay progresses.
+    /// </summary>
+    public class GameplayLeaderboardScore
+    {
+        /// <summary>
+        /// The user playing.
+        /// </summary>
+        public IUser User { get; }
+
+        /// <summary>
+        /// Whether the score is being tracked.
+        /// Generally understood as true when this score is the score of the local user currently playing.
+        /// </summary>
+        public bool Tracked { get; }
+
+        /// <summary>
+        /// The current total of the score.
+        /// </summary>
+        public BindableLong TotalScore { get; } = new BindableLong();
+
+        /// <summary>
+        /// The current accuracy of the score.
+        /// </summary>
+        public BindableDouble Accuracy { get; } = new BindableDouble();
+
+        /// <summary>
+        /// The current combo of the score.
+        /// </summary>
+        public BindableInt Combo { get; } = new BindableInt();
+
+        /// <summary>
+        /// Whether the user playing has quit.
+        /// </summary>
+        public BindableBool HasQuit { get; } = new BindableBool();
+
+        /// <summary>
+        /// An optional value to guarantee stable ordering.
+        /// Lower numbers will appear higher in cases of <see cref="TotalScore"/> ties.
+        /// </summary>
+        public Bindable<long> DisplayOrder { get; } = new BindableLong();
+
+        /// <summary>
+        /// A custom function which handles converting a score to a display score using a provided <see cref="ScoringMode"/>.
+        /// </summary>
+        /// <remarks>
+        /// If no function is provided, <see cref="TotalScore"/> will be used verbatim.
+        /// </remarks>
+        public Func<ScoringMode, long> GetDisplayScore { get; set; }
+
+        /// <summary>
+        /// The colour of the team that the user playing is on, if any.
+        /// </summary>
+        public Colour4? TeamColour { get; init; }
+
+        public GameplayLeaderboardScore(IUser user, ScoreProcessor scoreProcessor, bool tracked)
+        {
+            User = user;
+            Tracked = tracked;
+            TotalScore.BindTarget = scoreProcessor.TotalScore;
+            Accuracy.BindTarget = scoreProcessor.Accuracy;
+            Combo.BindTarget = scoreProcessor.Combo;
+            GetDisplayScore = scoreProcessor.GetDisplayScore;
+        }
+
+        public GameplayLeaderboardScore(IUser user, SpectatorScoreProcessor scoreProcessor, bool tracked)
+        {
+            User = user;
+            Tracked = tracked;
+            TotalScore.BindTarget = scoreProcessor.TotalScore;
+            Accuracy.BindTarget = scoreProcessor.Accuracy;
+            Combo.BindTarget = scoreProcessor.Combo;
+            GetDisplayScore = scoreProcessor.GetDisplayScore;
+        }
+
+        public GameplayLeaderboardScore(ScoreInfo scoreInfo, bool tracked)
+        {
+            User = scoreInfo.User;
+            Tracked = tracked;
+            TotalScore.Value = scoreInfo.TotalScore;
+            Accuracy.Value = scoreInfo.Accuracy;
+            Combo.Value = scoreInfo.Combo;
+            DisplayOrder.Value = scoreInfo.OnlineID > 0 ? scoreInfo.OnlineID : scoreInfo.Date.ToUnixTimeSeconds();
+            GetDisplayScore = scoreInfo.GetDisplayScore;
+        }
+
+        /// <remarks>
+        /// Used for testing.
+        /// </remarks>
+        internal GameplayLeaderboardScore(IUser user, bool tracked, Bindable<long> displayScore)
+        {
+            User = user;
+            Tracked = tracked;
+            TotalScore.BindTarget = displayScore;
+            GetDisplayScore = _ => displayScore.Value;
+        }
+    }
+}
diff --git a/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs b/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs
new file mode 100644
index 0000000000..4399c422b4
--- /dev/null
+++ b/osu.Game/Screens/Select/Leaderboards/IGameplayLeaderboardProvider.cs
@@ -0,0 +1,27 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+
+namespace osu.Game.Screens.Select.Leaderboards
+{
+    /// <summary>
+    /// Provides a leaderboard to show during gameplay.
+    /// </summary>
+    public interface IGameplayLeaderboardProvider
+    {
+        /// <summary>
+        /// List of all scores to display on the leaderboard.
+        /// </summary>
+        public IBindableList<GameplayLeaderboardScore> Scores { get; }
+
+        /// <summary>
+        /// Whether this leaderboard is a partial leaderboard (e.g. contains only the top 50 of all scores),
+        /// or is a full leaderboard (contains all scores that there will ever be).
+        /// </summary>
+        /// <remarks>
+        /// If this is <see langword="true"/> and a tracked score is last on the leaderboard, it will show an "unknown" score position.
+        /// </remarks>
+        bool IsPartial { get; }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorLeaderboard.cs b/osu.Game/Screens/Select/Leaderboards/MultiSpectatorLeaderboardProvider.cs
similarity index 76%
rename from osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorLeaderboard.cs
rename to osu.Game/Screens/Select/Leaderboards/MultiSpectatorLeaderboardProvider.cs
index ed92b719fc..19ae12a6ca 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorLeaderboard.cs
+++ b/osu.Game/Screens/Select/Leaderboards/MultiSpectatorLeaderboardProvider.cs
@@ -4,13 +4,12 @@
 using System;
 using osu.Framework.Timing;
 using osu.Game.Online.Multiplayer;
-using osu.Game.Screens.Play.HUD;
 
-namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
+namespace osu.Game.Screens.Select.Leaderboards
 {
-    public partial class MultiSpectatorLeaderboard : MultiplayerGameplayLeaderboard
+    public partial class MultiSpectatorLeaderboardProvider : MultiplayerLeaderboardProvider
     {
-        public MultiSpectatorLeaderboard(MultiplayerRoomUser[] users)
+        public MultiSpectatorLeaderboardProvider(MultiplayerRoomUser[] users)
             : base(users)
         {
         }
diff --git a/osu.Game/Screens/Play/HUD/MultiplayerGameplayLeaderboard.cs b/osu.Game/Screens/Select/Leaderboards/MultiplayerLeaderboardProvider.cs
similarity index 68%
rename from osu.Game/Screens/Play/HUD/MultiplayerGameplayLeaderboard.cs
rename to osu.Game/Screens/Select/Leaderboards/MultiplayerLeaderboardProvider.cs
index 922def6174..edfccd0e7e 100644
--- a/osu.Game/Screens/Play/HUD/MultiplayerGameplayLeaderboard.cs
+++ b/osu.Game/Screens/Select/Leaderboards/MultiplayerLeaderboardProvider.cs
@@ -11,6 +11,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Configuration;
 using osu.Game.Database;
 using osu.Game.Graphics;
@@ -20,20 +21,30 @@ using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Spectator;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Users;
 using osuTK.Graphics;
 
-namespace osu.Game.Screens.Play.HUD
+namespace osu.Game.Screens.Select.Leaderboards
 {
     [LongRunningLoad]
-    public partial class MultiplayerGameplayLeaderboard : GameplayLeaderboard
+    public partial class MultiplayerLeaderboardProvider : CompositeComponent, IGameplayLeaderboardProvider
     {
-        protected readonly Dictionary<int, TrackedUserData> UserScores = new Dictionary<int, TrackedUserData>();
+        public IBindableList<GameplayLeaderboardScore> Scores => scores;
+        private readonly BindableList<GameplayLeaderboardScore> scores = new BindableList<GameplayLeaderboardScore>();
 
+        protected readonly Dictionary<int, TrackedUserData> UserScores = new Dictionary<int, TrackedUserData>();
         public readonly SortedDictionary<int, BindableLong> TeamScores = new SortedDictionary<int, BindableLong>();
 
+        public bool HasTeams => TeamScores.Count > 0;
+
+        public bool IsPartial => false;
+
+        private readonly MultiplayerRoomUser[] users;
+
+        private readonly Bindable<ScoringMode> scoringMode = new Bindable<ScoringMode>();
+        private readonly IBindableList<int> playingUserIds = new BindableList<int>();
+
         [Resolved]
-        private OsuColour colours { get; set; } = null!;
+        private UserLookupCache userLookupCache { get; set; } = null!;
 
         [Resolved]
         private SpectatorClient spectatorClient { get; set; } = null!;
@@ -42,31 +53,19 @@ namespace osu.Game.Screens.Play.HUD
         private MultiplayerClient multiplayerClient { get; set; } = null!;
 
         [Resolved]
-        private UserLookupCache userLookupCache { get; set; } = null!;
+        private OsuColour colours { get; set; } = null!;
 
-        private Bindable<ScoringMode> scoringMode = null!;
-
-        private readonly MultiplayerRoomUser[] playingUsers;
-
-        private readonly IBindableList<int> playingUserIds = new BindableList<int>();
-
-        private bool hasTeams => TeamScores.Count > 0;
-
-        /// <summary>
-        /// Construct a new leaderboard.
-        /// </summary>
-        /// <param name="users">IDs of all users in this match.</param>
-        public MultiplayerGameplayLeaderboard(MultiplayerRoomUser[] users)
+        public MultiplayerLeaderboardProvider(MultiplayerRoomUser[] users)
         {
-            playingUsers = users;
+            this.users = users;
         }
 
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config, IAPIProvider api, CancellationToken cancellationToken)
         {
-            scoringMode = config.GetBindable<ScoringMode>(OsuSetting.ScoreDisplayMode);
+            config.BindWith(OsuSetting.ScoreDisplayMode, scoringMode);
 
-            foreach (var user in playingUsers)
+            foreach (var user in users)
             {
                 var scoreProcessor = new SpectatorScoreProcessor(user.UserID);
                 scoreProcessor.Mode.BindTo(scoringMode);
@@ -80,29 +79,29 @@ namespace osu.Game.Screens.Play.HUD
                     TeamScores.Add(team, new BindableLong());
             }
 
-            userLookupCache.GetUsersAsync(playingUsers.Select(u => u.UserID).ToArray(), cancellationToken)
+            userLookupCache.GetUsersAsync(users.Select(u => u.UserID).ToArray(), cancellationToken)
                            .ContinueWith(task =>
                            {
                                Schedule(() =>
                                {
-                                   var users = task.GetResultSafely();
+                                   var lookedUpUsers = task.GetResultSafely();
 
-                                   for (int i = 0; i < users.Length; i++)
+                                   for (int i = 0; i < lookedUpUsers.Length; i++)
                                    {
-                                       var user = users[i] ?? new APIUser
+                                       var user = lookedUpUsers[i] ?? new APIUser
                                        {
-                                           Id = playingUsers[i].UserID,
+                                           Id = users[i].UserID,
                                            Username = "Unknown user",
                                        };
 
                                        var trackedUser = UserScores[user.Id];
 
-                                       var leaderboardScore = Add(user, user.Id == api.LocalUser.Value.Id);
-                                       leaderboardScore.GetDisplayScore = trackedUser.ScoreProcessor.GetDisplayScore;
-                                       leaderboardScore.Accuracy.BindTo(trackedUser.ScoreProcessor.Accuracy);
-                                       leaderboardScore.TotalScore.BindTo(trackedUser.ScoreProcessor.TotalScore);
-                                       leaderboardScore.Combo.BindTo(trackedUser.ScoreProcessor.Combo);
-                                       leaderboardScore.HasQuit.BindTo(trackedUser.UserQuit);
+                                       var leaderboardScore = new GameplayLeaderboardScore(user, trackedUser.ScoreProcessor, user.Id == api.LocalUser.Value.Id)
+                                       {
+                                           HasQuit = { BindTarget = trackedUser.UserQuit },
+                                           TeamColour = UserScores[user.OnlineID].Team is int team ? getTeamColour(team) : null,
+                                       };
+                                       scores.Add(leaderboardScore);
                                    }
                                });
                            }, cancellationToken);
@@ -113,7 +112,7 @@ namespace osu.Game.Screens.Play.HUD
             base.LoadComplete();
 
             // BindableList handles binding in a really bad way (Clear then AddRange) so we need to do this manually..
-            foreach (var user in playingUsers)
+            foreach (var user in users)
             {
                 spectatorClient.WatchUser(user.UserID);
 
@@ -127,34 +126,6 @@ namespace osu.Game.Screens.Play.HUD
             playingUserIds.BindCollectionChanged(playingUsersChanged);
         }
 
-        protected override GameplayLeaderboardScore CreateLeaderboardScoreDrawable(IUser? user, bool isTracked)
-        {
-            var leaderboardScore = base.CreateLeaderboardScoreDrawable(user, isTracked);
-
-            if (user != null)
-            {
-                if (UserScores[user.OnlineID].Team is int team)
-                {
-                    leaderboardScore.BackgroundColour = getTeamColour(team).Lighten(1.2f);
-                    leaderboardScore.TextColour = Color4.White;
-                }
-            }
-
-            return leaderboardScore;
-        }
-
-        private Color4 getTeamColour(int team)
-        {
-            switch (team)
-            {
-                case 0:
-                    return colours.TeamColourRed;
-
-                default:
-                    return colours.TeamColourBlue;
-            }
-        }
-
         private void playingUsersChanged(object? sender, NotifyCollectionChangedEventArgs e)
         {
             switch (e.Action)
@@ -176,10 +147,10 @@ namespace osu.Game.Screens.Play.HUD
 
         private void updateTotals()
         {
-            if (!hasTeams)
+            if (!HasTeams)
                 return;
 
-            foreach (var scores in TeamScores.Values) scores.Value = 0;
+            foreach (var teamTotal in TeamScores.Values) teamTotal.Value = 0;
 
             foreach (var u in UserScores.Values)
             {
@@ -191,13 +162,25 @@ namespace osu.Game.Screens.Play.HUD
             }
         }
 
+        private Color4 getTeamColour(int team)
+        {
+            switch (team)
+            {
+                case 0:
+                    return colours.TeamColourRed.Lighten(1.2f);
+
+                default:
+                    return colours.TeamColourBlue.Lighten(1.2f);
+            }
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
 
             if (spectatorClient.IsNotNull())
             {
-                foreach (var user in playingUsers)
+                foreach (var user in users)
                     spectatorClient.StopWatchingUser(user.UserID);
             }
         }
diff --git a/osu.Game/Screens/Select/Leaderboards/SoloGameplayLeaderboardProvider.cs b/osu.Game/Screens/Select/Leaderboards/SoloGameplayLeaderboardProvider.cs
new file mode 100644
index 0000000000..5cbbb3f3b0
--- /dev/null
+++ b/osu.Game/Screens/Select/Leaderboards/SoloGameplayLeaderboardProvider.cs
@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Online.Leaderboards;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Screens.Select.Leaderboards
+{
+    public partial class SoloGameplayLeaderboardProvider : Component, IGameplayLeaderboardProvider
+    {
+        public bool IsPartial { get; private set; }
+
+        public IBindableList<GameplayLeaderboardScore> Scores => scores;
+        private readonly BindableList<GameplayLeaderboardScore> scores = new BindableList<GameplayLeaderboardScore>();
+
+        [Resolved]
+        private LeaderboardManager? leaderboardManager { get; set; }
+
+        [Resolved]
+        private GameplayState? gameplayState { get; set; }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            var globalScores = leaderboardManager?.Scores.Value;
+
+            IsPartial = leaderboardManager?.CurrentCriteria?.Scope != BeatmapLeaderboardScope.Local && globalScores?.TopScores.Count >= 50;
+
+            if (globalScores != null)
+            {
+                foreach (var topScore in globalScores.AllScores.OrderByTotalScore())
+                    scores.Add(new GameplayLeaderboardScore(topScore, false));
+            }
+
+            if (gameplayState != null)
+            {
+                scores.Add(new GameplayLeaderboardScore(gameplayState.Score.ScoreInfo.User, gameplayState.ScoreProcessor, true)
+                {
+                    // Local score should always show lower than any existing scores in cases of ties.
+                    DisplayOrder = { Value = long.MaxValue }
+                });
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Select/ModSpeedHotkeyHandler.cs b/osu.Game/Screens/Select/ModSpeedHotkeyHandler.cs
index c4cd44705e..998f94849c 100644
--- a/osu.Game/Screens/Select/ModSpeedHotkeyHandler.cs
+++ b/osu.Game/Screens/Select/ModSpeedHotkeyHandler.cs
@@ -8,6 +8,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
+using osu.Game.Input;
 using osu.Game.Overlays;
 using osu.Game.Overlays.OSD;
 using osu.Game.Rulesets.Mods;
@@ -21,7 +22,7 @@ namespace osu.Game.Screens.Select
         private Bindable<IReadOnlyList<Mod>> selectedMods { get; set; } = null!;
 
         [Resolved]
-        private OsuConfigManager config { get; set; } = null!;
+        private RealmKeyBindingStore keyBindingStore { get; set; } = null!;
 
         [Resolved]
         private OnScreenDisplay? onScreenDisplay { get; set; }
@@ -55,7 +56,7 @@ namespace osu.Game.Screens.Select
             if (Precision.AlmostEquals(targetSpeed, 1, 0.005))
             {
                 selectedMods.Value = selectedMods.Value.Where(m => m is not ModRateAdjust).ToList();
-                onScreenDisplay?.Display(new SpeedChangeToast(config, targetSpeed));
+                onScreenDisplay?.Display(new SpeedChangeToast(keyBindingStore, targetSpeed));
                 return true;
             }
 
@@ -108,7 +109,7 @@ namespace osu.Game.Screens.Select
                 return false;
 
             selectedMods.Value = intendedMods;
-            onScreenDisplay?.Display(new SpeedChangeToast(config, targetMod.SpeedChange.Value));
+            onScreenDisplay?.Display(new SpeedChangeToast(keyBindingStore, targetMod.SpeedChange.Value));
             return true;
         }
     }
diff --git a/osu.Game/Screens/Select/Options/BeatmapOptionsButton.cs b/osu.Game/Screens/Select/Options/BeatmapOptionsButton.cs
index 045a518525..572b2427b1 100644
--- a/osu.Game/Screens/Select/Options/BeatmapOptionsButton.cs
+++ b/osu.Game/Screens/Select/Options/BeatmapOptionsButton.cs
@@ -89,7 +89,7 @@ namespace osu.Game.Screens.Select.Options
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both,
-                    Shear = new Vector2(0.2f, 0f),
+                    Shear = OsuGame.SHEAR,
                     Masking = true,
                     EdgeEffect = new EdgeEffectParameters
                     {
diff --git a/osu.Game/Screens/Select/PlaySongSelect.cs b/osu.Game/Screens/Select/PlaySongSelect.cs
index 7b1479f392..c49b7c2ef2 100644
--- a/osu.Game/Screens/Select/PlaySongSelect.cs
+++ b/osu.Game/Screens/Select/PlaySongSelect.cs
@@ -129,17 +129,11 @@ namespace osu.Game.Screens.Select
 
                 if (replayGeneratingMod != null)
                 {
-                    player = new ReplayPlayer((beatmap, mods) => replayGeneratingMod.CreateScoreFromReplayData(beatmap, mods))
-                    {
-                        LeaderboardScores = { BindTarget = playBeatmapDetailArea.Leaderboard.Scores }
-                    };
+                    player = new ReplayPlayer((beatmap, mods) => replayGeneratingMod.CreateScoreFromReplayData(beatmap, mods));
                 }
                 else
                 {
-                    player = new SoloPlayer
-                    {
-                        LeaderboardScores = { BindTarget = playBeatmapDetailArea.Leaderboard.Scores }
-                    };
+                    player = new SoloPlayer();
                 }
 
                 return player;
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
index 994b0fb6c0..9cb7d152de 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
@@ -13,6 +13,7 @@ using osu.Framework.Graphics.Pooling;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Select;
 
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
index 8f9d5cc31b..a628595477 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 
@@ -46,7 +47,9 @@ namespace osu.Game.Screens.SelectV2
                 var newItems = new List<CarouselItem>();
 
                 BeatmapInfo? lastBeatmap = null;
+
                 GroupDefinition? lastGroup = null;
+                CarouselItem? lastGroupItem = null;
 
                 HashSet<CarouselItem>? currentGroupItems = null;
                 HashSet<CarouselItem>? currentSetItems = null;
@@ -68,7 +71,7 @@ namespace osu.Game.Screens.SelectV2
                         groupItems[newGroup] = currentGroupItems = new HashSet<CarouselItem>();
                         lastGroup = newGroup;
 
-                        addItem(new CarouselItem(newGroup)
+                        addItem(lastGroupItem = new CarouselItem(newGroup)
                         {
                             DrawHeight = PanelGroup.HEIGHT,
                             DepthLayer = -2,
@@ -83,6 +86,9 @@ namespace osu.Game.Screens.SelectV2
                         {
                             setItems[beatmap.BeatmapSet!] = currentSetItems = new HashSet<CarouselItem>();
 
+                            if (lastGroupItem != null)
+                                lastGroupItem.NestedItemCount++;
+
                             addItem(new CarouselItem(beatmap.BeatmapSet!)
                             {
                                 DrawHeight = PanelBeatmapSet.HEIGHT,
@@ -90,6 +96,11 @@ namespace osu.Game.Screens.SelectV2
                             });
                         }
                     }
+                    else
+                    {
+                        if (lastGroupItem != null)
+                            lastGroupItem.NestedItemCount++;
+                    }
 
                     addItem(item);
                     lastBeatmap = beatmap;
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterSorting.cs b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterSorting.cs
index 3cdbbb4fed..22a67321db 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterSorting.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterSorting.cs
@@ -7,6 +7,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Utils;
diff --git a/osu.Game/Screens/SelectV2/BeatmapInfoWedgeV2.cs b/osu.Game/Screens/SelectV2/BeatmapInfoWedgeV2.cs
deleted file mode 100644
index b294896c77..0000000000
--- a/osu.Game/Screens/SelectV2/BeatmapInfoWedgeV2.cs
+++ /dev/null
@@ -1,330 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Threading;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Effects;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Localisation;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.Drawables;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Rulesets;
-using osu.Game.Screens.Select;
-using osuTK;
-
-namespace osu.Game.Screens.SelectV2
-{
-    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/SelectV2/Leaderboards/LeaderboardScoreV2.cs b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
similarity index 96%
rename from osu.Game/Screens/SelectV2/Leaderboards/LeaderboardScoreV2.cs
rename to osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
index 16599a2080..c9413a9414 100644
--- a/osu.Game/Screens/SelectV2/Leaderboards/LeaderboardScoreV2.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
@@ -41,9 +41,9 @@ using osuTK;
 using osuTK.Graphics;
 using CommonStrings = osu.Game.Localisation.CommonStrings;
 
-namespace osu.Game.Screens.SelectV2.Leaderboards
+namespace osu.Game.Screens.SelectV2
 {
-    public partial class LeaderboardScoreV2 : OsuClickableContainer, IHasContextMenu, IHasCustomTooltip<ScoreInfo>
+    public partial class BeatmapLeaderboardScore : OsuClickableContainer, IHasContextMenu, IHasCustomTooltip<ScoreInfo>
     {
         public Bindable<IReadOnlyList<Mod>> SelectedMods = new Bindable<IReadOnlyList<Mod>>();
 
@@ -117,12 +117,12 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
         public ITooltip<ScoreInfo> GetCustomTooltip() => new LeaderboardScoreTooltip();
         public virtual ScoreInfo TooltipContent => score;
 
-        public LeaderboardScoreV2(ScoreInfo score, bool sheared = true)
+        public BeatmapLeaderboardScore(ScoreInfo score, bool sheared = true)
         {
             this.score = score;
             this.sheared = sheared;
 
-            Shear = new Vector2(sheared ? OsuGame.SHEAR : 0, 0);
+            Shear = sheared ? OsuGame.SHEAR : Vector2.Zero;
             RelativeSizeAxes = Axes.X;
             Height = height;
         }
@@ -255,7 +255,7 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
                 {
                     RelativeSizeAxes = Axes.Both,
                     User = score.User,
-                    Shear = new Vector2(sheared ? -OsuGame.SHEAR : 0, 0),
+                    Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
                     Anchor = Anchor.BottomLeft,
                     Origin = Anchor.BottomLeft,
                     Colour = ColourInfo.GradientHorizontal(Colour4.White.Opacity(0.5f), Colour4.FromHex(@"222A27").Opacity(1)),
@@ -286,7 +286,7 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
                                             Anchor = Anchor.Centre,
                                             Origin = Anchor.Centre,
                                             Scale = new Vector2(1.1f),
-                                            Shear = new Vector2(sheared ? -OsuGame.SHEAR : 0, 0),
+                                            Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
                                             RelativeSizeAxes = Axes.Both,
                                         })
                                     {
@@ -326,7 +326,7 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
                                 {
                                     flagBadgeAndDateContainer = new FillFlowContainer
                                     {
-                                        Shear = new Vector2(sheared ? -OsuGame.SHEAR : 0, 0),
+                                        Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
                                         Direction = FillDirection.Horizontal,
                                         Spacing = new Vector2(5),
                                         AutoSizeAxes = Axes.Both,
@@ -356,7 +356,7 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
                                     nameLabel = new TruncatingSpriteText
                                     {
                                         RelativeSizeAxes = Axes.X,
-                                        Shear = new Vector2(sheared ? -OsuGame.SHEAR : 0, 0),
+                                        Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
                                         Text = user.Username,
                                         Font = OsuFont.GetFont(size: 20, weight: FontWeight.SemiBold)
                                     }
@@ -372,7 +372,7 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
                                     Name = @"Statistics container",
                                     Padding = new MarginPadding { Right = 40 },
                                     Spacing = new Vector2(25, 0),
-                                    Shear = new Vector2(sheared ? -OsuGame.SHEAR : 0, 0),
+                                    Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
                                     Anchor = Anchor.CentreRight,
                                     Origin = Anchor.CentreRight,
                                     AutoSizeAxes = Axes.Both,
@@ -430,7 +430,7 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
                     },
                     RankContainer = new Container
                     {
-                        Shear = new Vector2(sheared ? -OsuGame.SHEAR : 0, 0),
+                        Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
                         Anchor = Anchor.CentreRight,
                         Origin = Anchor.CentreRight,
                         RelativeSizeAxes = Axes.Y,
@@ -488,7 +488,7 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
                                             Anchor = Anchor.TopRight,
                                             Origin = Anchor.TopRight,
                                             UseFullGlyphHeight = false,
-                                            Shear = new Vector2(sheared ? -OsuGame.SHEAR : 0, 0),
+                                            Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
                                             Current = scoreManager.GetBindableTotalScoreString(score),
                                             Font = OsuFont.GetFont(size: 30, weight: FontWeight.Light),
                                         },
@@ -496,7 +496,7 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
                                         {
                                             Anchor = Anchor.TopRight,
                                             Origin = Anchor.TopRight,
-                                            Shear = new Vector2(sheared ? -OsuGame.SHEAR : 0, 0),
+                                            Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
                                             AutoSizeAxes = Axes.Both,
                                             Direction = FillDirection.Horizontal,
                                             Spacing = new Vector2(2f, 0f),
@@ -704,7 +704,7 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
 
                 Child = new OsuSpriteText
                 {
-                    Shear = new Vector2(sheared ? -OsuGame.SHEAR : 0, 0),
+                    Shear = sheared ? -OsuGame.SHEAR : Vector2.Zero,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Font = OsuFont.GetFont(size: 20, weight: FontWeight.SemiBold, italics: true),
diff --git a/osu.Game/Screens/SelectV2/CollectionDropdown.cs b/osu.Game/Screens/SelectV2/CollectionDropdown.cs
new file mode 100644
index 0000000000..a2a2ec1c93
--- /dev/null
+++ b/osu.Game/Screens/SelectV2/CollectionDropdown.cs
@@ -0,0 +1,271 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Diagnostics;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.Database;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osuTK;
+using Realms;
+
+namespace osu.Game.Screens.SelectV2
+{
+    /// <summary>
+    /// A dropdown to select the collection to be used to filter results.
+    /// </summary>
+    public partial class CollectionDropdown : ShearedDropdown<CollectionFilterMenuItem> // TODO: partial class under FilterControl?
+    {
+        /// <summary>
+        /// Whether to show the "manage collections..." menu item in the dropdown.
+        /// </summary>
+        protected virtual bool ShowManageCollectionsItem => true;
+
+        public Action? RequestFilter { private get; set; }
+
+        private readonly BindableList<CollectionFilterMenuItem> filters = new BindableList<CollectionFilterMenuItem>();
+
+        [Resolved]
+        private ManageCollectionsDialog? manageCollectionsDialog { get; set; }
+
+        [Resolved]
+        private RealmAccess realm { get; set; } = null!;
+
+        private IDisposable? realmSubscription;
+
+        private readonly CollectionFilterMenuItem allBeatmapsItem = new AllBeatmapsCollectionFilterMenuItem();
+
+        public CollectionDropdown()
+            : base("Collection")
+        {
+            ItemSource = filters;
+
+            Current.Value = allBeatmapsItem;
+            AlwaysShowSearchBar = true;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            realmSubscription = realm.RegisterForNotifications(r => r.All<BeatmapCollection>().OrderBy(c => c.Name), collectionsChanged);
+
+            Current.BindValueChanged(selectionChanged);
+        }
+
+        private void collectionsChanged(IRealmCollection<BeatmapCollection> collections, ChangeSet? changes)
+        {
+            if (changes == null)
+            {
+                filters.Clear();
+                filters.Add(allBeatmapsItem);
+                filters.AddRange(collections.Select(c => new CollectionFilterMenuItem(c.ToLive(realm))));
+                if (ShowManageCollectionsItem)
+                    filters.Add(new ManageCollectionsFilterMenuItem());
+            }
+            else
+            {
+                foreach (int i in changes.DeletedIndices.OrderDescending())
+                    filters.RemoveAt(i + 1);
+
+                foreach (int i in changes.InsertedIndices)
+                    filters.Insert(i + 1, new CollectionFilterMenuItem(collections[i].ToLive(realm)));
+
+                var selectedItem = SelectedItem?.Value;
+
+                foreach (int i in changes.NewModifiedIndices)
+                {
+                    var updatedItem = collections[i];
+
+                    // This is responsible for updating the state of the +/- button and the collection's name.
+                    // TODO: we can probably make the menu items update with changes to avoid this.
+                    filters.RemoveAt(i + 1);
+                    filters.Insert(i + 1, new CollectionFilterMenuItem(updatedItem.ToLive(realm)));
+
+                    if (updatedItem.ID == selectedItem?.Collection?.ID)
+                    {
+                        // This current update and schedule is required to work around dropdown headers not updating text even when the selected item
+                        // changes. It's not great but honestly the whole dropdown menu structure isn't great. This needs to be fixed, but I'll issue
+                        // a warning that it's going to be a frustrating journey.
+                        Current.Value = allBeatmapsItem;
+                        Schedule(() =>
+                        {
+                            // current may have changed before the scheduled call is run.
+                            if (Current.Value != allBeatmapsItem)
+                                return;
+
+                            Current.Value = filters.SingleOrDefault(f => f.Collection?.ID == selectedItem.Collection?.ID) ?? filters[0];
+                        });
+
+                        // Trigger an external re-filter if the current item was in the change set.
+                        RequestFilter?.Invoke();
+                        break;
+                    }
+                }
+            }
+        }
+
+        private Live<BeatmapCollection>? lastFiltered;
+
+        private void selectionChanged(ValueChangedEvent<CollectionFilterMenuItem> filter)
+        {
+            // May be null during .Clear().
+            if (filter.NewValue.IsNull())
+                return;
+
+            // Never select the manage collection filter - rollback to the previous filter.
+            // This is done after the above since it is important that bindable is unbound from OldValue, which is lost after forcing it back to the old value.
+            if (filter.NewValue is ManageCollectionsFilterMenuItem)
+            {
+                Current.Value = filter.OldValue;
+                manageCollectionsDialog?.Show();
+                return;
+            }
+
+            var newCollection = filter.NewValue.Collection;
+
+            // This dropdown be weird.
+            // We only care about filtering if the actual collection has changed.
+            if (newCollection != lastFiltered)
+            {
+                RequestFilter?.Invoke();
+                lastFiltered = newCollection;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            realmSubscription?.Dispose();
+        }
+
+        protected override LocalisableString GenerateItemText(CollectionFilterMenuItem item) => item.CollectionName;
+
+        protected sealed override DropdownMenu CreateMenu() => CreateCollectionMenu();
+
+        protected virtual ShearedCollectionDropdownMenu CreateCollectionMenu() => new ShearedCollectionDropdownMenu();
+
+        protected partial class ShearedCollectionDropdownMenu : ShearedDropdownMenu
+        {
+            public ShearedCollectionDropdownMenu()
+            {
+                MaxHeight = 200;
+            }
+
+            protected override DrawableDropdownMenuItem CreateDrawableDropdownMenuItem(MenuItem item) => new DrawableCollectionMenuItem(item)
+            {
+                BackgroundColourHover = HoverColour,
+                BackgroundColourSelected = SelectionColour
+            };
+        }
+
+        protected partial class DrawableCollectionMenuItem : ShearedDropdownMenu.ShearedMenuItem
+        {
+            private IconButton addOrRemoveButton = null!;
+
+            private bool beatmapInCollection;
+
+            private readonly Live<BeatmapCollection>? collection;
+
+            [Resolved]
+            private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
+
+            public DrawableCollectionMenuItem(MenuItem item)
+                : base(item)
+            {
+                collection = ((DropdownMenuItem<CollectionFilterMenuItem>)item).Value.Collection;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AddInternal(addOrRemoveButton = new NoFocusChangeIconButton
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    Shear = -OsuGame.SHEAR,
+                    X = -OsuScrollContainer.SCROLL_BAR_WIDTH,
+                    Scale = new Vector2(0.65f),
+                    Action = addOrRemove,
+                });
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                if (collection != null)
+                {
+                    beatmap.BindValueChanged(_ =>
+                    {
+                        beatmapInCollection = collection.PerformRead(c => c.BeatmapMD5Hashes.Contains(beatmap.Value.BeatmapInfo.MD5Hash));
+
+                        addOrRemoveButton.Enabled.Value = !beatmap.IsDefault;
+                        addOrRemoveButton.Icon = beatmapInCollection ? FontAwesome.Solid.MinusSquare : FontAwesome.Solid.PlusSquare;
+                        addOrRemoveButton.TooltipText = beatmapInCollection ? "Remove selected beatmap" : "Add selected beatmap";
+
+                        updateButtonVisibility();
+                    }, true);
+                }
+
+                updateButtonVisibility();
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                updateButtonVisibility();
+                return base.OnHover(e);
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                updateButtonVisibility();
+                base.OnHoverLost(e);
+            }
+
+            protected override void OnSelectChange()
+            {
+                base.OnSelectChange();
+                updateButtonVisibility();
+            }
+
+            private void updateButtonVisibility()
+            {
+                if (collection == null)
+                    addOrRemoveButton.Alpha = 0;
+                else
+                    addOrRemoveButton.Alpha = IsHovered || IsPreSelected || beatmapInCollection ? 1 : 0;
+            }
+
+            private void addOrRemove()
+            {
+                Debug.Assert(collection != null);
+
+                collection.PerformWrite(c =>
+                {
+                    if (!c.BeatmapMD5Hashes.Remove(beatmap.Value.BeatmapInfo.MD5Hash))
+                        c.BeatmapMD5Hashes.Add(beatmap.Value.BeatmapInfo.MD5Hash);
+                });
+            }
+
+            protected override Drawable CreateContent() => (Content)base.CreateContent();
+
+            private partial class NoFocusChangeIconButton : IconButton
+            {
+                public override bool ChangeFocusOnClick => false;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/SelectV2/Footer/BeatmapOptionsPopover.cs b/osu.Game/Screens/SelectV2/Footer/BeatmapOptionsPopover.cs
deleted file mode 100644
index fb2e32dfdc..0000000000
--- a/osu.Game/Screens/SelectV2/Footer/BeatmapOptionsPopover.cs
+++ /dev/null
@@ -1,195 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.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.SelectV2.Footer
-{
-    public partial class BeatmapOptionsPopover : OsuPopover
-    {
-        private FillFlowContainer buttonFlow = null!;
-        private readonly ScreenFooterButtonOptions footerButton;
-
-        [Cached]
-        private readonly OverlayColourProvider colourProvider;
-
-        private WorkingBeatmap beatmapWhenOpening = null!;
-
-        [Resolved]
-        private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
-
-        public BeatmapOptionsPopover(ScreenFooterButtonOptions footerButton, OverlayColourProvider colourProvider)
-        {
-            this.footerButton = footerButton;
-            this.colourProvider = colourProvider;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(ManageCollectionsDialog? manageCollectionsDialog, 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, () => { }, colours.Red1); // songSelect?.DeleteBeatmap(beatmapWhenOpening.BeatmapSetInfo);
-
-            addHeader(SongSelectStrings.ForSelectedDifficulty, beatmapWhenOpening.BeatmapInfo.DifficultyName);
-            // TODO: make work, and make show "unplayed" or "played" based on status.
-            addButton(SongSelectStrings.MarkAsPlayed, FontAwesome.Regular.TimesCircle, null);
-            addButton(SongSelectStrings.ClearAllLocalScores, FontAwesome.Solid.Eraser, () => { }, colours.Red1); // songSelect?.ClearScores(beatmapWhenOpening.BeatmapInfo);
-
-            // if (songSelect != null && songSelect.AllowEditing)
-            addButton(SongSelectStrings.EditBeatmap, FontAwesome.Solid.PencilAlt, () => { }); // songSelect.Edit(beatmapWhenOpening.BeatmapInfo);
-
-            addButton(WebCommonStrings.ButtonsHide.ToSentence(), FontAwesome.Solid.Magic, () => beatmapManager?.Hide(beatmapWhenOpening.BeatmapInfo));
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            ScheduleAfterChildren(() => GetContainingFocusManager()!.ChangeFocus(this));
-
-            beatmap.BindValueChanged(_ => Hide());
-        }
-
-        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 = colourProvider.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);
-            footerButton.OverlayState.Value = state.NewValue;
-        }
-    }
-}
diff --git a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonMods.cs b/osu.Game/Screens/SelectV2/FooterButtonMods.cs
similarity index 96%
rename from osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonMods.cs
rename to osu.Game/Screens/SelectV2/FooterButtonMods.cs
index 869aef1470..833ea96139 100644
--- a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonMods.cs
+++ b/osu.Game/Screens/SelectV2/FooterButtonMods.cs
@@ -28,9 +28,9 @@ using osu.Game.Utils;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Screens.SelectV2.Footer
+namespace osu.Game.Screens.SelectV2
 {
-    public partial class ScreenFooterButtonMods : ScreenFooterButton, IHasCurrentValue<IReadOnlyList<Mod>>
+    public partial class FooterButtonMods : ScreenFooterButton, IHasCurrentValue<IReadOnlyList<Mod>>
     {
         private const float bar_height = 30f;
         private const float mod_display_portion = 0.65f;
@@ -58,7 +58,7 @@ namespace osu.Game.Screens.SelectV2.Footer
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
-        public ScreenFooterButtonMods(ModSelectOverlay overlay)
+        public FooterButtonMods(ModSelectOverlay overlay)
             : base(overlay)
         {
         }
@@ -78,7 +78,7 @@ namespace osu.Game.Screens.SelectV2.Footer
                     Y = -5f,
                     Depth = float.MaxValue,
                     Origin = Anchor.BottomLeft,
-                    Shear = BUTTON_SHEAR,
+                    Shear = OsuGame.SHEAR,
                     CornerRadius = CORNER_RADIUS,
                     Size = new Vector2(BUTTON_WIDTH, bar_height),
                     Masking = true,
@@ -108,7 +108,7 @@ namespace osu.Game.Screens.SelectV2.Footer
                             {
                                 Anchor = Anchor.Centre,
                                 Origin = Anchor.Centre,
-                                Shear = -BUTTON_SHEAR,
+                                Shear = -OsuGame.SHEAR,
                                 UseFullGlyphHeight = false,
                                 Font = OsuFont.Torus.With(size: 14f, weight: FontWeight.Bold)
                             }
@@ -130,7 +130,7 @@ namespace osu.Game.Screens.SelectV2.Footer
                                 {
                                     Anchor = Anchor.Centre,
                                     Origin = Anchor.Centre,
-                                    Shear = -BUTTON_SHEAR,
+                                    Shear = -OsuGame.SHEAR,
                                     Scale = new Vector2(0.5f),
                                     Current = { BindTarget = Current },
                                     ExpansionMode = ExpansionMode.AlwaysContracted,
@@ -139,7 +139,7 @@ namespace osu.Game.Screens.SelectV2.Footer
                                 {
                                     Anchor = Anchor.Centre,
                                     Origin = Anchor.Centre,
-                                    Shear = -BUTTON_SHEAR,
+                                    Shear = -OsuGame.SHEAR,
                                     Font = OsuFont.Torus.With(size: 14f, weight: FontWeight.Bold),
                                     Mods = { BindTarget = Current },
                                 }
@@ -305,7 +305,7 @@ namespace osu.Game.Screens.SelectV2.Footer
                 Y = -5f;
                 Depth = float.MaxValue;
                 Origin = Anchor.BottomLeft;
-                Shear = BUTTON_SHEAR;
+                Shear = OsuGame.SHEAR;
                 CornerRadius = CORNER_RADIUS;
                 AutoSizeAxes = Axes.X;
                 Height = bar_height;
@@ -329,7 +329,7 @@ namespace osu.Game.Screens.SelectV2.Footer
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        Shear = -BUTTON_SHEAR,
+                        Shear = -OsuGame.SHEAR,
                         Text = ModSelectOverlayStrings.Unranked.ToUpper(),
                         Margin = new MarginPadding { Horizontal = 15 },
                         UseFullGlyphHeight = false,
diff --git a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonOptions.cs b/osu.Game/Screens/SelectV2/FooterButtonOptions.cs
similarity index 76%
rename from osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonOptions.cs
rename to osu.Game/Screens/SelectV2/FooterButtonOptions.cs
index 72409b5566..41edaf2a02 100644
--- a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonOptions.cs
+++ b/osu.Game/Screens/SelectV2/FooterButtonOptions.cs
@@ -5,15 +5,14 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics;
 using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
 using osu.Game.Screens.Footer;
 
-namespace osu.Game.Screens.SelectV2.Footer
+namespace osu.Game.Screens.SelectV2
 {
-    public partial class ScreenFooterButtonOptions : ScreenFooterButton, IHasPopover
+    public partial class FooterButtonOptions : ScreenFooterButton, IHasPopover
     {
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
@@ -29,6 +28,6 @@ namespace osu.Game.Screens.SelectV2.Footer
             Action = this.ShowPopover;
         }
 
-        public Popover GetPopover() => new BeatmapOptionsPopover(this, colourProvider);
+        public Framework.Graphics.UserInterface.Popover GetPopover() => new Popover(this, colourProvider);
     }
 }
diff --git a/osu.Game/Screens/SelectV2/FooterButtonOptions_Popover.cs b/osu.Game/Screens/SelectV2/FooterButtonOptions_Popover.cs
new file mode 100644
index 0000000000..76b841ee99
--- /dev/null
+++ b/osu.Game/Screens/SelectV2/FooterButtonOptions_Popover.cs
@@ -0,0 +1,198 @@
+// 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.SelectV2
+{
+    public partial class FooterButtonOptions
+    {
+        public partial class Popover : OsuPopover
+        {
+            private FillFlowContainer buttonFlow = null!;
+            private readonly FooterButtonOptions footerButton;
+
+            [Cached]
+            private readonly OverlayColourProvider colourProvider;
+
+            private WorkingBeatmap beatmapWhenOpening = null!;
+
+            [Resolved]
+            private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
+
+            public Popover(FooterButtonOptions footerButton, OverlayColourProvider colourProvider)
+            {
+                this.footerButton = footerButton;
+                this.colourProvider = colourProvider;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(ManageCollectionsDialog? manageCollectionsDialog, 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, () => { }, colours.Red1); // songSelect?.DeleteBeatmap(beatmapWhenOpening.BeatmapSetInfo);
+
+                addHeader(SongSelectStrings.ForSelectedDifficulty, beatmapWhenOpening.BeatmapInfo.DifficultyName);
+                // TODO: make work, and make show "unplayed" or "played" based on status.
+                addButton(SongSelectStrings.MarkAsPlayed, FontAwesome.Regular.TimesCircle, null);
+                addButton(SongSelectStrings.ClearAllLocalScores, FontAwesome.Solid.Eraser, () => { }, colours.Red1); // songSelect?.ClearScores(beatmapWhenOpening.BeatmapInfo);
+
+                // if (songSelect != null && songSelect.AllowEditing)
+                addButton(SongSelectStrings.EditBeatmap, FontAwesome.Solid.PencilAlt, () => { }); // songSelect.Edit(beatmapWhenOpening.BeatmapInfo);
+
+                addButton(WebCommonStrings.ButtonsHide.ToSentence(), FontAwesome.Solid.Magic, () => beatmapManager?.Hide(beatmapWhenOpening.BeatmapInfo));
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                ScheduleAfterChildren(() => GetContainingFocusManager()!.ChangeFocus(this));
+
+                beatmap.BindValueChanged(_ => Hide());
+            }
+
+            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 = colourProvider.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);
+                footerButton.OverlayState.Value = state.NewValue;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonRandom.cs b/osu.Game/Screens/SelectV2/FooterButtonRandom.cs
similarity index 97%
rename from osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonRandom.cs
rename to osu.Game/Screens/SelectV2/FooterButtonRandom.cs
index dbdb6fe79b..88b139da97 100644
--- a/osu.Game/Screens/SelectV2/Footer/ScreenFooterButtonRandom.cs
+++ b/osu.Game/Screens/SelectV2/FooterButtonRandom.cs
@@ -14,9 +14,9 @@ using osu.Game.Screens.Footer;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Screens.SelectV2.Footer
+namespace osu.Game.Screens.SelectV2
 {
-    public partial class ScreenFooterButtonRandom : ScreenFooterButton
+    public partial class FooterButtonRandom : ScreenFooterButton
     {
         public Action? NextRandom { get; set; }
         public Action? PreviousRandom { get; set; }
diff --git a/osu.Game/Screens/SelectV2/PanelBase.cs b/osu.Game/Screens/SelectV2/Panel.cs
similarity index 98%
rename from osu.Game/Screens/SelectV2/PanelBase.cs
rename to osu.Game/Screens/SelectV2/Panel.cs
index 05a1a55c03..c22a88a55f 100644
--- a/osu.Game/Screens/SelectV2/PanelBase.cs
+++ b/osu.Game/Screens/SelectV2/Panel.cs
@@ -12,6 +12,7 @@ using osu.Framework.Graphics.Pooling;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osuTK;
@@ -19,7 +20,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public abstract partial class PanelBase : PoolableDrawable, ICarouselPanel
+    public abstract partial class Panel : PoolableDrawable, ICarouselPanel
     {
         private const float corner_radius = 10;
 
@@ -159,7 +160,7 @@ namespace osu.Game.Screens.SelectV2
                     keyboardSelectionLayer = new Box
                     {
                         Alpha = 0,
-                        Colour = colours.Yellow.Opacity(0.1f),
+                        Colour = colourProvider.Highlight1.Opacity(0.1f),
                         Blending = BlendingParameters.Additive,
                         RelativeSizeAxes = Axes.Both,
                     },
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmap.cs b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
index d4bf3519fa..c8ae443364 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmap.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
@@ -22,7 +23,7 @@ using osuTK;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public partial class PanelBeatmap : PanelBase
+    public partial class PanelBeatmap : Panel
     {
         public const float HEIGHT = CarouselItem.DEFAULT_HEIGHT;
 
@@ -30,7 +31,7 @@ namespace osu.Game.Screens.SelectV2
         private ConstrainedIconContainer difficultyIcon = null!;
         private OsuSpriteText keyCountText = null!;
         private StarRatingDisplay starRatingDisplay = null!;
-        private TopLocalRank difficultyRank = null!;
+        private PanelLocalRankDisplay localRank = null!;
         private OsuSpriteText difficultyText = null!;
         private OsuSpriteText authorText = null!;
 
@@ -72,7 +73,7 @@ namespace osu.Game.Screens.SelectV2
 
             Icon = difficultyIcon = new ConstrainedIconContainer
             {
-                Size = new Vector2(20),
+                Size = new Vector2(16f),
                 Margin = new MarginPadding { Horizontal = 5f },
                 Colour = colourProvider.Background5,
             };
@@ -99,12 +100,13 @@ namespace osu.Game.Screens.SelectV2
                                 {
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
+                                    Scale = new Vector2(0.875f),
                                 },
-                                difficultyRank = new TopLocalRank
+                                localRank = new PanelLocalRankDisplay
                                 {
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
-                                    Scale = new Vector2(0.75f)
+                                    Scale = new Vector2(0.65f)
                                 },
                                 starCounter = new StarCounter
                                 {
@@ -122,22 +124,22 @@ namespace osu.Game.Screens.SelectV2
                             {
                                 keyCountText = new OsuSpriteText
                                 {
-                                    Font = OsuFont.GetFont(size: 18, weight: FontWeight.SemiBold),
+                                    Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
                                     Anchor = Anchor.BottomLeft,
                                     Origin = Anchor.BottomLeft,
                                     Alpha = 0,
                                 },
                                 difficultyText = new OsuSpriteText
                                 {
-                                    Font = OsuFont.GetFont(size: 18, weight: FontWeight.SemiBold),
+                                    Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
                                     Anchor = Anchor.BottomLeft,
                                     Origin = Anchor.BottomLeft,
-                                    Margin = new MarginPadding { Right = 8f },
+                                    Margin = new MarginPadding { Right = 5f },
                                 },
                                 authorText = new OsuSpriteText
                                 {
                                     Colour = colourProvider.Content2,
-                                    Font = OsuFont.GetFont(weight: FontWeight.SemiBold),
+                                    Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
                                     Anchor = Anchor.BottomLeft,
                                     Origin = Anchor.BottomLeft
                                 }
@@ -174,7 +176,7 @@ namespace osu.Game.Screens.SelectV2
 
             difficultyIcon.Icon = beatmap.Ruleset.CreateInstance().CreateIcon();
 
-            difficultyRank.Beatmap = beatmap;
+            localRank.Beatmap = beatmap;
             difficultyText.Text = beatmap.DifficultyName;
             authorText.Text = BeatmapsetsStrings.ShowDetailsMappedBy(beatmap.Metadata.Author.Username);
 
@@ -186,7 +188,7 @@ namespace osu.Game.Screens.SelectV2
         {
             base.FreeAfterUse();
 
-            difficultyRank.Beatmap = null;
+            localRank.Beatmap = null;
             starDifficultyBindable = null;
         }
 
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
index c599c3e534..7f5aa6ffe8 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
@@ -11,22 +11,23 @@ using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
 using osuTK;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public partial class PanelBeatmapSet : PanelBase
+    public partial class PanelBeatmapSet : Panel
     {
-        public const float HEIGHT = CarouselItem.DEFAULT_HEIGHT * 1.6f;
+        public const float HEIGHT = CarouselItem.DEFAULT_HEIGHT * 1.7f;
 
-        private BeatmapSetPanelBackground background = null!;
+        private PanelSetBackground background = null!;
 
         private OsuSpriteText titleText = null!;
         private OsuSpriteText artistText = null!;
         private Drawable chevronIcon = null!;
-        private UpdateBeatmapSetButton updateButton = null!;
+        private PanelUpdateBeatmapButton updateButton = null!;
         private BeatmapSetOnlineStatusPill statusPill = null!;
         private DifficultySpectrumDisplay difficultiesDisplay = null!;
 
@@ -54,13 +55,13 @@ namespace osu.Game.Screens.SelectV2
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Icon = FontAwesome.Solid.ChevronRight,
-                    Size = new Vector2(12),
+                    Size = new Vector2(8),
                     X = 1f,
                     Colour = colourProvider.Background5,
                 },
             };
 
-            Background = background = new BeatmapSetPanelBackground
+            Background = background = new PanelSetBackground
             {
                 RelativeSizeAxes = Axes.Both,
             };
@@ -76,20 +77,20 @@ namespace osu.Game.Screens.SelectV2
                     {
                         titleText = new OsuSpriteText
                         {
-                            Font = OsuFont.GetFont(weight: FontWeight.Bold, size: 22, italics: true),
+                            Font = OsuFont.Style.Heading1.With(typeface: Typeface.TorusAlternate),
                         },
                         artistText = new OsuSpriteText
                         {
-                            Font = OsuFont.GetFont(weight: FontWeight.SemiBold, size: 17, italics: true),
+                            Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
                         },
                         new FillFlowContainer
                         {
                             Direction = FillDirection.Horizontal,
                             AutoSizeAxes = Axes.Both,
-                            Margin = new MarginPadding { Top = 5f },
+                            Margin = new MarginPadding { Top = 4f },
                             Children = new Drawable[]
                             {
-                                updateButton = new UpdateBeatmapSetButton
+                                updateButton = new PanelUpdateBeatmapButton
                                 {
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
@@ -97,11 +98,9 @@ namespace osu.Game.Screens.SelectV2
                                 },
                                 statusPill = new BeatmapSetOnlineStatusPill
                                 {
-                                    AutoSizeAxes = Axes.Both,
                                     Origin = Anchor.CentreLeft,
                                     Anchor = Anchor.CentreLeft,
-                                    TextSize = 11,
-                                    TextPadding = new MarginPadding { Horizontal = 8, Vertical = 2 },
+                                    TextSize = OsuFont.Style.Caption2.Size,
                                     Margin = new MarginPadding { Right = 5f },
                                 },
                                 difficultiesDisplay = new DifficultySpectrumDisplay
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
index 948311a86e..a90a84d115 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
@@ -13,6 +13,7 @@ using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
@@ -23,9 +24,9 @@ using osuTK;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public partial class PanelBeatmapStandalone : PanelBase
+    public partial class PanelBeatmapStandalone : Panel
     {
-        public const float HEIGHT = CarouselItem.DEFAULT_HEIGHT * 1.6f;
+        public const float HEIGHT = CarouselItem.DEFAULT_HEIGHT * 1.7f;
 
         [Resolved]
         private IBindable<RulesetInfo> ruleset { get; set; } = null!;
@@ -48,17 +49,17 @@ namespace osu.Game.Screens.SelectV2
         private IBindable<StarDifficulty?>? starDifficultyBindable;
         private CancellationTokenSource? starDifficultyCancellationSource;
 
-        private BeatmapSetPanelBackground background = null!;
+        private PanelSetBackground background = null!;
 
         private OsuSpriteText titleText = null!;
         private OsuSpriteText artistText = null!;
-        private UpdateBeatmapSetButton updateButton = null!;
+        private PanelUpdateBeatmapButton updateButton = null!;
         private BeatmapSetOnlineStatusPill statusPill = null!;
 
         private ConstrainedIconContainer difficultyIcon = null!;
         private FillFlowContainer difficultyLine = null!;
         private StarRatingDisplay difficultyStarRating = null!;
-        private TopLocalRank difficultyRank = null!;
+        private PanelLocalRankDisplay difficultyRank = null!;
         private OsuSpriteText difficultyKeyCountText = null!;
         private OsuSpriteText difficultyName = null!;
         private OsuSpriteText difficultyAuthor = null!;
@@ -75,12 +76,12 @@ namespace osu.Game.Screens.SelectV2
 
             Icon = difficultyIcon = new ConstrainedIconContainer
             {
-                Size = new Vector2(20),
+                Size = new Vector2(16),
                 Margin = new MarginPadding { Horizontal = 5f },
                 Colour = colourProvider.Background5,
             };
 
-            Background = background = new BeatmapSetPanelBackground
+            Background = background = new PanelSetBackground
             {
                 RelativeSizeAxes = Axes.Both,
             };
@@ -94,22 +95,19 @@ namespace osu.Game.Screens.SelectV2
                 {
                     titleText = new OsuSpriteText
                     {
-                        Font = OsuFont.GetFont(weight: FontWeight.Bold, size: 22, italics: true),
-                        Shadow = true,
+                        Font = OsuFont.Style.Heading1.With(typeface: Typeface.TorusAlternate),
                     },
                     artistText = new OsuSpriteText
                     {
-                        Font = OsuFont.GetFont(weight: FontWeight.SemiBold, size: 17, italics: true),
-                        Shadow = true,
+                        Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
                     },
                     new FillFlowContainer
                     {
                         Direction = FillDirection.Horizontal,
                         AutoSizeAxes = Axes.Both,
-                        Margin = new MarginPadding { Top = 5f },
                         Children = new Drawable[]
                         {
-                            updateButton = new UpdateBeatmapSetButton
+                            updateButton = new PanelUpdateBeatmapButton
                             {
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
@@ -117,11 +115,9 @@ namespace osu.Game.Screens.SelectV2
                             },
                             statusPill = new BeatmapSetOnlineStatusPill
                             {
-                                AutoSizeAxes = Axes.Both,
                                 Origin = Anchor.CentreLeft,
                                 Anchor = Anchor.CentreLeft,
-                                TextSize = 11,
-                                TextPadding = new MarginPadding { Horizontal = 8, Vertical = 2 },
+                                TextSize = OsuFont.Style.Caption2.Size,
                                 Margin = new MarginPadding { Right = 5f },
                             },
                             difficultyLine = new FillFlowContainer
@@ -134,19 +130,19 @@ namespace osu.Game.Screens.SelectV2
                                     {
                                         Origin = Anchor.CentreLeft,
                                         Anchor = Anchor.CentreLeft,
-                                        Scale = new Vector2(8f / 9f),
+                                        Scale = new Vector2(0.875f),
                                         Margin = new MarginPadding { Right = 5f },
                                     },
-                                    difficultyRank = new TopLocalRank
+                                    difficultyRank = new PanelLocalRankDisplay
                                     {
-                                        Scale = new Vector2(8f / 11),
+                                        Scale = new Vector2(0.65f),
                                         Origin = Anchor.CentreLeft,
                                         Anchor = Anchor.CentreLeft,
                                         Margin = new MarginPadding { Right = 5f },
                                     },
                                     difficultyKeyCountText = new OsuSpriteText
                                     {
-                                        Font = OsuFont.GetFont(size: 18, weight: FontWeight.SemiBold),
+                                        Font = OsuFont.Style.Heading2,
                                         Anchor = Anchor.BottomLeft,
                                         Origin = Anchor.BottomLeft,
                                         Alpha = 0,
@@ -154,7 +150,7 @@ namespace osu.Game.Screens.SelectV2
                                     },
                                     difficultyName = new OsuSpriteText
                                     {
-                                        Font = OsuFont.GetFont(size: 18, weight: FontWeight.SemiBold),
+                                        Font = OsuFont.Style.Heading2,
                                         Origin = Anchor.BottomLeft,
                                         Anchor = Anchor.BottomLeft,
                                         Margin = new MarginPadding { Right = 5f, Bottom = 2f },
@@ -162,7 +158,7 @@ namespace osu.Game.Screens.SelectV2
                                     difficultyAuthor = new OsuSpriteText
                                     {
                                         Colour = colourProvider.Content2,
-                                        Font = OsuFont.GetFont(weight: FontWeight.SemiBold),
+                                        Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold),
                                         Origin = Anchor.BottomLeft,
                                         Anchor = Anchor.BottomLeft,
                                         Margin = new MarginPadding { Right = 5f, Bottom = 2f },
diff --git a/osu.Game/Screens/SelectV2/PanelGroup.cs b/osu.Game/Screens/SelectV2/PanelGroup.cs
index ecb64f4797..4370146dbc 100644
--- a/osu.Game/Screens/SelectV2/PanelGroup.cs
+++ b/osu.Game/Screens/SelectV2/PanelGroup.cs
@@ -5,10 +5,13 @@ using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Backgrounds;
+using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
 using osuTK;
@@ -16,31 +19,61 @@ using osuTK.Graphics;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public partial class PanelGroup : PanelBase
+    public partial class PanelGroup : Panel
     {
-        public const float HEIGHT = CarouselItem.DEFAULT_HEIGHT;
+        public const float HEIGHT = CarouselItem.DEFAULT_HEIGHT * 1.2f;
 
-        private Drawable chevronIcon = null!;
+        private Drawable iconContainer = null!;
         private OsuSpriteText titleText = null!;
+        private TrianglesV2 triangles = null!;
+        private OsuSpriteText countText = null!;
+        private Box glow = null!;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
 
         [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colourProvider)
+        private void load()
         {
             Height = HEIGHT;
 
-            Icon = chevronIcon = new SpriteIcon
+            Icon = iconContainer = new Container
             {
                 AlwaysPresent = true,
-                Icon = FontAwesome.Solid.ChevronDown,
-                Size = new Vector2(12),
-                Margin = new MarginPadding { Horizontal = 5f },
-                X = 2f,
-                Colour = colourProvider.Background3,
+                RelativeSizeAxes = Axes.Y,
+                Child = new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Icon = FontAwesome.Solid.ChevronDown,
+                    Size = new Vector2(12),
+                    Colour = colourProvider.Background3,
+                },
             };
-            Background = new Box
+            Background = new Container
             {
                 RelativeSizeAxes = Axes.Both,
-                Colour = colourProvider.Dark1,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colourProvider.Background5,
+                    },
+                    triangles = new TrianglesV2
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Thickness = 0.02f,
+                        SpawnRatio = 0.6f,
+                        Colour = ColourInfo.GradientHorizontal(colourProvider.Background6, colourProvider.Background5)
+                    },
+                    glow = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                        Colour = ColourInfo.GradientHorizontal(colourProvider.Highlight1, colourProvider.Highlight1.Opacity(0f)),
+                    },
+                },
             };
             AccentColour = colourProvider.Highlight1;
             Content.Children = new Drawable[]
@@ -49,6 +82,8 @@ namespace osu.Game.Screens.SelectV2
                 {
                     Anchor = Anchor.CentreLeft,
                     Origin = Anchor.CentreLeft,
+                    Font = OsuFont.Style.Heading2,
+                    UseFullGlyphHeight = false,
                     X = 10f,
                 },
                 new CircularContainer
@@ -65,17 +100,15 @@ namespace osu.Game.Screens.SelectV2
                             RelativeSizeAxes = Axes.Both,
                             Colour = Color4.Black.Opacity(0.7f),
                         },
-                        new OsuSpriteText
+                        countText = new OsuSpriteText
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
-                            Font = OsuFont.Torus.With(size: 14.4f, weight: FontWeight.Bold),
-                            // TODO: requires Carousel/CarouselItem-side implementation
-                            Text = "43",
+                            Font = OsuFont.Style.Caption1.With(weight: FontWeight.Bold),
                             UseFullGlyphHeight = false,
                         }
                     },
-                }
+                },
             };
         }
 
@@ -90,8 +123,15 @@ namespace osu.Game.Screens.SelectV2
         {
             const float duration = 500;
 
-            chevronIcon.ResizeWidthTo(Expanded.Value ? 12f : 0f, duration, Easing.OutQuint);
-            chevronIcon.FadeTo(Expanded.Value ? 1f : 0f, duration, Easing.OutQuint);
+            iconContainer.ResizeWidthTo(Expanded.Value ? 20f : 5f, duration, Easing.OutQuint);
+            iconContainer.FadeTo(Expanded.Value ? 1f : 0f, duration, Easing.OutQuint);
+
+            ColourInfo colour = Expanded.Value
+                ? ColourInfo.GradientHorizontal(colourProvider.Highlight1.Opacity(0.25f), colourProvider.Highlight1.Opacity(0f))
+                : ColourInfo.GradientHorizontal(colourProvider.Background6, colourProvider.Background5);
+
+            triangles.FadeColour(colour, duration, Easing.OutQuint);
+            glow.FadeTo(Expanded.Value ? 0.4f : 0, duration, Easing.OutQuint);
         }
 
         protected override void PrepareForUse()
@@ -103,6 +143,7 @@ namespace osu.Game.Screens.SelectV2
             GroupDefinition group = (GroupDefinition)Item.Model;
 
             titleText.Text = group.Title;
+            countText.Text = Item.NestedItemCount.ToString("N0");
         }
     }
 }
diff --git a/osu.Game/Screens/SelectV2/PanelGroupStarDifficulty.cs b/osu.Game/Screens/SelectV2/PanelGroupStarDifficulty.cs
index 0dc5a2f365..4ef3bd724c 100644
--- a/osu.Game/Screens/SelectV2/PanelGroupStarDifficulty.cs
+++ b/osu.Game/Screens/SelectV2/PanelGroupStarDifficulty.cs
@@ -5,21 +5,20 @@ using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public partial class PanelGroupStarDifficulty : PanelBase
+    public partial class PanelGroupStarDifficulty : Panel
     {
         [Resolved]
         private OsuColour colours { get; set; } = null!;
@@ -27,28 +26,50 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
-        private Drawable chevronIcon = null!;
+        private Drawable iconContainer = null!;
         private Box contentBackground = null!;
-        private StarRatingDisplay starRatingDisplay = null!;
-        private StarCounter starCounter = null!;
+        private OsuSpriteText starRatingText = null!;
+        private TrianglesV2 triangles = null!;
+        private Box glow = null!;
 
         [BackgroundDependencyLoader]
         private void load()
         {
             Height = PanelGroup.HEIGHT;
 
-            Icon = chevronIcon = new SpriteIcon
+            Icon = iconContainer = new Container
             {
                 AlwaysPresent = true,
-                Icon = FontAwesome.Solid.ChevronDown,
-                Size = new Vector2(12),
-                Margin = new MarginPadding { Horizontal = 5f },
-                X = 2f,
+                RelativeSizeAxes = Axes.Y,
+                Child = new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Icon = FontAwesome.Solid.ChevronDown,
+                    Size = new Vector2(12),
+                },
             };
-            Background = contentBackground = new Box
+            Background = new Container
             {
                 RelativeSizeAxes = Axes.Both,
-                Colour = colourProvider.Dark1,
+                Children = new Drawable[]
+                {
+                    contentBackground = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    triangles = new TrianglesV2
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Thickness = 0.02f,
+                        SpawnRatio = 0.6f,
+                    },
+                    glow = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.5f,
+                    },
+                },
             };
             AccentColour = colourProvider.Highlight1;
             Content.Children = new Drawable[]
@@ -62,17 +83,13 @@ namespace osu.Game.Screens.SelectV2
                     Margin = new MarginPadding { Left = 10f },
                     Children = new Drawable[]
                     {
-                        starRatingDisplay = new StarRatingDisplay(default, StarRatingDisplaySize.Small)
+                        starRatingText = new OsuSpriteText
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
-                        },
-                        starCounter = new StarCounter
-                        {
-                            Anchor = Anchor.CentreLeft,
-                            Origin = Anchor.CentreLeft,
-                            Scale = new Vector2(8f / 20f),
-                        },
+                            UseFullGlyphHeight = false,
+                            Font = OsuFont.Style.Heading2,
+                        }
                     }
                 },
                 new CircularContainer
@@ -93,7 +110,7 @@ namespace osu.Game.Screens.SelectV2
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
-                            Font = OsuFont.Torus.With(size: 14.4f, weight: FontWeight.Bold),
+                            Font = OsuFont.Style.Caption1.With(weight: FontWeight.Bold),
                             // TODO: requires Carousel/CarouselItem-side implementation
                             Text = "43",
                             UseFullGlyphHeight = false,
@@ -110,6 +127,8 @@ namespace osu.Game.Screens.SelectV2
             Expanded.BindValueChanged(_ => onExpanded(), true);
         }
 
+        private Color4 ratingColour;
+
         protected override void PrepareForUse()
         {
             base.PrepareForUse();
@@ -118,25 +137,50 @@ namespace osu.Game.Screens.SelectV2
 
             int starNumber = (int)((GroupDefinition)Item.Model).Data;
 
-            Color4 colour = starNumber >= 9 ? OsuColour.Gray(0.2f) : colours.ForStarDifficulty(starNumber);
-            Color4 contentColour = starNumber >= 7 ? colours.Orange1 : colourProvider.Background5;
+            ratingColour = starNumber >= 9 ? OsuColour.Gray(0.2f) : colours.ForStarDifficulty(starNumber);
 
-            AccentColour = colour;
-            contentBackground.Colour = colour.Darken(0.3f);
+            AccentColour = ratingColour;
+            contentBackground.Colour = ratingColour.Darken(1f);
+            glow.Colour = ColourInfo.GradientHorizontal(ratingColour, ratingColour.Opacity(0f));
 
-            starRatingDisplay.Current.Value = new StarDifficulty(starNumber, 0);
-            starCounter.Current = starNumber;
+            switch (starNumber)
+            {
+                case 0:
+                    starRatingText.Text = @"Below 1 Star";
+                    break;
 
-            chevronIcon.Colour = contentColour;
-            starCounter.Colour = contentColour;
+                case 1:
+                    starRatingText.Text = @"1 Star";
+                    break;
+
+                default:
+                    starRatingText.Text = $"{starNumber} Stars";
+                    break;
+            }
+
+            iconContainer.Colour = starNumber >= 7 ? colourProvider.Content1 : colourProvider.Background5;
+            starRatingText.Colour = colourProvider.Content1;
+
+            ColourInfo colour;
+
+            if (starNumber >= 8)
+                colour = ColourInfo.GradientHorizontal(ratingColour, ratingColour.Darken(0.2f));
+            else
+                colour = ColourInfo.GradientHorizontal(ratingColour.Darken(0.6f), ratingColour.Darken(0.8f));
+
+            triangles.Colour = colour;
+
+            onExpanded();
         }
 
         private void onExpanded()
         {
             const float duration = 500;
 
-            chevronIcon.ResizeWidthTo(Expanded.Value ? 12f : 0f, duration, Easing.OutQuint);
-            chevronIcon.FadeTo(Expanded.Value ? 1f : 0f, duration, Easing.OutQuint);
+            iconContainer.ResizeWidthTo(Expanded.Value ? 20f : 5f, duration, Easing.OutQuint);
+            iconContainer.FadeTo(Expanded.Value ? 1f : 0f, duration, Easing.OutQuint);
+
+            glow.FadeTo(Expanded.Value ? 0.4f : 0, duration, Easing.OutQuint);
         }
     }
 }
diff --git a/osu.Game/Screens/SelectV2/TopLocalRank.cs b/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs
similarity index 96%
rename from osu.Game/Screens/SelectV2/TopLocalRank.cs
rename to osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs
index 2a72a05db7..588e7e650e 100644
--- a/osu.Game/Screens/SelectV2/TopLocalRank.cs
+++ b/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs
@@ -19,7 +19,7 @@ using Realms;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public partial class TopLocalRank : CompositeDrawable
+    public partial class PanelLocalRankDisplay : CompositeDrawable
     {
         private BeatmapInfo? beatmap;
 
@@ -48,7 +48,7 @@ namespace osu.Game.Screens.SelectV2
 
         private readonly UpdateableRank updateable;
 
-        public TopLocalRank(BeatmapInfo? beatmap = null)
+        public PanelLocalRankDisplay(BeatmapInfo? beatmap = null)
         {
             AutoSizeAxes = Axes.Both;
 
diff --git a/osu.Game/Screens/SelectV2/BeatmapSetPanelBackground.cs b/osu.Game/Screens/SelectV2/PanelSetBackground.cs
similarity index 97%
rename from osu.Game/Screens/SelectV2/BeatmapSetPanelBackground.cs
rename to osu.Game/Screens/SelectV2/PanelSetBackground.cs
index 798acf62ee..99dbf90556 100644
--- a/osu.Game/Screens/SelectV2/BeatmapSetPanelBackground.cs
+++ b/osu.Game/Screens/SelectV2/PanelSetBackground.cs
@@ -14,7 +14,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public partial class BeatmapSetPanelBackground : ModelBackedDrawable<WorkingBeatmap>
+    public partial class PanelSetBackground : ModelBackedDrawable<WorkingBeatmap>
     {
         protected override double TransformDuration => 400;
 
diff --git a/osu.Game/Screens/SelectV2/UpdateBeatmapSetButton.cs b/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs
similarity index 93%
rename from osu.Game/Screens/SelectV2/UpdateBeatmapSetButton.cs
rename to osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs
index e2c841f88a..4c767df9d8 100644
--- a/osu.Game/Screens/SelectV2/UpdateBeatmapSetButton.cs
+++ b/osu.Game/Screens/SelectV2/PanelUpdateBeatmapButton.cs
@@ -22,7 +22,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Screens.SelectV2
 {
-    public partial class UpdateBeatmapSetButton : OsuAnimatedButton
+    public partial class PanelUpdateBeatmapButton : OsuAnimatedButton
     {
         private BeatmapSetInfo? beatmapSet;
 
@@ -53,9 +53,9 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private IDialogOverlay? dialogOverlay { get; set; }
 
-        public UpdateBeatmapSetButton()
+        public PanelUpdateBeatmapButton()
         {
-            Size = new Vector2(75f, 22f);
+            Size = new Vector2(72, 22f);
         }
 
         private Bindable<bool> preferNoVideo = null!;
@@ -63,13 +63,13 @@ namespace osu.Game.Screens.SelectV2
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
-            const float icon_size = 14;
+            const float icon_size = 12;
 
             preferNoVideo = config.GetBindable<bool>(OsuSetting.PreferNoVideo);
 
             Content.Anchor = Anchor.Centre;
             Content.Origin = Anchor.Centre;
-            Content.Shear = new Vector2(OsuGame.SHEAR, 0);
+            Content.Shear = OsuGame.SHEAR;
 
             Content.AddRange(new Drawable[]
             {
@@ -87,7 +87,7 @@ namespace osu.Game.Screens.SelectV2
                     AutoSizeAxes = Axes.Both,
                     Direction = FillDirection.Horizontal,
                     Spacing = new Vector2(4),
-                    Shear = new Vector2(-OsuGame.SHEAR, 0),
+                    Shear = -OsuGame.SHEAR,
                     Children = new Drawable[]
                     {
                         new Container
@@ -110,7 +110,7 @@ namespace osu.Game.Screens.SelectV2
                         {
                             Anchor = Anchor.CentreLeft,
                             Origin = Anchor.CentreLeft,
-                            Font = OsuFont.Default.With(weight: FontWeight.Bold),
+                            Font = OsuFont.Style.Body.With(weight: FontWeight.SemiBold),
                             Text = "Update",
                         }
                     }
diff --git a/osu.Game/Screens/SelectV2/SongSelect.cs b/osu.Game/Screens/SelectV2/SongSelect.cs
index e295656a21..ca09b2a40a 100644
--- a/osu.Game/Screens/SelectV2/SongSelect.cs
+++ b/osu.Game/Screens/SelectV2/SongSelect.cs
@@ -11,7 +11,6 @@ using osu.Game.Overlays.Mods;
 using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Select;
-using osu.Game.Screens.SelectV2.Footer;
 
 namespace osu.Game.Screens.SelectV2
 {
@@ -23,6 +22,10 @@ namespace osu.Game.Screens.SelectV2
     {
         private const float logo_scale = 0.4f;
 
+        public const float WEDGE_CONTENT_MARGIN = CORNER_RADIUS_HIDE_OFFSET + OsuGame.SCREEN_EDGE_MARGIN;
+        public const float CORNER_RADIUS_HIDE_OFFSET = 20f;
+        public const float ENTER_DURATION = 600;
+
         private readonly ModSelectOverlay modSelectOverlay = new ModSelectOverlay(OverlayColourScheme.Aquamarine)
         {
             ShowPresets = true,
@@ -77,9 +80,9 @@ namespace osu.Game.Screens.SelectV2
 
         public override IReadOnlyList<ScreenFooterButton> CreateFooterButtons() => new ScreenFooterButton[]
         {
-            new ScreenFooterButtonMods(modSelectOverlay) { Current = Mods },
-            new ScreenFooterButtonRandom(),
-            new ScreenFooterButtonOptions(),
+            new FooterButtonMods(modSelectOverlay) { Current = Mods },
+            new FooterButtonRandom(),
+            new FooterButtonOptions(),
         };
 
         protected override void LoadComplete()
diff --git a/osu.Game/Screens/SelectV2/Wedge/DifficultyNameContent.cs b/osu.Game/Screens/SelectV2/Wedge/DifficultyNameContent.cs
deleted file mode 100644
index 4a3dc34cf9..0000000000
--- a/osu.Game/Screens/SelectV2/Wedge/DifficultyNameContent.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Localisation;
-using osu.Game.Overlays;
-
-namespace osu.Game.Screens.SelectV2.Wedge
-{
-    public abstract partial class DifficultyNameContent : CompositeDrawable
-    {
-        protected OsuSpriteText DifficultyName = null!;
-        private OsuSpriteText mappedByLabel = null!;
-        protected OsuHoverContainer MapperLink = null!;
-        protected OsuSpriteText MapperName = null!;
-
-        protected DifficultyNameContent()
-        {
-            RelativeSizeAxes = Axes.X;
-            AutoSizeAxes = Axes.Y;
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            InternalChild = new FillFlowContainer
-            {
-                RelativeSizeAxes = Axes.X,
-                AutoSizeAxes = Axes.Y,
-                Direction = FillDirection.Horizontal,
-                Children = new Drawable[]
-                {
-                    DifficultyName = new TruncatingSpriteText
-                    {
-                        Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.BottomLeft,
-                        Font = OsuFont.GetFont(weight: FontWeight.SemiBold),
-                    },
-                    mappedByLabel = new OsuSpriteText
-                    {
-                        Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.BottomLeft,
-                        // TODO: better null display? beatmap carousel panels also just show this text currently.
-                        Text = " mapped by ",
-                        Font = OsuFont.GetFont(size: 14),
-                    },
-                    // This is not a `LinkFlowContainer` as there are single-frame layout issues when Update()
-                    // is being used for layout, see https://github.com/ppy/osu-framework/issues/3369.
-                    MapperLink = new MapperLinkContainer
-                    {
-                        Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.BottomLeft,
-                        AutoSizeAxes = Axes.Both,
-                        Child = MapperName = new OsuSpriteText
-                        {
-                            Font = OsuFont.GetFont(weight: FontWeight.SemiBold, size: 14),
-                        }
-                    },
-                }
-            };
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            // truncate difficulty name when width exceeds bounds, prioritizing mapper name display
-            DifficultyName.MaxWidth = Math.Max(DrawWidth - mappedByLabel.DrawWidth
-                                                         - MapperName.DrawWidth, 0);
-        }
-
-        private partial class MapperLinkContainer : OsuHoverContainer
-        {
-            [BackgroundDependencyLoader]
-            private void load(OverlayColourProvider? overlayColourProvider, OsuColour colours)
-            {
-                TooltipText = ContextMenuStrings.ViewProfile;
-                IdleColour = overlayColourProvider?.Light2 ?? colours.Blue;
-            }
-        }
-    }
-}
diff --git a/osu.Game/Screens/SelectV2/Wedge/LocalDifficultyNameContent.cs b/osu.Game/Screens/SelectV2/Wedge/LocalDifficultyNameContent.cs
deleted file mode 100644
index 66f8cb02b2..0000000000
--- a/osu.Game/Screens/SelectV2/Wedge/LocalDifficultyNameContent.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Game.Beatmaps;
-using osu.Game.Online;
-using osu.Game.Online.Chat;
-
-namespace osu.Game.Screens.SelectV2.Wedge
-{
-    public partial class LocalDifficultyNameContent : DifficultyNameContent
-    {
-        [Resolved]
-        private IBindable<WorkingBeatmap> beatmap { get; set; } = null!;
-
-        [Resolved]
-        private ILinkHandler? linkHandler { get; set; }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            beatmap.BindValueChanged(b =>
-            {
-                DifficultyName.Text = b.NewValue.BeatmapInfo.DifficultyName;
-
-                // TODO: should be the mapper of the guest difficulty, but that isn't stored correctly yet (see https://github.com/ppy/osu/issues/12965)
-                MapperName.Text = b.NewValue.Metadata.Author.Username;
-                MapperLink.Action = () => linkHandler?.HandleLink(new LinkDetails(LinkAction.OpenUserProfile, b.NewValue.Metadata.Author));
-            }, true);
-        }
-    }
-}
diff --git a/osu.Game/Screens/SelectV2/WedgeBackground.cs b/osu.Game/Screens/SelectV2/WedgeBackground.cs
new file mode 100644
index 0000000000..ecfbd51260
--- /dev/null
+++ b/osu.Game/Screens/SelectV2/WedgeBackground.cs
@@ -0,0 +1,54 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Overlays;
+
+namespace osu.Game.Screens.SelectV2
+{
+    internal partial class WedgeBackground : CompositeDrawable
+    {
+        public float StartAlpha { get; init; } = 0.9f;
+
+        public float FinalAlpha { get; init; } = 0.6f;
+
+        public float WidthForGradient { get; init; } = 0.3f;
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    Blending = BlendingParameters.Additive,
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 0.6f,
+                    Alpha = 0.5f,
+                    Colour = ColourInfo.GradientHorizontal(colourProvider.Background2, colourProvider.Background2.Opacity(0)),
+                },
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 1 - WidthForGradient,
+                    Colour = colourProvider.Background5.Opacity(StartAlpha),
+                },
+                new Box
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                    RelativeSizeAxes = Axes.Both,
+                    Width = WidthForGradient,
+                    Colour = ColourInfo.GradientHorizontal(colourProvider.Background5.Opacity(StartAlpha), colourProvider.Background5.Opacity(FinalAlpha)),
+                },
+            };
+        }
+    }
+}
diff --git a/osu.Game/Skinning/LegacyHealthDisplay.cs b/osu.Game/Skinning/LegacyHealthDisplay.cs
index 9c06cbbfb5..0d561d6c89 100644
--- a/osu.Game/Skinning/LegacyHealthDisplay.cs
+++ b/osu.Game/Skinning/LegacyHealthDisplay.cs
@@ -234,14 +234,14 @@ namespace osu.Game.Skinning
             {
                 Bulge();
                 explode.Blending = isEpic ? BlendingParameters.Additive : BlendingParameters.Inherit;
-                explode.ScaleTo(1).Then().ScaleTo(isEpic ? 2 : 1.6f, 120);
-                explode.FadeOutFromOne(120);
+                explode.ScaleTo(1).Then().ScaleTo(isEpic ? 2 : 1.6f, 120, Easing.Out);
+                explode.FadeOutFromOne(120, Easing.Out);
             }
 
             public override void Bulge()
             {
                 base.Bulge();
-                Main.ScaleTo(1.4f).Then().ScaleTo(1, 200, Easing.Out);
+                Main.ScaleTo(1.2f).Then().ScaleTo(0.8f, 150);
             }
         }
 
diff --git a/osu.Game/Storyboards/StoryboardSprite.cs b/osu.Game/Storyboards/StoryboardSprite.cs
index 42426c8c85..5b3e7c3919 100644
--- a/osu.Game/Storyboards/StoryboardSprite.cs
+++ b/osu.Game/Storyboards/StoryboardSprite.cs
@@ -17,42 +17,55 @@ namespace osu.Game.Storyboards
         private readonly List<StoryboardTriggerGroup> triggerGroups = new List<StoryboardTriggerGroup>();
 
         public string Path { get; }
-        public bool IsDrawable => HasCommands;
+        public virtual bool IsDrawable => HasCommands;
 
         public Anchor Origin;
         public Vector2 InitialPosition;
 
         public readonly StoryboardCommandGroup Commands = new StoryboardCommandGroup();
 
-        public double StartTime
+        public virtual double StartTime
         {
             get
             {
-                // To get the initial start time, we need to check whether the first alpha command to exist (across all loops) has a StartValue of zero.
-                // A StartValue of zero governs, above all else, the first valid display time of a sprite.
+                // Users that are crafting storyboards using raw osb scripting or external tools may create alpha events far before the actual display time
+                // of sprites.
                 //
-                // You can imagine that the first command of each type decides that type's start value, so if the initial alpha is zero,
-                // anything before that point can be ignored (the sprite is not visible after all).
-                var alphaCommands = new List<(double startTime, bool isZeroStartValue)>();
+                // To make sure lifetime optimisations work as efficiently as they can, let's locally find the first time a sprite becomes visible.
+                var alphaCommands = new List<StoryboardCommand<float>>();
 
-                var command = Commands.Alpha.FirstOrDefault();
-                if (command != null) alphaCommands.Add((command.StartTime, command.StartValue == 0));
+                foreach (var command in Commands.Alpha)
+                {
+                    alphaCommands.Add(command);
+                    if (visibleAtStartOrEnd(command))
+                        break;
+                }
 
                 foreach (var loop in loopingGroups)
                 {
-                    command = loop.Alpha.FirstOrDefault();
-                    if (command != null) alphaCommands.Add((command.StartTime, command.StartValue == 0));
+                    foreach (var command in loop.Alpha)
+                    {
+                        alphaCommands.Add(command);
+                        if (visibleAtStartOrEnd(command))
+                            break;
+                    }
                 }
 
                 if (alphaCommands.Count > 0)
                 {
-                    var firstAlpha = alphaCommands.MinBy(t => t.startTime);
+                    // Special care is given to cases where there's one or more no-op transforms (ie transforming from alpha 0 to alpha 0).
+                    // - If a 0->0 transform exists, we still need to check it to ensure the absolute first start value is non-visible.
+                    // - After ascertaining this, we then check the first non-noop transform to get the true start lifetime.
+                    var firstAlpha = alphaCommands.MinBy(c => c.StartTime);
+                    var firstRealAlpha = alphaCommands.Where(visibleAtStartOrEnd).MinBy(c => c.StartTime);
 
-                    if (firstAlpha.isZeroStartValue)
-                        return firstAlpha.startTime;
+                    if (firstAlpha!.StartValue == 0 && firstRealAlpha != null)
+                        return firstRealAlpha.StartTime;
                 }
 
                 return EarliestTransformTime;
+
+                bool visibleAtStartOrEnd(StoryboardCommand<float> command) => command.StartValue > 0 || command.EndValue > 0;
             }
         }
 
diff --git a/osu.Game/Storyboards/StoryboardVideo.cs b/osu.Game/Storyboards/StoryboardVideo.cs
index 14189a1a6c..5a9eb533c6 100644
--- a/osu.Game/Storyboards/StoryboardVideo.cs
+++ b/osu.Game/Storyboards/StoryboardVideo.cs
@@ -14,9 +14,13 @@ namespace osu.Game.Storyboards
         {
             // This is just required to get a valid StartTime based on the incoming offset.
             // Actual fades are handled inside DrawableStoryboardVideo for now.
-            Commands.AddAlpha(Easing.None, offset, offset, 0, 0);
+            StartTime = offset;
         }
 
+        public override double StartTime { get; }
+
+        public override bool IsDrawable => true;
+
         public override Drawable CreateDrawable() => new DrawableStoryboardVideo(this);
     }
 }
diff --git a/osu.Game/Tests/Beatmaps/TestBeatmap.cs b/osu.Game/Tests/Beatmaps/TestBeatmap.cs
index 1f0c08714e..caf99a4cf6 100644
--- a/osu.Game/Tests/Beatmaps/TestBeatmap.cs
+++ b/osu.Game/Tests/Beatmaps/TestBeatmap.cs
@@ -68,6 +68,7 @@ namespace osu.Game.Tests.Beatmaps
                     var b = Decoder.GetDecoder<Beatmap>(reader).Decode(reader);
 
                     b.BeatmapInfo.MD5Hash = test_beatmap_hash.Value.md5;
+                    b.BeatmapInfo.OnlineMD5Hash = test_beatmap_hash.Value.md5;
                     b.BeatmapInfo.Hash = test_beatmap_hash.Value.sha2;
 
                     return b;
diff --git a/osu.Game/Tests/Visual/LegacyReplayPlaybackTestScene.cs b/osu.Game/Tests/Visual/LegacyReplayPlaybackTestScene.cs
new file mode 100644
index 0000000000..5f973d1e4e
--- /dev/null
+++ b/osu.Game/Tests/Visual/LegacyReplayPlaybackTestScene.cs
@@ -0,0 +1,157 @@
+// 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.IO;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Formats;
+using osu.Game.IO.Legacy;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Scoring.Legacy;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual
+{
+    /// <summary>
+    /// The goal of this abstract test class is to exercise correct playback of replays sourced from previous osu! versions.
+    /// Use <see cref="RunTest"/> to exercise that property.
+    /// </summary>
+    [HeadlessTest]
+    [TestFixture]
+    public abstract partial class LegacyReplayPlaybackTestScene : RateAdjustedBeatmapTestScene
+    {
+        private ReplayPlayer currentPlayer = null!;
+        private readonly List<JudgementResult> results = new List<JudgementResult>();
+
+        /// <summary>
+        /// This is provided as a convenience for testing behaviour against osu!stable.
+        /// Setting this field to a non-null path will cause beatmap files and replays used in all test cases
+        /// to be exported to disk so that they can be cross-checked against stable.
+        /// </summary>
+        protected abstract string? ExportLocation { get; }
+
+        /// <summary>
+        /// Encodes the supplied <paramref name="originalScore"/>, decodes the result of encoding, runs the result of decoding against the supplied <paramref name="beatmap"/>,
+        /// and checks that the judgement results recorded still match <paramref name="expectedResults"/>.
+        /// If <see cref="ExportLocation"/> is set, exports both the beatmap and the replay to said location.
+        /// </summary>
+        protected void RunTest(string beatmapName, IBeatmap beatmap, string replayName, Score originalScore, IEnumerable<HitResult> expectedResults)
+        {
+            IBeatmap playableBeatmap = null!;
+            MemoryStream beatmapStream = new MemoryStream();
+            MemoryStream scoreStream = new MemoryStream();
+            Score decodedScore = null!;
+
+            AddStep(@"set up beatmap", () =>
+            {
+                beatmap.Metadata.Title = beatmapName;
+                Beatmap.Value = CreateWorkingBeatmap(beatmap);
+                Ruleset.Value = CreateRuleset()!.RulesetInfo;
+                playableBeatmap = Beatmap.Value.GetPlayableBeatmap(Ruleset.Value);
+
+                var beatmapEncoder = new LegacyBeatmapEncoder(beatmap, null);
+
+                using (var writer = new StreamWriter(beatmapStream, Encoding.UTF8, leaveOpen: true))
+                    beatmapEncoder.Encode(writer);
+
+                beatmapStream.Seek(0, SeekOrigin.Begin);
+                playableBeatmap.BeatmapInfo.MD5Hash = beatmapStream.ComputeMD5Hash();
+            });
+
+            AddStep(@"encode score", () =>
+            {
+                originalScore.ScoreInfo.BeatmapInfo = playableBeatmap.BeatmapInfo;
+                var encoder = new LegacyScoreEncoder(originalScore, playableBeatmap);
+                encoder.Encode(scoreStream, leaveOpen: true);
+
+                // `LegacyScoreEncoder` hardcodes a replay version that belongs to lazer.
+                // here we want to simulate a stable replay, which should have the classic mod attached etc.
+                // to that end, we do a post-encode step to specify a stable-like replay version.
+                scoreStream.Position = 1;
+
+                using (var sw = new SerializationWriter(scoreStream, leaveOpen: true))
+                {
+                    const int version = 20250414;
+                    sw.Write(version);
+                }
+
+                scoreStream.Position = 0;
+            });
+
+            if (ExportLocation != null)
+            {
+                AddStep("export beatmap", () =>
+                {
+                    using var stream = File.Open(Path.Combine(ExportLocation, $"{beatmapName}.osu"), FileMode.Create);
+                    beatmapStream.CopyTo(stream);
+                    beatmapStream.Position = 0;
+                });
+
+                AddStep("export score", () =>
+                {
+                    using var stream = File.Open(Path.Combine(ExportLocation, $@"{replayName}.osr"), FileMode.Create);
+                    scoreStream.CopyTo(stream);
+                    scoreStream.Position = 0;
+                });
+            }
+
+            AddStep(@"decode score", () =>
+            {
+                using (scoreStream)
+                {
+                    scoreStream.Position = 0;
+                    decodedScore = new TestScoreDecoder(Beatmap.Value, Ruleset.Value).Parse(scoreStream);
+                }
+            });
+
+            AddAssert(@"classic mod present", () => decodedScore.ScoreInfo.Mods.Any(mod => mod is ModClassic));
+            AddStep(@"push player", () => pushNewPlayer(decodedScore));
+
+            AddUntilStep(@"Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddAssert(@"classic mod present", () => currentPlayer.GameplayState.Mods.Any(mod => mod is ModClassic));
+            AddUntilStep(@"Wait for completion", () => currentPlayer.GameplayState.HasCompleted);
+            AddAssert(@"judgement results after encode are correct", () => results.Select(r => r.Type), () => Is.EquivalentTo(expectedResults));
+        }
+
+        private void pushNewPlayer(Score score)
+        {
+            var player = new ReplayPlayer(score);
+            SelectedMods.Value = score.ScoreInfo.Mods;
+            player.OnLoadComplete += _ =>
+            {
+                player.GameplayState.ScoreProcessor.NewJudgement += result =>
+                {
+                    if (currentPlayer == player)
+                        results.Add(result);
+                };
+            };
+            LoadScreen(currentPlayer = player);
+            results.Clear();
+        }
+
+        private class TestScoreDecoder : LegacyScoreDecoder
+        {
+            private readonly WorkingBeatmap beatmap;
+            private readonly Ruleset ruleset;
+
+            public TestScoreDecoder(WorkingBeatmap beatmap, RulesetInfo ruleset)
+            {
+                this.beatmap = beatmap;
+                this.ruleset = ruleset.CreateInstance();
+            }
+
+            protected override Ruleset GetRuleset(int rulesetId) => ruleset;
+            protected override WorkingBeatmap GetBeatmap(string md5Hash) => beatmap;
+        }
+    }
+}
diff --git a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
index bc73f853ec..3843460add 100644
--- a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
+++ b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
@@ -15,6 +15,7 @@ using osu.Game.Online;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.Countdown;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets.Mods;
@@ -70,6 +71,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private MultiplayerPlaylistItem? currentItem => ServerRoom?.Playlist[currentIndex];
         private int currentIndex;
         private long lastPlaylistItemId;
+        private int lastCountdownId;
 
         private readonly TestRoomRequestsHandler apiRequestHandler;
 
@@ -393,7 +395,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
             switch (request)
             {
                 case ChangeTeamRequest changeTeam:
-
                     TeamVersusRoomState roomState = (TeamVersusRoomState)ServerRoom.MatchState!;
                     TeamVersusUserState userState = (TeamVersusUserState)LocalUser.MatchState!;
 
@@ -402,11 +403,25 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     if (targetTeam != null)
                     {
                         userState.TeamID = targetTeam.ID;
-
                         await ((IMultiplayerClient)this).MatchUserStateChanged(clone(LocalUser.UserID), clone(userState)).ConfigureAwait(false);
                     }
 
                     break;
+
+                case StartMatchCountdownRequest startCountdown:
+                    ServerRoom.ActiveCountdowns.Add(new MatchStartCountdown
+                    {
+                        ID = ++lastCountdownId,
+                        TimeRemaining = startCountdown.Duration
+                    });
+
+                    await ((IMultiplayerClient)this).MatchEvent(clone(new CountdownStartedEvent(ServerRoom.ActiveCountdowns[^1]))).ConfigureAwait(false);
+                    break;
+
+                case StopCountdownRequest stopCountdown:
+                    ServerRoom.ActiveCountdowns.Remove(ServerRoom.ActiveCountdowns.First(c => c.ID == stopCountdown.ID));
+                    await ((IMultiplayerClient)this).MatchEvent(clone(new CountdownStoppedEvent(stopCountdown.ID))).ConfigureAwait(false);
+                    break;
             }
         }
 
diff --git a/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs b/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs
index 46c1251d42..08f61f3ddc 100644
--- a/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs
+++ b/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs
@@ -267,7 +267,7 @@ namespace osu.Game.Tests.Visual.OnlinePlay
         /// <param name="host">The room host.</param>
         public void AddServerSideRoom(Room room, APIUser host)
         {
-            room.RoomID ??= currentRoomId++;
+            room.RoomID = currentRoomId++;
             room.Host = host;
 
             for (int i = 0; i < room.Playlist.Count; i++)
diff --git a/osu.Game/Tests/Visual/ReplayStabilityTestScene.cs b/osu.Game/Tests/Visual/ReplayStabilityTestScene.cs
new file mode 100644
index 0000000000..13abedf611
--- /dev/null
+++ b/osu.Game/Tests/Visual/ReplayStabilityTestScene.cs
@@ -0,0 +1,106 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Replays;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Scoring.Legacy;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual
+{
+    /// <summary>
+    /// The goal of this abstract test class is to ensure that the process of exporting of a replay does not affect its playback.
+    /// Use <see cref="RunTest"/> to exercise that property.
+    /// </summary>
+    [HeadlessTest]
+    [TestFixture]
+    public abstract partial class ReplayStabilityTestScene : RateAdjustedBeatmapTestScene
+    {
+        private ReplayPlayer currentPlayer = null!;
+        private readonly List<JudgementResult> results = new List<JudgementResult>();
+
+        /// <summary>
+        /// Runs <paramref name="replay"/> against the supplied <paramref name="beatmap"/>
+        /// and checks that the judgement results recorded match <paramref name="expectedResults"/>.
+        /// Then, encodes the <paramref name="replay"/>, decodes the result of encoding, runs the result of decoding against the supplied <paramref name="beatmap"/>,
+        /// and checks that the judgement results recorded still match <paramref name="expectedResults"/>.
+        /// </summary>
+        protected void RunTest(IBeatmap beatmap, Replay replay, IEnumerable<HitResult> expectedResults)
+        {
+            Score originalScore = null!;
+            Score decodedScore = null!;
+
+            AddStep(@"create replay", () => originalScore = new Score
+            {
+                Replay = replay,
+                ScoreInfo = new ScoreInfo()
+            });
+
+            AddStep(@"set beatmap", () => Beatmap.Value = CreateWorkingBeatmap(beatmap));
+            AddStep(@"set ruleset", () => Ruleset.Value = beatmap.BeatmapInfo.Ruleset);
+            AddStep(@"push player", () => pushNewPlayer(originalScore));
+
+            AddUntilStep(@"wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep(@"wait for completion", () => currentPlayer.GameplayState.HasCompleted);
+            AddAssert(@"judgement results before encode are correct", () => results.Select(r => r.Type), () => Is.EquivalentTo(expectedResults));
+
+            AddStep(@"exit player", () => currentPlayer.Exit());
+
+            AddStep(@"encode and decode score", () =>
+            {
+                var encoder = new LegacyScoreEncoder(originalScore, beatmap);
+
+                using (var stream = new MemoryStream())
+                {
+                    encoder.Encode(stream, leaveOpen: true);
+                    stream.Position = 0;
+                    decodedScore = new TestScoreDecoder(Beatmap.Value).Parse(stream);
+                }
+            });
+
+            AddStep(@"push player", () => pushNewPlayer(decodedScore));
+
+            AddUntilStep(@"Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep(@"Wait for completion", () => currentPlayer.GameplayState.HasCompleted);
+            AddAssert(@"judgement results after encode are correct", () => results.Select(r => r.Type), () => Is.EquivalentTo(expectedResults));
+        }
+
+        private void pushNewPlayer(Score score)
+        {
+            var player = new ReplayPlayer(score);
+            player.OnLoadComplete += _ =>
+            {
+                player.GameplayState.ScoreProcessor.NewJudgement += result =>
+                {
+                    if (currentPlayer == player)
+                        results.Add(result);
+                };
+            };
+            LoadScreen(currentPlayer = player);
+            results.Clear();
+        }
+
+        private class TestScoreDecoder : LegacyScoreDecoder
+        {
+            private readonly WorkingBeatmap beatmap;
+
+            public TestScoreDecoder(WorkingBeatmap beatmap)
+            {
+                this.beatmap = beatmap;
+            }
+
+            protected override Ruleset GetRuleset(int rulesetId) => beatmap.BeatmapInfo.Ruleset.CreateInstance();
+            protected override WorkingBeatmap GetBeatmap(string md5Hash) => beatmap;
+        }
+    }
+}
diff --git a/osu.Game/Users/UserActivity.cs b/osu.Game/Users/UserActivity.cs
index 16b30546de..b7b6c6f366 100644
--- a/osu.Game/Users/UserActivity.cs
+++ b/osu.Game/Users/UserActivity.cs
@@ -6,6 +6,7 @@ using MessagePack;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Online;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
@@ -271,6 +272,12 @@ namespace osu.Game.Users
                 RoomName = room.Name;
             }
 
+            public InLobby(MultiplayerRoom room)
+            {
+                RoomID = room.RoomID;
+                RoomName = room.Settings.Name;
+            }
+
             [SerializationConstructor]
             public InLobby() { }
 
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index e9d7bacc64..b8aae9c015 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -35,7 +35,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="20.1.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2025.321.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2025.419.0" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2025.321.0" />
     <PackageReference Include="Sentry" Version="5.1.1" />
     <!-- Held back due to 0.34.0 failing AOT compilation on ZstdSharp.dll dependency. -->
diff --git a/osu.iOS.props b/osu.iOS.props
index 2fa83c3ab0..d988adb6cf 100644
--- a/osu.iOS.props
+++ b/osu.iOS.props
@@ -17,6 +17,6 @@
     <MtouchInterpreter>-all</MtouchInterpreter>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2025.321.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2025.419.0" />
   </ItemGroup>
 </Project>
diff --git a/osu.sln.DotSettings b/osu.sln.DotSettings
index 5cac0024b7..b8a455e2f1 100644
--- a/osu.sln.DotSettings
+++ b/osu.sln.DotSettings
@@ -88,6 +88,7 @@
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertToUsingDeclaration/@EntryIndexedValue">HINT</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConvertTypeCheckPatternToNullCheck/@EntryIndexedValue">DO_NOT_SHOW</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=DoubleNegationOperator/@EntryIndexedValue">WARNING</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=DuplicatedStatements/@EntryIndexedValue">HINT</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=EmptyGeneralCatchClause/@EntryIndexedValue">DO_NOT_SHOW</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=EnforceDoWhileStatementBraces/@EntryIndexedValue">WARNING</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=EnforceFixedStatementBraces/@EntryIndexedValue">WARNING</s:String>