diff --git a/.editorconfig b/.editorconfig
index 7aecde95ee..a145efc348 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -19,6 +19,11 @@ indent_style = space
 indent_size = 4
 trim_trailing_whitespace = true
 
+# temporary workaround for https://youtrack.jetbrains.com/issue/RIDER-130051/Cannot-resolve-symbol-inspections-incorrectly-firing-for-xmldoc-protected-member-references
+resharper_c_sharp_warnings_cs1574_cs1584_cs1581_cs1580_highlighting = hint
+# temporary workaround for https://youtrack.jetbrains.com/issue/RIDER-130381/Rider-does-not-respect-propagated-NoWarn-CS1591?backToIssues=false
+dotnet_diagnostic.CS1591.severity = none
+
 #license header
 file_header_template = Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.\nSee the LICENCE file in the repository root for full licence text.
 
diff --git a/osu.Android.props b/osu.Android.props
index 40a9b454ce..64bdd985f6 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.826.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.930.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-apple-overlay.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-apple-overlay.png
deleted file mode 100644
index 8d9608cfc9..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-apple-overlay.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-apple.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-apple.png
deleted file mode 100644
index be1bda0383..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-apple.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-bananas-overlay.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-bananas-overlay.png
deleted file mode 100644
index 3a6612378e..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-bananas-overlay.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-bananas.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-bananas.png
deleted file mode 100644
index afb8698b2d..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-bananas.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-drop.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-drop.png
deleted file mode 100644
index 12c74f46e2..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-drop.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-grapes-overlay.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-grapes-overlay.png
deleted file mode 100644
index bb37ba1920..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-grapes-overlay.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-grapes.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-grapes.png
deleted file mode 100644
index 10699b1f31..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-grapes.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-orange-overlay.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-orange-overlay.png
deleted file mode 100644
index e86aa6e7e3..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-orange-overlay.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-orange.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-orange.png
deleted file mode 100644
index 42cc80399f..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-orange.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-pear-overlay.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-pear-overlay.png
deleted file mode 100644
index 5c479da954..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-pear-overlay.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-pear.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-pear.png
deleted file mode 100644
index 9fe400bdd1..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-pear.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-plate.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-plate.png
deleted file mode 100644
index 1da1fdde85..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-plate.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-ryuuta.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-ryuuta.png
deleted file mode 100644
index f732092379..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/fruit-ryuuta.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit0.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit0.png
deleted file mode 100644
index 2d312ceefd..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit0.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit100.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit100.png
deleted file mode 100644
index 7884dc072d..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit100.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit300.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit300.png
deleted file mode 100644
index 3e4ec2e047..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit300.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit50.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit50.png
deleted file mode 100644
index f02ad11a17..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/hit50.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-0.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-0.png
deleted file mode 100644
index 8304617d8c..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-0.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-1.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-1.png
deleted file mode 100644
index c3b85eb873..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-1.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-2.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-2.png
deleted file mode 100644
index 7f65eb7ca7..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-2.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-3.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-3.png
deleted file mode 100644
index 82bec3babe..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-3.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-4.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-4.png
deleted file mode 100644
index 5e38c75a9d..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-4.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-5.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-5.png
deleted file mode 100644
index a562d9f2ac..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-5.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-6.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-6.png
deleted file mode 100644
index b4cf81f26e..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-6.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-7.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-7.png
deleted file mode 100644
index a23f5379b2..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-7.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-8.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-8.png
deleted file mode 100644
index 430b18509d..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-8.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-9.png b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-9.png
deleted file mode 100644
index add1202c31..0000000000
Binary files a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/score-9.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/skin.ini b/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/skin.ini
deleted file mode 100644
index 94c6b5b58d..0000000000
--- a/osu.Game.Rulesets.Catch.Tests/Resources/old-skin/skin.ini
+++ /dev/null
@@ -1,2 +0,0 @@
-[General]
-// no version specified means v1
diff --git a/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs b/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs
index 24da447482..ad3cf4e05f 100644
--- a/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs
+++ b/osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs
@@ -147,7 +147,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         }
 
         [TestCase]
-        public void TestFilterIntersection()
+        public void TestKeysFilterIntersection()
         {
             var criteria = new ManiaFilterCriteria();
             criteria.TryParseCustomKeywordCriteria("keys", Operator.Greater, "4");
@@ -175,7 +175,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         }
 
         [TestCase]
-        public void TestInvalidFilters()
+        public void TestInvalidKeysFilters()
         {
             var criteria = new ManiaFilterCriteria();
 
@@ -183,5 +183,132 @@ namespace osu.Game.Rulesets.Mania.Tests
             Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "4,some text"));
             Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4,5,6"));
         }
+
+        [TestCase]
+        public void TestLnsEqual()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0");
+            BeatmapInfo beatmapInfo1 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 0,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0");
+            BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "100");
+            BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 100
+            };
+            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "1");
+            BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0.1");
+            BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 1000,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestLnsGreaterOrEqual()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0");
+            BeatmapInfo beatmapInfo1 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 0,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0");
+            BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 0
+            };
+            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "100");
+            BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 100
+            };
+            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1");
+            BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0.1");
+            BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
+            {
+                TotalObjectCount = 1000,
+                EndTimeObjectCount = 1
+            };
+            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestLnsNotManiaRuleset()
+        {
+            var criteria = new ManiaFilterCriteria();
+            var filterCriteria = new FilterCriteria
+            {
+                Ruleset = new ManiaRuleset().RulesetInfo
+            };
+
+            criteria.TryParseCustomKeywordCriteria("lns", Operator.LessOrEqual, "100");
+            BeatmapInfo beatmapInfo = new BeatmapInfo
+            {
+                TotalObjectCount = 100,
+                EndTimeObjectCount = 50
+            };
+            Assert.False(criteria.Matches(beatmapInfo, filterCriteria));
+        }
+
+        [TestCase]
+        public void TestInvalidLnsFilters()
+        {
+            var criteria = new ManiaFilterCriteria();
+
+            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "some text"));
+            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1some text"));
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs b/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
index 9b2700c6e8..3f7a018dd1 100644
--- a/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
+++ b/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Bindables;
@@ -19,12 +20,16 @@ namespace osu.Game.Rulesets.Mania
     public class ManiaFilterCriteria : IRulesetFilterCriteria
     {
         private readonly HashSet<int> includedKeyCounts = Enumerable.Range(1, LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT).ToHashSet();
+        private FilterCriteria.OptionalRange<float> longNotePercentage;
 
         public bool Matches(BeatmapInfo beatmapInfo, FilterCriteria criteria)
         {
             int keyCount = ManiaBeatmapConverter.GetColumnCount(LegacyBeatmapConversionDifficultyInfo.FromBeatmapInfo(beatmapInfo), criteria.Mods);
 
-            return includedKeyCounts.Contains(keyCount);
+            bool keyCountMatch = includedKeyCounts.Contains(keyCount);
+            bool longNotePercentageMatch = !longNotePercentage.HasFilter || (!isConvertedBeatmap(beatmapInfo) && longNotePercentage.IsInRange(calculateLongNotePercentage(beatmapInfo)));
+
+            return keyCountMatch && longNotePercentageMatch;
         }
 
         public bool TryParseCustomKeywordCriteria(string key, Operator op, string strValues)
@@ -84,6 +89,10 @@ namespace osu.Game.Rulesets.Mania
                             return false;
                     }
                 }
+
+                case "ln":
+                case "lns":
+                    return FilterQueryParser.TryUpdateCriteriaRange(ref longNotePercentage, op, strValues);
             }
 
             return false;
@@ -103,5 +112,18 @@ namespace osu.Game.Rulesets.Mania
 
             return false;
         }
+
+        private static bool isConvertedBeatmap(BeatmapInfo beatmapInfo)
+        {
+            return !beatmapInfo.Ruleset.Equals(new ManiaRuleset().RulesetInfo);
+        }
+
+        private static float calculateLongNotePercentage(BeatmapInfo beatmapInfo)
+        {
+            int holdNotes = beatmapInfo.EndTimeObjectCount;
+            int totalNotes = Math.Max(1, beatmapInfo.TotalObjectCount);
+
+            return holdNotes / (float)totalNotes * 100;
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/ManiaRuleset.cs b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
index c7bf1f3538..cc64ee0d69 100644
--- a/osu.Game.Rulesets.Mania/ManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
@@ -79,6 +79,7 @@ namespace osu.Game.Rulesets.Mania
                     return new ManiaArgonSkinTransformer(skin, beatmap);
 
                 case DefaultLegacySkin:
+                case RetroSkin:
                     return new ManiaClassicSkinTransformer(skin, beatmap);
 
                 case LegacySkin:
diff --git a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyNotePiece.cs b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyNotePiece.cs
index 4291ec3c13..c9c655ef7d 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyNotePiece.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyNotePiece.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 
         private Drawable noteAnimation = null!;
 
-        private float? minimumColumnWidth;
+        private float? widthForNoteHeightScale;
 
         public LegacyNotePiece()
         {
@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
         [BackgroundDependencyLoader]
         private void load(ISkinSource skin, IScrollingInfo scrollingInfo)
         {
-            minimumColumnWidth = skin.GetConfig<ManiaSkinConfigurationLookup, float>(new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.MinimumColumnWidth))?.Value;
+            widthForNoteHeightScale = skin.GetConfig<ManiaSkinConfigurationLookup, float>(new ManiaSkinConfigurationLookup(LegacyManiaSkinConfigurationLookups.WidthForNoteHeightScale))?.Value;
 
             InternalChild = directionContainer = new Container
             {
@@ -60,9 +60,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 
             if (texture != null)
             {
-                // The height is scaled to the minimum column width, if provided.
-                float minimumWidth = minimumColumnWidth ?? DrawWidth;
-                noteAnimation.Scale = Vector2.Divide(new Vector2(DrawWidth, minimumWidth), texture.DisplayWidth);
+                float noteHeight = widthForNoteHeightScale ?? DrawWidth;
+                noteAnimation.Scale = Vector2.Divide(new Vector2(DrawWidth, noteHeight), texture.DisplayWidth);
             }
         }
 
diff --git a/osu.Game.Rulesets.Mania/VariantMappingGenerator.cs b/osu.Game.Rulesets.Mania/VariantMappingGenerator.cs
index 2195c9e1b9..5e4da2d480 100644
--- a/osu.Game.Rulesets.Mania/VariantMappingGenerator.cs
+++ b/osu.Game.Rulesets.Mania/VariantMappingGenerator.cs
@@ -42,13 +42,22 @@ namespace osu.Game.Rulesets.Mania
             var bindings = new List<KeyBinding>();
 
             for (int i = LeftKeys.Length - columns / 2; i < LeftKeys.Length; i++)
-                bindings.Add(new KeyBinding(LeftKeys[i], currentAction++));
+            {
+                bindings.Add(new KeyBinding(LeftKeys[i], currentAction));
+                bindings.Add(new KeyBinding(InputKey.None, currentAction++));
+            }
 
             if (columns % 2 == 1)
-                bindings.Add(new KeyBinding(SpecialKey, currentAction++));
+            {
+                bindings.Add(new KeyBinding(SpecialKey, currentAction));
+                bindings.Add(new KeyBinding(InputKey.None, currentAction++));
+            }
 
             for (int i = 0; i < columns / 2; i++)
-                bindings.Add(new KeyBinding(RightKeys[i], currentAction++));
+            {
+                bindings.Add(new KeyBinding(RightKeys[i], currentAction));
+                bindings.Add(new KeyBinding(InputKey.None, currentAction++));
+            }
 
             return bindings;
         }
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/approachcircle.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/approachcircle.png
deleted file mode 100644
index ff8b02ce80..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/approachcircle.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/cursor-smoke.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/cursor-smoke.png
deleted file mode 100644
index 5f7beae4e9..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/cursor-smoke.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/cursor.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/cursor.png
deleted file mode 100755
index fe305468fe..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/cursor.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/cursortrail.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/cursortrail.png
deleted file mode 100755
index f3327dc92f..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/cursortrail.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-0.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-0.png
deleted file mode 100644
index 2af0569bcb..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-0.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-1.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-1.png
deleted file mode 100644
index e8b674d62a..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-1.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-2.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-2.png
deleted file mode 100644
index dbf7bc73bc..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-2.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-3.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-3.png
deleted file mode 100644
index 43990c46e7..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-3.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-4.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-4.png
deleted file mode 100644
index 4564f6d8bf..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-4.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-5.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-5.png
deleted file mode 100644
index dcef35eb59..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-5.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-6.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-6.png
deleted file mode 100644
index bfc0a01be5..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-6.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-7.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-7.png
deleted file mode 100644
index b9079ad5d5..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-7.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-8.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-8.png
deleted file mode 100644
index 3a3d61b947..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-8.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-9.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-9.png
deleted file mode 100644
index 3e703cd1cf..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/default-9.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit0.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit0.png
deleted file mode 100644
index 3c3ebbfd0b..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit0.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit100.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit100.png
deleted file mode 100644
index 9ecc302910..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit100.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit300.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit300.png
deleted file mode 100644
index 24945f7d92..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit300.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit50.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit50.png
deleted file mode 100644
index d3f7eec5ee..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hit50.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hitcircle.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hitcircle.png
deleted file mode 100644
index a5a3545abf..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hitcircle.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hitcircleoverlay.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hitcircleoverlay.png
deleted file mode 100644
index b4062b8c62..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/hitcircleoverlay.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/reversearrow.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/reversearrow.png
deleted file mode 100644
index 7ebdec37d3..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/reversearrow.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-0.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-0.png
deleted file mode 100644
index 8304617d8c..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-0.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-1.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-1.png
deleted file mode 100644
index c3b85eb873..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-1.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-2.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-2.png
deleted file mode 100644
index 7f65eb7ca7..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-2.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-3.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-3.png
deleted file mode 100644
index 82bec3babe..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-3.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-4.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-4.png
deleted file mode 100644
index 5e38c75a9d..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-4.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-5.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-5.png
deleted file mode 100644
index a562d9f2ac..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-5.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-6.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-6.png
deleted file mode 100644
index b4cf81f26e..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-6.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-7.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-7.png
deleted file mode 100644
index a23f5379b2..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-7.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-8.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-8.png
deleted file mode 100644
index 430b18509d..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-8.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-9.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-9.png
deleted file mode 100644
index add1202c31..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-9.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-comma.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-comma.png
deleted file mode 100644
index f68d32957f..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-comma.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-dot.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-dot.png
deleted file mode 100644
index 80c39b8745..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-dot.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-percent.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-percent.png
deleted file mode 100644
index fc750abc7e..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-percent.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-x.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-x.png
deleted file mode 100644
index 779773f8bd..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/score-x.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/skin.ini b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/skin.ini
deleted file mode 100644
index 06dfa6b7be..0000000000
--- a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/skin.ini
+++ /dev/null
@@ -1,6 +0,0 @@
-[General]
-// no version specified means v1
-
-[Fonts]
-HitCircleOverlap: 3
-ScoreOverlap: 3
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint10.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint10.png
deleted file mode 100644
index 3e2fe66a1c..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint10.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint30.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint30.png
deleted file mode 100644
index d883279d81..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/sliderpoint30.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-approachcircle.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-approachcircle.png
deleted file mode 100644
index 3811e5050f..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-approachcircle.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-background.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-background.png
deleted file mode 100644
index d84eab2f15..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-background.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-circle.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-circle.png
deleted file mode 100644
index 4dd4a6d319..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-circle.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-clear.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-clear.png
deleted file mode 100644
index c66f1c9309..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-clear.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-metre.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-metre.png
deleted file mode 100644
index 33902186d9..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-metre.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-osu.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-osu.png
deleted file mode 100644
index 6882a232e0..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-osu.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-rpm.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-rpm.png
deleted file mode 100644
index 73753554f7..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-rpm.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-spin.png b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-spin.png
deleted file mode 100644
index 98a9991c2f..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinner-spin.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinnerbonus.wav b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinnerbonus.wav
deleted file mode 100644
index 5e583e77aa..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinnerbonus.wav and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinnerspin.wav b/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinnerspin.wav
deleted file mode 100644
index bba19381f1..0000000000
Binary files a/osu.Game.Rulesets.Osu.Tests/Resources/old-skin/spinnerspin.wav and /dev/null differ
diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerInput.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerInput.cs
index 4a72690da2..c4e643dcdf 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerInput.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerInput.cs
@@ -191,6 +191,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         [Test]
+        [FlakyTest]
         public void TestRewind()
         {
             AddStep("set manual clock", () => manualClock = new ManualClock
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
index 5ae9b194be..bff6701826 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
@@ -469,9 +469,20 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             }
             else
             {
-                SnapResult result = positionSnapProvider?.TrySnapToPositionGrid(Parent!.ToScreenSpace(e.MousePosition));
+                Vector2 newControlPointPosition = Parent!.ToScreenSpace(e.MousePosition);
 
-                Vector2 movementDelta = Parent!.ToLocalSpace(result?.ScreenSpacePosition ?? Parent!.ToScreenSpace(e.MousePosition)) - dragStartPositions[draggedControlPointIndex] - hitObject.Position;
+                // Snapping inherited B-spline control points to nearby objects would be unintuitive, because snapping them does not equate to snapping the interpolated slider path.
+                bool shouldSnapToNearbyObjects = dragPathTypes[draggedControlPointIndex] is not null ||
+                                                 dragPathTypes[..draggedControlPointIndex].LastOrDefault(t => t is not null)?.Type != SplineType.BSpline;
+
+                SnapResult result = null;
+                if (shouldSnapToNearbyObjects)
+                    result = positionSnapProvider?.TrySnapToNearbyObjects(newControlPointPosition, oldStartTime);
+                if (positionSnapProvider?.TrySnapToPositionGrid(result?.ScreenSpacePosition ?? newControlPointPosition, result?.Time ?? oldStartTime) is SnapResult gridSnapResult)
+                    result = gridSnapResult;
+                result ??= new SnapResult(newControlPointPosition, oldStartTime);
+
+                Vector2 movementDelta = Parent!.ToLocalSpace(result.ScreenSpacePosition) - dragStartPositions[draggedControlPointIndex] - hitObject.Position;
 
                 for (int i = 0; i < controlPoints.Count; ++i)
                 {
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
index 363533ae76..b46dd44ce5 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
@@ -626,10 +626,38 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         public override Vector2 ScreenSpaceSelectionPoint => DrawableObject.SliderBody?.ToScreenSpace(DrawableObject.SliderBody.PathOffset)
                                                              ?? BodyPiece.ToScreenSpace(BodyPiece.PathStartLocation);
 
-        protected override Vector2[] ScreenSpaceAdditionalNodes => new[]
-        {
+        protected override Vector2[] ScreenSpaceAdditionalNodes => getScreenSpaceControlPointNodes().Prepend(
             DrawableObject.SliderBody?.ToScreenSpace(DrawableObject.SliderBody.PathEndOffset) ?? BodyPiece.ToScreenSpace(BodyPiece.PathEndLocation)
-        };
+        ).ToArray();
+
+        private IEnumerable<Vector2> getScreenSpaceControlPointNodes()
+        {
+            // Returns the positions of control points that produce visible kinks on the slider's path
+            // This excludes inherited control points from Bezier, B-Spline, Perfect, and Catmull curves
+            if (DrawableObject.SliderBody == null)
+                yield break;
+
+            PathType? currentPathType = null;
+
+            // Skip the last control point because its always either not on the slider path or exactly on the slider end
+            for (int i = 0; i < DrawableObject.HitObject.Path.ControlPoints.Count - 1; i++)
+            {
+                var controlPoint = DrawableObject.HitObject.Path.ControlPoints[i];
+
+                if (controlPoint.Type is not null)
+                    currentPathType = controlPoint.Type;
+
+                // Skip the first control point because it is already covered by the slider head
+                if (i == 0)
+                    continue;
+
+                if (controlPoint.Type is null && currentPathType != PathType.LINEAR)
+                    continue;
+
+                var screenSpacePosition = DrawableObject.SliderBody.ToScreenSpace(DrawableObject.SliderBody.PathOffset + controlPoint.Position);
+                yield return screenSpacePosition;
+            }
+        }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
         {
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index 3a1ff34fb9..c591b79b29 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -253,7 +253,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
             var hitObjects = selectedMovableObjects;
 
-            Quad quad = GeometryUtils.GetSurroundingQuad(hitObjects);
+            Quad quad = GeometryUtils.GetSurroundingQuad(hitObjects, true);
 
             Vector2 delta = Vector2.Zero;
 
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index 9a5d3c3bc1..d5f3137769 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -81,12 +81,8 @@ namespace osu.Game.Rulesets.Osu.Edit
             changeHandler?.BeginChange();
 
             objectsInScale = selectedMovableObjects.ToDictionary(ho => ho, ho => new OriginalHitObjectState(ho));
-            OriginalSurroundingQuad = objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider
-                ? GeometryUtils.GetSurroundingQuad(slider.Path.ControlPoints.Select(p => slider.Position + p.Position))
-                : GeometryUtils.GetSurroundingQuad(objectsInScale.Keys);
-            originalConvexHull = objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider2
-                ? GeometryUtils.GetConvexHull(slider2.Path.ControlPoints.Select(p => slider2.Position + p.Position))
-                : GeometryUtils.GetConvexHull(objectsInScale.Keys);
+            OriginalSurroundingQuad = GeometryUtils.GetSurroundingQuad(objectsInScale.Keys);
+            originalConvexHull = GeometryUtils.GetConvexHull(objectsInScale.Keys);
             defaultOrigin = GeometryUtils.MinimumEnclosingCircle(originalConvexHull).Item1;
         }
 
@@ -312,7 +308,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private void moveSelectionInBounds()
         {
-            Quad quad = GeometryUtils.GetSurroundingQuad(objectsInScale!.Keys);
+            Quad quad = GeometryUtils.GetSurroundingQuad(objectsInScale!.Keys, true);
 
             Vector2 delta = Vector2.Zero;
 
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs
index 04d6afc925..f3739ab445 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs
@@ -176,6 +176,11 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private void applyPosition()
         {
+            // can happen if popover is dismissed by a keyboard key press while dragging UI controls
+            // it doesn't cause a crash, but it looks wrong
+            if (!editorBeatmap.TransactionActive)
+                return;
+
             editorBeatmap.PerformOnSelection(ho =>
             {
                 if (!initialPositions.TryGetValue(ho, out var initialPosition))
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
index ae8ad2c01b..e2cde1a325 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
@@ -157,6 +157,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             rotationInfo.BindValueChanged(rotation =>
             {
+                // can happen if the popover is dismissed by a keyboard key press while dragging UI controls
+                if (!rotationHandler.OperationInProgress.Value)
+                    return;
+
                 rotationHandler.Update(rotation.NewValue.Degrees, getOriginPosition(rotation.NewValue));
             });
         }
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
index ac6d9fbb19..ca4a99b9cd 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
@@ -220,6 +220,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             scaleInfo.BindValueChanged(scale =>
             {
+                // can happen if the popover is dismissed by a keyboard key press while dragging UI controls
+                if (!scaleHandler.OperationInProgress.Value)
+                    return;
+
                 var newScale = new Vector2(scale.NewValue.Scale, scale.NewValue.Scale);
                 scaleHandler.Update(newScale, getOriginPosition(scale.NewValue), getAdjustAxis(scale.NewValue), getRotation(scale.NewValue));
             });
diff --git a/osu.Game.Rulesets.Osu/Utils/OsuHitObjectGenerationUtils_Reposition.cs b/osu.Game.Rulesets.Osu/Utils/OsuHitObjectGenerationUtils.Reposition.cs
similarity index 100%
rename from osu.Game.Rulesets.Osu/Utils/OsuHitObjectGenerationUtils_Reposition.cs
rename to osu.Game.Rulesets.Osu/Utils/OsuHitObjectGenerationUtils.Reposition.cs
diff --git a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModHidden.cs b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModHidden.cs
index e6d5c51902..5336ea604e 100644
--- a/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModHidden.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModHidden.cs
@@ -5,10 +5,13 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Taiko.Tests.Mods
 {
@@ -69,5 +72,106 @@ namespace osu.Game.Rulesets.Taiko.Tests.Mods
                 },
             });
         }
+
+        [Test]
+        public void TestIncreasedVisibilityOnFirstObject()
+        {
+            bool firstHitNeverFadedOut = true;
+            AddStep("enable increased visibility", () => LocalConfig.SetValue(OsuSetting.IncreaseFirstObjectVisibility, true));
+            CreateModTest(new ModTestData
+            {
+                Mod = new TaikoModHidden(),
+                Autoplay = true,
+                PassCondition = () =>
+                {
+                    var firstHit = this.ChildrenOfType<DrawableHit>().FirstOrDefault(h => h.HitObject.StartTime == 100);
+
+                    if (firstHit?.Alpha < 1 && !firstHit.IsHit)
+                        firstHitNeverFadedOut = false;
+
+                    return firstHitNeverFadedOut && checkAllMaxResultJudgements(2).Invoke();
+                },
+                CreateBeatmap = () =>
+                {
+                    var beatmap = new Beatmap<TaikoHitObject>
+                    {
+                        HitObjects = new List<TaikoHitObject>
+                        {
+                            new Hit
+                            {
+                                Type = HitType.Rim,
+                                StartTime = 100,
+                            },
+                            new Hit
+                            {
+                                Type = HitType.Centre,
+                                StartTime = 200,
+                            },
+                        },
+                        BeatmapInfo =
+                        {
+                            Difficulty = new BeatmapDifficulty
+                            {
+                                SliderTickRate = 4,
+                                OverallDifficulty = 0,
+                            },
+                            Ruleset = new TaikoRuleset().RulesetInfo
+                        },
+                    };
+
+                    beatmap.ControlPointInfo.Add(0, new EffectControlPoint { ScrollSpeed = 0.1f });
+                    return beatmap;
+                },
+            });
+        }
+
+        [Test]
+        public void TestNoIncreasedVisibilityOnFirstObject()
+        {
+            bool firstHitFadedOut = true;
+            AddStep("enable increased visibility", () => LocalConfig.SetValue(OsuSetting.IncreaseFirstObjectVisibility, false));
+            CreateModTest(new ModTestData
+            {
+                Mod = new TaikoModHidden(),
+                Autoplay = true,
+                PassCondition = () =>
+                {
+                    var firstHit = this.ChildrenOfType<DrawableHit>().FirstOrDefault(h => h.HitObject.StartTime == 100);
+                    firstHitFadedOut |= firstHit?.IsHit == false && firstHit.Alpha < 1;
+                    return firstHitFadedOut && checkAllMaxResultJudgements(2).Invoke();
+                },
+                CreateBeatmap = () =>
+                {
+                    var beatmap = new Beatmap<TaikoHitObject>
+                    {
+                        HitObjects = new List<TaikoHitObject>
+                        {
+                            new Hit
+                            {
+                                Type = HitType.Rim,
+                                StartTime = 100,
+                            },
+                            new Hit
+                            {
+                                Type = HitType.Centre,
+                                StartTime = 200,
+                            },
+                        },
+                        BeatmapInfo =
+                        {
+                            Difficulty = new BeatmapDifficulty
+                            {
+                                SliderTickRate = 4,
+                                OverallDifficulty = 0,
+                            },
+                            Ruleset = new TaikoRuleset().RulesetInfo
+                        },
+                    };
+
+                    beatmap.ControlPointInfo.Add(0, new EffectControlPoint { ScrollSpeed = 0.1f });
+                    return beatmap;
+                },
+            });
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/approachcircle.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/approachcircle.png
deleted file mode 100755
index 5aba688756..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/approachcircle.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/skin.ini b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/skin.ini
deleted file mode 100644
index 462c2c278e..0000000000
--- a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/skin.ini
+++ /dev/null
@@ -1,5 +0,0 @@
-[General]
-Name: an old skin
-Author: an old guy
-
-// no version specified means v1
\ No newline at end of file
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-bar-left.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-bar-left.png
deleted file mode 100644
index ad55fd5a96..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-bar-left.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-drum-inner.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-drum-inner.png
deleted file mode 100644
index f5c02509fb..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-drum-inner.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-drum-outer.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-drum-outer.png
deleted file mode 100644
index 53905792cb..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-drum-outer.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-slider-fail@2x.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-slider-fail@2x.png
deleted file mode 100644
index 2d9974a701..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-slider-fail@2x.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-slider@2x.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-slider@2x.png
deleted file mode 100644
index 07b2f167e0..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taiko-slider@2x.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikobigcircle.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikobigcircle.png
deleted file mode 100644
index 63504dd52d..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikobigcircle.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikobigcircleoverlay-0.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikobigcircleoverlay-0.png
deleted file mode 100644
index 490c196fba..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikobigcircleoverlay-0.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikobigcircleoverlay-1.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikobigcircleoverlay-1.png
deleted file mode 100644
index 99cd589a10..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikobigcircleoverlay-1.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikohitcircle.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikohitcircle.png
deleted file mode 100644
index 26eec54d07..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikohitcircle.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikohitcircleoverlay-0.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikohitcircleoverlay-0.png
deleted file mode 100644
index 272c6bcaf7..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikohitcircleoverlay-0.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikohitcircleoverlay-1.png b/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikohitcircleoverlay-1.png
deleted file mode 100644
index e49e82a71f..0000000000
Binary files a/osu.Game.Rulesets.Taiko.Tests/Resources/old-skin/taikohitcircleoverlay-1.png and /dev/null differ
diff --git a/osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs b/osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs
index 2c3b4a8d18..8b6fb71d51 100644
--- a/osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs
+++ b/osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
 
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            ApplyNormalVisibilityState(hitObject, state);
+            // intentional no-op
         }
 
         protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
diff --git a/osu.Game.Tests/Database/BeatmapImporterTests.cs b/osu.Game.Tests/Database/BeatmapImporterTests.cs
index 38746f2567..f3ca665380 100644
--- a/osu.Game.Tests/Database/BeatmapImporterTests.cs
+++ b/osu.Game.Tests/Database/BeatmapImporterTests.cs
@@ -1018,6 +1018,49 @@ namespace osu.Game.Tests.Database
             });
         }
 
+        [Test]
+        public void TestBeatmapFilesInNestedDirectoriesAreIgnored()
+        {
+            RunTestWithRealmAsync(async (realm, storage) =>
+            {
+                var importer = new BeatmapImporter(storage, realm);
+                using var store = new RealmRulesetStore(realm, storage);
+
+                string? temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                Directory.CreateDirectory(extractedFolder);
+
+                try
+                {
+                    using (var zip = ZipArchive.Open(temp))
+                        zip.WriteToDirectory(extractedFolder);
+
+                    var subdirectory = Directory.CreateDirectory(Path.Combine(extractedFolder, "subdir"));
+                    string modifiedCopyPath = Path.Combine(subdirectory.FullName, "duplicate.osu");
+                    File.Copy(Directory.GetFiles(extractedFolder, "*.osu").First(), modifiedCopyPath);
+
+                    using (var stream = File.OpenWrite(modifiedCopyPath))
+                    using (var textWriter = new StreamWriter(stream))
+                        await textWriter.WriteLineAsync("# adding a comment so that the hashes are different");
+
+                    using (var zip = ZipArchive.Create())
+                    {
+                        zip.AddAllFromDirectory(extractedFolder);
+                        zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
+                    }
+
+                    await importer.Import(temp);
+
+                    EnsureLoaded(realm.Realm);
+                }
+                finally
+                {
+                    Directory.Delete(extractedFolder, true);
+                }
+            });
+        }
+
         [Test]
         public void TestImportNestedStructure()
         {
diff --git a/osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs b/osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs
index b02bf01019..3a96459b73 100644
--- a/osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs
+++ b/osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs
@@ -46,9 +46,12 @@ namespace osu.Game.Tests.Extensions
 
         [Test]
         [SetCulture("fr-FR")]
-        public void TestCultureInsensitivity()
+        [TestCase(0.4, true, 2, ExpectedResult = "40%")]
+        [TestCase(1e-6, false, 6, ExpectedResult = "0.000001")]
+        [TestCase(0.48333, true, 4, ExpectedResult = "48.33%")]
+        public string TestCultureInsensitivity(double input, bool percent, int decimalDigits)
         {
-            Assert.That(0.4.ToStandardFormattedString(maxDecimalDigits: 2, asPercentage: true), Is.EqualTo("40%"));
+            return input.ToStandardFormattedString(decimalDigits, percent);
         }
     }
 }
diff --git a/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs b/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
index 9968647cb2..8bef6b04a7 100644
--- a/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
+++ b/osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
@@ -178,6 +178,16 @@ namespace osu.Game.Tests.NonVisual.Filtering
 
         [Test]
         public void TestApplyBPMQueries()
+        {
+            const string query = "bpm=200";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual(filterCriteria.BPM.Min, 199.5d);
+            Assert.AreEqual(filterCriteria.BPM.Max, 200.5d);
+        }
+
+        [Test]
+        public void TestApplyBPMRangeQueries()
         {
             const string query = "bpm>:200 gotta go fast";
             var filterCriteria = new FilterCriteria();
@@ -185,8 +195,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.AreEqual("gotta go fast", filterCriteria.SearchText.Trim());
             Assert.AreEqual(3, filterCriteria.SearchTerms.Length);
             Assert.IsNotNull(filterCriteria.BPM.Min);
-            Assert.Greater(filterCriteria.BPM.Min, 199.99d);
-            Assert.Less(filterCriteria.BPM.Min, 200.00d);
+            Assert.AreEqual(filterCriteria.BPM.Min, 199.5d);
             Assert.IsNull(filterCriteria.BPM.Max);
         }
 
diff --git a/osu.Game.Tests/Online/Matchmaking/MatchmakingRoomStateTest.cs b/osu.Game.Tests/Online/Matchmaking/MatchmakingRoomStateTest.cs
new file mode 100644
index 0000000000..c9219c871a
--- /dev/null
+++ b/osu.Game.Tests/Online/Matchmaking/MatchmakingRoomStateTest.cs
@@ -0,0 +1,153 @@
+// 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.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+
+namespace osu.Game.Tests.Online.Matchmaking
+{
+    public class MatchmakingRoomStateTest
+    {
+        /// <summary>
+        /// The number of points awarded for each placement position (index 0 = #1, index 7 = #8).
+        /// </summary>
+        private static readonly int[] placement_points = [8, 7, 6, 5, 4, 3, 2, 1];
+
+        [Test]
+        public void Basic()
+        {
+            var state = new MatchmakingRoomState();
+
+            // 1 -> 3 -> 2
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 2, TotalScore = 500 },
+                new SoloScoreInfo { UserID = 1, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 3, TotalScore = 750 },
+            ], placement_points);
+
+            Assert.AreEqual(8, state.Users[1].Points);
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(1, state.Users[1].Rounds[1].Placement);
+
+            Assert.AreEqual(6, state.Users[2].Points);
+            Assert.AreEqual(3, state.Users[2].Placement);
+            Assert.AreEqual(3, state.Users[2].Rounds[1].Placement);
+
+            Assert.AreEqual(7, state.Users[3].Points);
+            Assert.AreEqual(2, state.Users[3].Placement);
+            Assert.AreEqual(2, state.Users[3].Rounds[1].Placement);
+
+            // 2 -> 1 -> 3
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 2, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 1, TotalScore = 750 },
+                new SoloScoreInfo { UserID = 3, TotalScore = 500 },
+            ], placement_points);
+
+            Assert.AreEqual(15, state.Users[1].Points);
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(2, state.Users[1].Rounds[2].Placement);
+
+            Assert.AreEqual(14, state.Users[2].Points);
+            Assert.AreEqual(2, state.Users[2].Placement);
+            Assert.AreEqual(1, state.Users[2].Rounds[2].Placement);
+
+            Assert.AreEqual(13, state.Users[3].Points);
+            Assert.AreEqual(3, state.Users[3].Placement);
+            Assert.AreEqual(3, state.Users[3].Rounds[2].Placement);
+        }
+
+        [Test]
+        public void MatchingScores()
+        {
+            var state = new MatchmakingRoomState();
+
+            // 1 + 2 -> 3 + 4
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 1, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 2, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 3, TotalScore = 500 },
+                new SoloScoreInfo { UserID = 4, TotalScore = 500 },
+            ], placement_points);
+
+            Assert.AreEqual(7, state.Users[1].Points);
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(2, state.Users[1].Rounds[1].Placement);
+
+            Assert.AreEqual(7, state.Users[2].Points);
+            Assert.AreEqual(2, state.Users[2].Placement);
+            Assert.AreEqual(2, state.Users[2].Rounds[1].Placement);
+
+            Assert.AreEqual(5, state.Users[3].Points);
+            Assert.AreEqual(3, state.Users[3].Placement);
+            Assert.AreEqual(4, state.Users[3].Rounds[1].Placement);
+
+            Assert.AreEqual(5, state.Users[4].Points);
+            Assert.AreEqual(4, state.Users[4].Placement);
+            Assert.AreEqual(4, state.Users[4].Rounds[1].Placement);
+        }
+
+        [Test]
+        public void RoundTieBreaker()
+        {
+            var state = new MatchmakingRoomState();
+
+            // 1 -> 2
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 1, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 2, TotalScore = 500 },
+            ], placement_points);
+
+            // 2 -> 1
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 1, TotalScore = 500 },
+                new SoloScoreInfo { UserID = 2, TotalScore = 1000 },
+            ], placement_points);
+
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(2, state.Users[2].Placement);
+        }
+
+        [Test]
+        public void UserIdTieBreaker()
+        {
+            var state = new MatchmakingRoomState();
+
+            // 1 + 2 + 3 + 4 + 5 + 6
+
+            state.AdvanceRound();
+            state.RecordScores(
+            [
+                new SoloScoreInfo { UserID = 4, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 6, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 2, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 3, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 1, TotalScore = 1000 },
+                new SoloScoreInfo { UserID = 5, TotalScore = 1000 },
+            ], placement_points);
+
+            Assert.AreEqual(1, state.Users[1].Placement);
+            Assert.AreEqual(2, state.Users[2].Placement);
+            Assert.AreEqual(3, state.Users[3].Placement);
+            Assert.AreEqual(4, state.Users[4].Placement);
+            Assert.AreEqual(5, state.Users[5].Placement);
+            Assert.AreEqual(6, state.Users[6].Placement);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Resources/Archives/modified-argon-20250308.osk b/osu.Game.Tests/Resources/Archives/modified-argon-20250308.osk
new file mode 100644
index 0000000000..cbaacd3f4b
Binary files /dev/null and b/osu.Game.Tests/Resources/Archives/modified-argon-20250308.osk differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-0.png b/osu.Game.Tests/Resources/old-skin/score-0.png
deleted file mode 100644
index 8304617d8c..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-0.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-1.png b/osu.Game.Tests/Resources/old-skin/score-1.png
deleted file mode 100644
index c3b85eb873..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-1.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-2.png b/osu.Game.Tests/Resources/old-skin/score-2.png
deleted file mode 100644
index 7f65eb7ca7..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-2.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-3.png b/osu.Game.Tests/Resources/old-skin/score-3.png
deleted file mode 100644
index 82bec3babe..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-3.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-4.png b/osu.Game.Tests/Resources/old-skin/score-4.png
deleted file mode 100644
index 5e38c75a9d..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-4.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-5.png b/osu.Game.Tests/Resources/old-skin/score-5.png
deleted file mode 100644
index a562d9f2ac..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-5.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-6.png b/osu.Game.Tests/Resources/old-skin/score-6.png
deleted file mode 100644
index b4cf81f26e..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-6.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-7.png b/osu.Game.Tests/Resources/old-skin/score-7.png
deleted file mode 100644
index a23f5379b2..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-7.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-8.png b/osu.Game.Tests/Resources/old-skin/score-8.png
deleted file mode 100644
index 430b18509d..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-8.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-9.png b/osu.Game.Tests/Resources/old-skin/score-9.png
deleted file mode 100644
index add1202c31..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-9.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-comma.png b/osu.Game.Tests/Resources/old-skin/score-comma.png
deleted file mode 100644
index f68d32957f..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-comma.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-dot.png b/osu.Game.Tests/Resources/old-skin/score-dot.png
deleted file mode 100644
index 80c39b8745..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-dot.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-percent.png b/osu.Game.Tests/Resources/old-skin/score-percent.png
deleted file mode 100644
index fc750abc7e..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-percent.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/score-x.png b/osu.Game.Tests/Resources/old-skin/score-x.png
deleted file mode 100644
index 779773f8bd..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/score-x.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/scorebar-bg.png b/osu.Game.Tests/Resources/old-skin/scorebar-bg.png
deleted file mode 100644
index 1e94f464ca..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/scorebar-bg.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/scorebar-colour-0.png b/osu.Game.Tests/Resources/old-skin/scorebar-colour-0.png
deleted file mode 100644
index 1119ce289e..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/scorebar-colour-0.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/scorebar-colour-1.png b/osu.Game.Tests/Resources/old-skin/scorebar-colour-1.png
deleted file mode 100644
index 7669474d8b..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/scorebar-colour-1.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/scorebar-colour-2.png b/osu.Game.Tests/Resources/old-skin/scorebar-colour-2.png
deleted file mode 100644
index 70fdb4b146..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/scorebar-colour-2.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/scorebar-colour-3.png b/osu.Game.Tests/Resources/old-skin/scorebar-colour-3.png
deleted file mode 100644
index 18ac6976c9..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/scorebar-colour-3.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/scorebar-ki.png b/osu.Game.Tests/Resources/old-skin/scorebar-ki.png
deleted file mode 100644
index a030c5801e..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/scorebar-ki.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/scorebar-kidanger.png b/osu.Game.Tests/Resources/old-skin/scorebar-kidanger.png
deleted file mode 100644
index ac5a2c5893..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/scorebar-kidanger.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/scorebar-kidanger2.png b/osu.Game.Tests/Resources/old-skin/scorebar-kidanger2.png
deleted file mode 100644
index 507be0463f..0000000000
Binary files a/osu.Game.Tests/Resources/old-skin/scorebar-kidanger2.png and /dev/null differ
diff --git a/osu.Game.Tests/Resources/old-skin/skin.ini b/osu.Game.Tests/Resources/old-skin/skin.ini
deleted file mode 100644
index 94c6b5b58d..0000000000
--- a/osu.Game.Tests/Resources/old-skin/skin.ini
+++ /dev/null
@@ -1,2 +0,0 @@
-[General]
-// no version specified means v1
diff --git a/osu.Game.Tests/Skins/IO/ImportSkinTest.cs b/osu.Game.Tests/Skins/IO/ImportSkinTest.cs
index 62e7a80435..2535d5b2e2 100644
--- a/osu.Game.Tests/Skins/IO/ImportSkinTest.cs
+++ b/osu.Game.Tests/Skins/IO/ImportSkinTest.cs
@@ -294,6 +294,92 @@ namespace osu.Game.Tests.Skins.IO
 
         #endregion
 
+        [Test]
+        public async Task TestExternallyMountingWithSubDirectory()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var zipStream = new MemoryStream();
+                    using var zip = ZipArchive.Create();
+                    zip.AddEntry("folder/test.png", new MemoryStream(new byte[] { 0xDE, 0xAD, 0xBE, 0xEF }));
+                    zip.SaveTo(zipStream);
+
+                    var import = await loadSkinIntoOsu(osu, new ImportTask(zipStream, "test skin.osk"));
+
+                    var skinManager = osu.Dependencies.Get<SkinManager>();
+                    var externalEdit = await skinManager.BeginExternalEditing(import.PerformRead(s => s.Detach())); // should not fail
+
+                    Assert.That(Directory.Exists(externalEdit.MountedPath));
+
+                    var directoryInfo = new DirectoryInfo(externalEdit.MountedPath);
+
+                    Assert.That(directoryInfo.GetFiles().Select(f => f.Name), Is.EquivalentTo(new[]
+                    {
+                        "skin.ini",
+                    }));
+
+                    var subDirectory = directoryInfo.GetDirectories().Single();
+                    Assert.That(subDirectory.Name, Is.EqualTo("folder"));
+                    Assert.That(subDirectory.GetFiles().Select(f => f.Name), Is.EquivalentTo(new[]
+                    {
+                        "test.png",
+                    }));
+
+                    Task finishTask = Task.CompletedTask;
+                    host.UpdateThread.Scheduler.Add(() => finishTask = externalEdit.Finish());
+                    await finishTask;
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        /// <remarks>
+        /// Note that this test passing / failing is platform / OS-specific (if it is to fail, it'll fail on windows).
+        /// </remarks>
+        [Test]
+        public async Task TestExternallyMountingImportWithInvalidFilename()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var zipStream = new MemoryStream();
+                    using var zip = ZipArchive.Create();
+                    zip.AddEntry("test?.png", new MemoryStream(new byte[] { 0xDE, 0xAD, 0xBE, 0xEF }));
+                    zip.SaveTo(zipStream);
+
+                    var import = await loadSkinIntoOsu(osu, new ImportTask(zipStream, "test skin.osk"));
+
+                    var skinManager = osu.Dependencies.Get<SkinManager>();
+                    var externalEdit = await skinManager.BeginExternalEditing(import.PerformRead(s => s.Detach())); // should not fail
+
+                    Assert.That(Directory.Exists(externalEdit.MountedPath));
+                    Assert.That(new DirectoryInfo(externalEdit.MountedPath).GetFiles().Select(f => f.Name), Is.EquivalentTo(new[]
+                    {
+                        "skin.ini",
+                        "test.png"
+                    }));
+
+                    Task finishTask = Task.CompletedTask;
+                    host.UpdateThread.Scheduler.Add(() => finishTask = externalEdit.Finish());
+                    await finishTask;
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
         private void assertCorrectMetadata(Live<SkinInfo> import1, string name, string creator, decimal version, OsuGameBase osu)
         {
             import1.PerformRead(i =>
diff --git a/osu.Game.Tests/Skins/SkinDeserialisationTest.cs b/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
index 0eafe33343..a493f334fd 100644
--- a/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
+++ b/osu.Game.Tests/Skins/SkinDeserialisationTest.cs
@@ -79,6 +79,8 @@ namespace osu.Game.Tests.Skins
             "Archives/modified-argon-20250424.osk",
             // Covers "Argon" unstable rate counter
             "Archives/modified-argon-20250809.osk",
+            // Covers "Argon" judgement counter
+            "Archives/modified-argon-20250308.osk",
         };
 
         /// <summary>
diff --git a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
index 58fb02c90c..3021589cdb 100644
--- a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
+++ b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
@@ -325,7 +325,7 @@ namespace osu.Game.Tests.Visual.Background
         private void setupUserSettings()
         {
             AddUntilStep("Song select is current", () => songSelect.IsCurrentScreen());
-            AddUntilStep("Song select has selection", () => songSelect.Carousel?.CurrentSelection != null);
+            AddUntilStep("Song select has selection", () => songSelect.Carousel?.CurrentGroupedBeatmap != null);
             AddStep("Set default user settings", () =>
             {
                 SelectedMods.Value = new[] { new OsuModNoFail() };
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneSubmissionStageProgress.cs b/osu.Game.Tests/Visual/Editing/TestSceneSubmissionStageProgress.cs
index ee22cbda71..2dc9077a14 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneSubmissionStageProgress.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneSubmissionStageProgress.cs
@@ -68,6 +68,25 @@ namespace osu.Game.Tests.Visual.Editing
                         progress.SetInProgress(incrementingProgress += RNG.NextSingle(0.08f));
                 }, 0, true);
             });
+            AddStep("increase progress slowly then fail", () =>
+            {
+                incrementingProgress = 0;
+
+                ScheduledDelegate? task = null;
+
+                task = Scheduler.AddDelayed(() =>
+                {
+                    if (incrementingProgress >= 1)
+                    {
+                        progress.SetFailed("nope");
+                        // ReSharper disable once AccessToModifiedClosure
+                        task?.Cancel();
+                        return;
+                    }
+
+                    progress.SetInProgress(incrementingProgress += RNG.NextSingle(0.001f));
+                }, 0, true);
+            });
 
             AddUntilStep("wait for completed", () => incrementingProgress >= 1);
             AddStep("completed", () => progress.SetCompleted());
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneArgonJudgementCounter.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneArgonJudgementCounter.cs
new file mode 100644
index 0000000000..e5886aa607
--- /dev/null
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneArgonJudgementCounter.cs
@@ -0,0 +1,209 @@
+// 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 NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD.JudgementCounter;
+using osu.Game.Skinning.Components;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public partial class TestSceneArgonJudgementCounter : OsuTestScene
+    {
+        private ScoreProcessor scoreProcessor = null!;
+        private JudgementCountController judgementCountController = null!;
+        private TestArgonJudgementCounterDisplay counterDisplay = null!;
+
+        private DependencyProvidingContainer content = null!;
+
+        protected override Container<Drawable> Content => content;
+
+        private readonly Bindable<JudgementResult> lastJudgementResult = new Bindable<JudgementResult>();
+
+        private int iteration;
+
+        [SetUpSteps]
+        public void SetUpSteps() => AddStep("Create components", () =>
+        {
+            var ruleset = CreateRuleset();
+
+            Debug.Assert(ruleset != null);
+
+            scoreProcessor = new ScoreProcessor(ruleset);
+            base.Content.Child = new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies = new (Type, object)[] { (typeof(ScoreProcessor), scoreProcessor), (typeof(Ruleset), ruleset) },
+                Children = new Drawable[]
+                {
+                    judgementCountController = new JudgementCountController(),
+                    content = new DependencyProvidingContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        CachedDependencies = new (Type, object)[] { (typeof(JudgementCountController), judgementCountController) },
+                    }
+                },
+            };
+        });
+
+        protected override Ruleset CreateRuleset() => new OsuRuleset();
+
+        private void applyOneJudgement(HitResult result)
+        {
+            lastJudgementResult.Value = new OsuJudgementResult(new HitObject
+            {
+                StartTime = iteration * 10000
+            }, new OsuJudgement())
+            {
+                Type = result,
+            };
+            scoreProcessor.ApplyResult(lastJudgementResult.Value);
+
+            iteration++;
+        }
+
+        [Test]
+        public void TestAddJudgementsToCounters()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddRepeatStep("Add judgement", () => applyOneJudgement(HitResult.Great), 2);
+            AddRepeatStep("Add judgement", () => applyOneJudgement(HitResult.Miss), 2);
+            AddRepeatStep("Add judgement", () => applyOneJudgement(HitResult.Meh), 2);
+        }
+
+        [Test]
+        public void TestAddWhilstHidden()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddRepeatStep("Add judgement", () => applyOneJudgement(HitResult.LargeTickHit), 2);
+            AddAssert("Check value added whilst hidden", () => hiddenCount() == 2);
+            AddStep("Show all judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.All);
+        }
+
+        [Test]
+        public void TestChangeFlowDirection()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Set direction vertical", () => counterDisplay.FlowDirection.Value = Direction.Vertical);
+            AddStep("Set direction horizontal", () => counterDisplay.FlowDirection.Value = Direction.Horizontal);
+
+            AddStep("add 100 ok judgements", () =>
+            {
+                for (int i = 0; i < 100; i++)
+                    applyOneJudgement(HitResult.Ok);
+            });
+            AddStep("add 1000 great judgements", () =>
+            {
+                for (int i = 0; i < 1000; i++)
+                    applyOneJudgement(HitResult.Great);
+            });
+
+            AddToggleStep("toggle max judgement display", t => counterDisplay.ShowMaxJudgement.Value = t);
+        }
+
+        [Test]
+        public void TestToggleJudgementNames()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Show label", () => counterDisplay.ShowLabel.Value = true);
+            AddWaitStep("wait some", 2);
+            AddAssert("Assert hidden", () => counterDisplay.CounterFlow.Children.First().Alpha == 1);
+            AddStep("Hide label", () => counterDisplay.ShowLabel.Value = false);
+            AddWaitStep("wait some", 2);
+            AddAssert("Assert shown", () => counterDisplay.CounterFlow.Children.First().Alpha == 1);
+        }
+
+        [Test]
+        public void TestHideMaxValue()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Hide max judgement", () => counterDisplay.ShowMaxJudgement.Value = false);
+            AddWaitStep("wait some", 2);
+            AddAssert("Check max hidden", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().First().Alpha == 0);
+            AddStep("Show max judgement", () => counterDisplay.ShowMaxJudgement.Value = true);
+        }
+
+        [Test]
+        public void TestMaxValueStartsHidden()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay
+            {
+                ShowMaxJudgement = { Value = false }
+            });
+            AddAssert("Check max hidden", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().First().Alpha == 0);
+        }
+
+        [Test]
+        public void TestMaxValueHiddenOnModeChange()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Set max judgement to hide itself", () => counterDisplay.ShowMaxJudgement.Value = false);
+            AddStep("Show all judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.All);
+            AddWaitStep("wait some", 2);
+            AddAssert("Assert max judgement hidden", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().First().Alpha == 0);
+        }
+
+        [Test]
+        public void TestNoDuplicates()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+            AddStep("Show all judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.All);
+            AddAssert("Check no duplicates",
+                () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().Count(),
+                () => Is.EqualTo(counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().Select(c => c.Result.DisplayName).Distinct().Count()));
+        }
+
+        [Test]
+        public void TestCycleDisplayModes()
+        {
+            AddStep("create counter", () => Child = counterDisplay = new TestArgonJudgementCounterDisplay());
+
+            AddStep("Show basic judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.Simple);
+            AddWaitStep("wait some", 2);
+            AddAssert("Check only basic", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().Last().Alpha == 0);
+            AddStep("Show normal judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.Normal);
+            AddStep("Show all judgements", () => counterDisplay.Mode.Value = ArgonJudgementCounterDisplay.DisplayMode.All);
+            AddWaitStep("wait some", 2);
+            AddAssert("Check all visible", () => counterDisplay.CounterFlow.ChildrenOfType<ArgonJudgementCounter>().Last().Alpha == 1);
+            AddToggleStep("toggle wireframe display", t => counterDisplay.WireframeOpacity.Value = t ? 0.3f : 0);
+            AddStep("Set direction vertical", () => counterDisplay.FlowDirection.Value = Direction.Vertical);
+            AddStep("Set direction horizontal", () => counterDisplay.FlowDirection.Value = Direction.Horizontal);
+        }
+
+        private int hiddenCount()
+        {
+            var num = counterDisplay.CounterFlow.Children.First(child => child.Result.Types.Contains(HitResult.LargeTickHit));
+            return num.Result.ResultCount.Value;
+        }
+
+        private partial class TestArgonJudgementCounterDisplay : ArgonJudgementCounterDisplay
+        {
+            public new FillFlowContainer<ArgonJudgementCounter> CounterFlow => base.CounterFlow;
+
+            public TestArgonJudgementCounterDisplay()
+            {
+                Margin = new MarginPadding { Top = 100 };
+                Anchor = Anchor.TopCentre;
+                Origin = Anchor.TopCentre;
+            }
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneBeatmapSelectGrid.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneBeatmapSelectGrid.cs
new file mode 100644
index 0000000000..93a33bdd95
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneBeatmapSelectGrid.cs
@@ -0,0 +1,210 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect;
+using osu.Game.Tests.Visual.OnlinePlay;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneBeatmapSelectGrid : OnlinePlayTestScene
+    {
+        private MultiplayerPlaylistItem[] items = null!;
+
+        private BeatmapSelectGrid grid = null!;
+
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var beatmaps = beatmapManager.GetAllUsableBeatmapSets()
+                                         .SelectMany(it => it.Beatmaps)
+                                         .Take(50)
+                                         .ToArray();
+
+            if (beatmaps.Length > 0)
+            {
+                items = Enumerable.Range(1, 50).Select(i => new MultiplayerPlaylistItem
+                {
+                    ID = i,
+                    BeatmapID = beatmaps[i % beatmaps.Length].OnlineID,
+                    StarRating = i / 10.0,
+                }).ToArray();
+            }
+            else
+            {
+                items = Enumerable.Range(1, 50).Select(i => new MultiplayerPlaylistItem
+                {
+                    ID = i,
+                    BeatmapID = i,
+                    StarRating = i / 10.0,
+                }).ToArray();
+            }
+        }
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("add grid", () => Child = grid = new BeatmapSelectGrid
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Scale = new Vector2(0.8f),
+            });
+
+            AddStep("add items", () =>
+            {
+                foreach (var item in items)
+                    grid.AddItem(item);
+            });
+
+            AddWaitStep("wait for panels", 3);
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+            AddStep("do nothing", () =>
+            {
+                // test scene is weird.
+            });
+
+            AddStep("add selection 1", () => grid.ChildrenOfType<BeatmapSelectPanel>().First().AddUser(new APIUser
+            {
+                Id = 6411631,
+                Username = "Maarvin",
+            }, isOwnUser: true));
+            AddStep("add selection 2", () => grid.ChildrenOfType<BeatmapSelectPanel>().Skip(5).First().AddUser(new APIUser
+            {
+                Id = 2,
+                Username = "peppy",
+            }));
+            AddStep("add selection 3", () => grid.ChildrenOfType<BeatmapSelectPanel>().Skip(10).First().AddUser(new APIUser
+            {
+                Id = 1040328,
+                Username = "smoogipoo",
+            }));
+        }
+
+        [Test]
+        public void TestCompleteRollAnimation()
+        {
+            AddStep("play animation", () =>
+            {
+                var (candidateItems, finalItem) = pickRandomItems(5);
+
+                grid.RollAndDisplayFinalBeatmap(candidateItems, finalItem);
+            });
+        }
+
+        [Test]
+        public void TestRollAnimation()
+        {
+            AddStep("play animation", () =>
+            {
+                var (candidateItems, finalItem) = pickRandomItems(5);
+
+                grid.TransferCandidatePanelsToRollContainer(candidateItems, duration: 0);
+                grid.ArrangeItemsForRollAnimation(duration: 0, stagger: 0);
+
+                Scheduler.AddDelayed(() => grid.PlayRollAnimation(finalItem), 500);
+            });
+        }
+
+        [Test]
+        public void TestPresentRolledBeatmap()
+        {
+            AddStep("present beatmap", () =>
+            {
+                var (candidateItems, finalItem) = pickRandomItems(5);
+
+                grid.TransferCandidatePanelsToRollContainer(candidateItems, duration: 0);
+                grid.ArrangeItemsForRollAnimation(duration: 0, stagger: 0);
+                grid.PlayRollAnimation(finalItem, duration: 0);
+
+                Scheduler.AddDelayed(() => grid.PresentRolledBeatmap(finalItem), 500);
+            });
+        }
+
+        [Test]
+        public void TestPresentUnanimouslyChosenBeatmap()
+        {
+            AddStep("present beatmap", () =>
+            {
+                var (candidateItems, finalItem) = pickRandomItems(5);
+
+                grid.TransferCandidatePanelsToRollContainer(candidateItems, duration: 0);
+                grid.ArrangeItemsForRollAnimation(duration: 0, stagger: 0);
+                grid.PlayRollAnimation(finalItem, duration: 0);
+
+                Scheduler.AddDelayed(() => grid.PresentUnanimouslyChosenBeatmap(finalItem), 500);
+            });
+        }
+
+        [TestCase(1)]
+        [TestCase(2)]
+        [TestCase(3)]
+        [TestCase(4)]
+        [TestCase(5)]
+        [TestCase(6)]
+        [TestCase(7)]
+        [TestCase(8)]
+        public void TestPanelArrangement(int count)
+        {
+            AddStep("arrange panels", () =>
+            {
+                var (candidateItems, _) = pickRandomItems(count);
+
+                grid.TransferCandidatePanelsToRollContainer(candidateItems);
+                grid.Delay(BeatmapSelectGrid.ARRANGE_DELAY)
+                    .Schedule(() => grid.ArrangeItemsForRollAnimation());
+            });
+
+            AddWaitStep("wait for movement", 5);
+
+            AddStep("display roll order", () =>
+            {
+                var panels = grid.ChildrenOfType<BeatmapSelectPanel>().ToArray();
+
+                for (int i = 0; i < panels.Length; i++)
+                {
+                    var panel = panels[i];
+
+                    panel.Add(new OsuSpriteText
+                    {
+                        Text = (i + 1).ToString(),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Font = OsuFont.Default.With(size: 50, weight: FontWeight.SemiBold),
+                    });
+                }
+            });
+        }
+
+        private (long[] candidateItems, long finalItem) pickRandomItems(int count)
+        {
+            long[] candidateItems = items.Select(it => it.ID).ToArray();
+            Random.Shared.Shuffle(candidateItems);
+            candidateItems = candidateItems.Take(count).ToArray();
+
+            long finalItem = candidateItems[Random.Shared.Next(candidateItems.Length)];
+
+            return (candidateItems, finalItem);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneBeatmapSelectPanel.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneBeatmapSelectPanel.cs
new file mode 100644
index 0000000000..2de4d6d7ea
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneBeatmapSelectPanel.cs
@@ -0,0 +1,57 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneBeatmapSelectPanel : MultiplayerTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
+
+        [Test]
+        public void TestBeatmapPanel()
+        {
+            BeatmapSelectPanel? panel = null;
+
+            AddStep("add panel", () => Child = panel = new BeatmapSelectPanel(new MultiplayerPlaylistItem())
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+
+            AddStep("add maarvin", () => panel!.AddUser(new APIUser
+            {
+                Id = 6411631,
+                Username = "Maarvin",
+            }, isOwnUser: true));
+            AddStep("add peppy", () => panel!.AddUser(new APIUser
+            {
+                Id = 2,
+                Username = "peppy",
+            }));
+            AddStep("add smogipoo", () => panel!.AddUser(new APIUser
+            {
+                Id = 1040328,
+                Username = "smoogipoo",
+            }));
+            AddStep("remove smogipoo", () => panel!.RemoveUser(new APIUser { Id = 1040328 }));
+            AddStep("remove peppy", () => panel!.RemoveUser(new APIUser { Id = 2 }));
+            AddStep("remove maarvin", () => panel!.RemoveUser(new APIUser { Id = 6411631 }));
+
+            AddToggleStep("allow selection", value =>
+            {
+                if (panel != null)
+                    panel.AllowSelection = value;
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneIdleScreen.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneIdleScreen.cs
new file mode 100644
index 0000000000..08df61d629
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneIdleScreen.cs
@@ -0,0 +1,90 @@
+// 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.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.RoundWarmup;
+using osu.Game.Tests.Visual.Multiplayer;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneIdleScreen : MultiplayerTestScene
+    {
+        private const int user_count = 8;
+
+        private (MultiplayerRoomUser user, int score)[] userScores = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add list", () =>
+            {
+                userScores = Enumerable.Range(1, user_count).Select(i =>
+                {
+                    var user = new MultiplayerRoomUser(i)
+                    {
+                        User = new APIUser
+                        {
+                            Username = $"Player {i}"
+                        }
+                    };
+
+                    return (user, 0);
+                }).ToArray();
+
+                Child = new ScreenStack(new SubScreenRoundWarmup())
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(0.8f)
+                };
+            });
+
+            AddStep("join users", () =>
+            {
+                foreach (var (user, _) in userScores)
+                    MultiplayerClient.AddUser(user);
+            });
+        }
+
+        [Test]
+        public void TestRandomChanges()
+        {
+            AddStep("apply random changes", () =>
+            {
+                int[] deltas = Enumerable.Range(1, userScores.Length).ToArray();
+                new Random().Shuffle(deltas);
+
+                for (int i = 0; i < userScores.Length; i++)
+                    userScores[i] = (userScores[i].user, userScores[i].score + deltas[i]);
+                userScores = userScores.OrderByDescending(u => u.score).ToArray();
+
+                MultiplayerClient.ChangeMatchRoomState(new MatchmakingRoomState
+                {
+                    Users =
+                    {
+                        UserDictionary = userScores.Select((tuple, i) => new MatchmakingUser
+                        {
+                            UserId = tuple.user.UserID,
+                            Points = tuple.score,
+                            Placement = i + 1
+                        }).ToDictionary(s => s.UserId)
+                    }
+                }).WaitSafely();
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingCloud.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingCloud.cs
new file mode 100644
index 0000000000..d656971b5a
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingCloud.cs
@@ -0,0 +1,44 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Queue;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneMatchmakingCloud : OsuTestScene
+    {
+        private CloudVisualisation cloud = null!;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Child = cloud = new CloudVisualisation
+            {
+                RelativeSizeAxes = Axes.Both,
+            };
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+            AddStep("refresh users", () =>
+            {
+                var testUsers = Enumerable.Range(0, 50).Select(_ => new APIUser
+                {
+                    Username = "peppy",
+                    Statistics = new UserStatistics { GlobalRank = 1234 },
+                    Id = RNG.Next(2, 30000000),
+                }).ToArray();
+
+                cloud.Users = testUsers;
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingPoolSelector.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingPoolSelector.cs
new file mode 100644
index 0000000000..5971cd9091
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingPoolSelector.cs
@@ -0,0 +1,35 @@
+// 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.Game.Online.Matchmaking;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Queue;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneMatchmakingPoolSelector : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("add selector", () => Child = new PoolSelector
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AvailablePools =
+                {
+                    Value =
+                    [
+                        new MatchmakingPool { Id = 0, RulesetId = 0 },
+                        new MatchmakingPool { Id = 1, RulesetId = 1 },
+                        new MatchmakingPool { Id = 2, RulesetId = 2 },
+                        new MatchmakingPool { Id = 3, RulesetId = 3, Variant = 4 },
+                        new MatchmakingPool { Id = 4, RulesetId = 3, Variant = 7 },
+                    ]
+                }
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingQueueScreen.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingQueueScreen.cs
new file mode 100644
index 0000000000..5193d58ee6
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingQueueScreen.cs
@@ -0,0 +1,58 @@
+// 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.Testing;
+using osu.Framework.Utils;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Intro;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Queue;
+using osu.Game.Tests.Visual.Multiplayer;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneMatchmakingQueueScreen : MultiplayerTestScene
+    {
+        [Cached]
+        private readonly QueueController controller = new QueueController();
+
+        private ScreenQueue? queueScreen => Stack.CurrentScreen as ScreenQueue;
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("load screen", () => LoadScreen(new IntroScreen()));
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+            AddUntilStep("wait for queue screen", () => queueScreen?.IsLoaded == true);
+
+            AddStep("set users", () =>
+            {
+                queueScreen!.Users = Enumerable.Range(0, 10).Select(_ => new APIUser
+                {
+                    Username = "peppy",
+                    Statistics = new UserStatistics { GlobalRank = 1234 },
+                    Id = RNG.Next(2, 30000000),
+                }).ToArray();
+            });
+
+            AddStep("change state to idle", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.Idle));
+
+            AddStep("change state to queueing", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.Queueing));
+
+            AddStep("change state to found match", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.PendingAccept));
+
+            AddStep("change state to waiting for room", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.AcceptedWaitingForRoom));
+
+            AddStep("change state to in room", () => queueScreen!.SetState(ScreenQueue.MatchmakingScreenState.InRoom));
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingScreen.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingScreen.cs
new file mode 100644
index 0000000000..2269e1c76c
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneMatchmakingScreen.cs
@@ -0,0 +1,196 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Screens;
+using osu.Framework.Utils;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneMatchmakingScreen : MultiplayerTestScene
+    {
+        private const int user_count = 8;
+        private const int beatmap_count = 50;
+
+        private MultiplayerRoomUser[] users = null!;
+        private ScreenMatchmaking screen = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () =>
+            {
+                var room = CreateDefaultRoom(MatchType.Matchmaking);
+                room.Playlist = Enumerable.Range(1, 50).Select(i => new PlaylistItem(new MultiplayerPlaylistItem
+                {
+                    ID = i,
+                    BeatmapID = i,
+                    StarRating = i / 10.0,
+                })).ToArray();
+
+                JoinRoom(room);
+            });
+
+            WaitForJoined();
+
+            AddStep("join users", () =>
+            {
+                for (int i = 0; i < 7; i++)
+                {
+                    MultiplayerClient.AddUser(new MultiplayerRoomUser(i)
+                    {
+                        User = new APIUser
+                        {
+                            Username = $"User {i}"
+                        }
+                    });
+                }
+            });
+
+            setupRequestHandler();
+
+            AddStep("load match", () =>
+            {
+                users = Enumerable.Range(1, user_count).Select(i => new MultiplayerRoomUser(i)
+                {
+                    User = new APIUser
+                    {
+                        Username = $"Player {i}"
+                    }
+                }).ToArray();
+
+                var beatmaps = Enumerable.Range(1, beatmap_count).Select(i => new MultiplayerPlaylistItem
+                {
+                    BeatmapID = i,
+                    StarRating = i / 10.0
+                }).ToArray();
+
+                LoadScreen(screen = new ScreenMatchmaking(new MultiplayerRoom(0)
+                {
+                    Users = users,
+                    Playlist = beatmaps
+                }));
+            });
+            AddUntilStep("wait for load", () => screen.IsCurrentScreen());
+        }
+
+        [Test]
+        public void TestGameplayFlow()
+        {
+            for (int round = 1; round <= 3; round++)
+            {
+                AddLabel($"Round {round}");
+
+                int r = round;
+                changeStage(MatchmakingStage.RoundWarmupTime, state => state.CurrentRound = r);
+                changeStage(MatchmakingStage.UserBeatmapSelect);
+                changeStage(MatchmakingStage.ServerBeatmapFinalised, state =>
+                {
+                    MultiplayerPlaylistItem[] beatmaps = Enumerable.Range(1, 8).Select(i => new MultiplayerPlaylistItem
+                    {
+                        ID = i,
+                        BeatmapID = i,
+                        StarRating = i / 10.0,
+                    }).ToArray();
+
+                    state.CandidateItems = beatmaps.Select(b => b.ID).ToArray();
+                    state.CandidateItem = beatmaps[0].ID;
+                }, waitTime: 35);
+
+                changeStage(MatchmakingStage.WaitingForClientsBeatmapDownload);
+                changeStage(MatchmakingStage.GameplayWarmupTime);
+                changeStage(MatchmakingStage.Gameplay);
+                changeStage(MatchmakingStage.ResultsDisplaying);
+            }
+
+            changeStage(MatchmakingStage.Ended, state =>
+            {
+                int localUserId = API.LocalUser.Value.OnlineID;
+
+                state.Users[localUserId].Placement = 1;
+                state.Users[localUserId].Rounds[1].Placement = 1;
+                state.Users[localUserId].Rounds[1].TotalScore = 1;
+                state.Users[localUserId].Rounds[1].Statistics[HitResult.LargeBonus] = 1;
+            });
+        }
+
+        private void changeStage(MatchmakingStage stage, Action<MatchmakingRoomState>? prepare = null, int waitTime = 5)
+        {
+            AddStep($"stage: {stage}", () => MultiplayerClient.MatchmakingChangeStage(stage, prepare).WaitSafely());
+            AddWaitStep("wait", waitTime);
+        }
+
+        private void setupRequestHandler()
+        {
+            AddStep("setup request handler", () =>
+            {
+                Func<APIRequest, bool>? defaultRequestHandler = null;
+
+                ((DummyAPIAccess)API).HandleRequest = request =>
+                {
+                    switch (request)
+                    {
+                        case GetBeatmapsRequest getBeatmaps:
+                            getBeatmaps.TriggerSuccess(new GetBeatmapsResponse
+                            {
+                                Beatmaps = getBeatmaps.BeatmapIds.Select(id => new APIBeatmap
+                                {
+                                    OnlineID = id,
+                                    StarRating = id,
+                                    DifficultyName = $"Beatmap {id}",
+                                    BeatmapSet = new APIBeatmapSet
+                                    {
+                                        Title = $"Title {id}",
+                                        Artist = $"Artist {id}",
+                                        AuthorString = $"Author {id}"
+                                    }
+                                }).ToList()
+                            });
+                            return true;
+
+                        case IndexPlaylistScoresRequest index:
+                            var result = new IndexedMultiplayerScores();
+
+                            for (int i = 0; i < 8; ++i)
+                            {
+                                result.Scores.Add(new MultiplayerScore
+                                {
+                                    ID = i,
+                                    Accuracy = 1 - (float)i / 16,
+                                    Position = i + 1,
+                                    EndedAt = DateTimeOffset.Now,
+                                    Passed = true,
+                                    Rank = (ScoreRank)RNG.Next((int)ScoreRank.D, (int)ScoreRank.XH),
+                                    MaxCombo = 1000 - i,
+                                    TotalScore = (long)(1_000_000 * (1 - (float)i / 16)),
+                                    User = new APIUser { Username = $"user {i}" },
+                                    Statistics = new Dictionary<HitResult, int>()
+                                });
+                            }
+
+                            index.TriggerSuccess(result);
+                            return true;
+
+                        default:
+                            return defaultRequestHandler?.Invoke(request) ?? false;
+                    }
+                };
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestScenePanelRoomAward.cs b/osu.Game.Tests/Visual/Matchmaking/TestScenePanelRoomAward.cs
new file mode 100644
index 0000000000..494d1c411a
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestScenePanelRoomAward.cs
@@ -0,0 +1,23 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.Results;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestScenePanelRoomAward : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("add statistic", () => Child = new PanelRoomAward("Statistic description", 1)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestScenePickScreen.cs b/osu.Game.Tests/Visual/Matchmaking/TestScenePickScreen.cs
new file mode 100644
index 0000000000..e894616f9e
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestScenePickScreen.cs
@@ -0,0 +1,111 @@
+// 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.Screens;
+using osu.Framework.Utils;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestScenePickScreen : MultiplayerTestScene
+    {
+        private readonly IReadOnlyList<APIUser> users = new[]
+        {
+            new APIUser
+            {
+                Id = 2,
+                Username = "peppy",
+            },
+            new APIUser
+            {
+                Id = 1040328,
+                Username = "smoogipoo",
+            },
+            new APIUser
+            {
+                Id = 6573093,
+                Username = "OliBomby",
+            },
+            new APIUser
+            {
+                Id = 7782553,
+                Username = "aesth",
+            },
+            new APIUser
+            {
+                Id = 6411631,
+                Username = "Maarvin",
+            }
+        };
+
+        private readonly PlaylistItem[] items = Enumerable.Range(1, 50).Select(i => new PlaylistItem(new MultiplayerPlaylistItem
+        {
+            ID = i,
+            BeatmapID = i,
+            StarRating = i / 10.0,
+        })).ToArray();
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () =>
+            {
+                var room = CreateDefaultRoom(MatchType.Matchmaking);
+                room.Playlist = items;
+
+                JoinRoom(room);
+            });
+
+            WaitForJoined();
+
+            AddStep("add users", () =>
+            {
+                foreach (var user in users)
+                    MultiplayerClient.AddUser(user);
+            });
+        }
+
+        [Test]
+        public void TestScreen()
+        {
+            var selectedItems = new List<long>();
+
+            SubScreenBeatmapSelect screen = null!;
+
+            AddStep("add screen", () => Child = new ScreenStack(screen = new SubScreenBeatmapSelect()));
+
+            AddStep("select maps", () =>
+            {
+                selectedItems.Clear();
+
+                foreach (var user in users)
+                {
+                    var item = items[Random.Shared.Next(items.Length)];
+                    selectedItems.Add(item.ID);
+
+                    Scheduler.AddDelayed(() =>
+                    {
+                        MultiplayerClient.MatchmakingToggleUserSelection(user.Id, item.ID).FireAndForget();
+                    }, RNG.NextDouble(10, 1000));
+                }
+            });
+
+            AddStep("show final map", () =>
+            {
+                long[] candidateItems = selectedItems.ToArray();
+                long finalItem = candidateItems[Random.Shared.Next(candidateItems.Length)];
+
+                screen.RollFinalBeatmap(candidateItems, finalItem);
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestScenePlayerPanel.cs b/osu.Game.Tests/Visual/Matchmaking/TestScenePlayerPanel.cs
new file mode 100644
index 0000000000..09c0f5fdbf
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestScenePlayerPanel.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.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Matchmaking.Events;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestScenePlayerPanel : MultiplayerTestScene
+    {
+        private PlayerPanel panel = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add panel", () => Child = panel = new PlayerPanel(new MultiplayerRoomUser(1)
+            {
+                User = new APIUser
+                {
+                    Username = @"peppy",
+                    Id = 2,
+                    Colour = "99EB47",
+                    CountryCode = CountryCode.AU,
+                    CoverUrl = @"https://assets.ppy.sh/user-profile-covers/8195163/4a8e2ad5a02a2642b631438cfa6c6bd7e2f9db289be881cb27df18331f64144c.jpeg",
+                    Statistics = new UserStatistics { GlobalRank = null, CountryRank = null }
+                }
+            })
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            });
+        }
+
+        [Test]
+        public void TestIncreasePlacement()
+        {
+            int rank = 0;
+
+            AddStep("increase placement", () => MultiplayerClient.ChangeMatchRoomState(new MatchmakingRoomState
+            {
+                Users =
+                {
+                    UserDictionary =
+                    {
+                        {
+                            2, new MatchmakingUser
+                            {
+                                UserId = 2,
+                                Placement = ++rank
+                            }
+                        }
+                    }
+                }
+            }).WaitSafely());
+
+            AddToggleStep("toggle horizontal", h => panel.Horizontal = h);
+        }
+
+        [Test]
+        public void TestIncreasePoints()
+        {
+            int points = 0;
+
+            AddStep("increase points", () => MultiplayerClient.ChangeMatchRoomState(new MatchmakingRoomState
+            {
+                Users =
+                {
+                    UserDictionary =
+                    {
+                        {
+                            1, new MatchmakingUser
+                            {
+                                UserId = 1,
+                                Placement = 1,
+                                Points = ++points
+                            }
+                        }
+                    }
+                }
+            }).WaitSafely());
+        }
+
+        [Test]
+        public void TestJump()
+        {
+            AddStep("jump", () => MultiplayerClient.SendUserMatchRequest(1, new MatchmakingAvatarActionRequest { Action = MatchmakingAvatarAction.Jump }).WaitSafely());
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneResultsScreen.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneResultsScreen.cs
new file mode 100644
index 0000000000..d445c46a48
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneResultsScreen.cs
@@ -0,0 +1,99 @@
+// 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.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.Results;
+using osu.Game.Tests.Visual.Multiplayer;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneResultsScreen : MultiplayerTestScene
+    {
+        private const int invalid_user_id = 1;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add results screen", () =>
+            {
+                Child = new ScreenStack(new SubScreenResults())
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(0.8f)
+                };
+            });
+
+            AddStep("join another user", () => MultiplayerClient.AddUser(new MultiplayerRoomUser(invalid_user_id)
+            {
+                User = new APIUser
+                {
+                    Id = invalid_user_id,
+                    Username = "Invalid user"
+                }
+            }));
+        }
+
+        [Test]
+        public void TestResults()
+        {
+            AddStep("set results stage", () =>
+            {
+                var state = new MatchmakingRoomState
+                {
+                    CurrentRound = 6,
+                    Stage = MatchmakingStage.Ended
+                };
+
+                int localUserId = API.LocalUser.Value.OnlineID;
+
+                // Overall state.
+                state.Users[localUserId].Placement = 1;
+                state.Users[localUserId].Points = 8;
+                state.Users[invalid_user_id].Placement = 2;
+                state.Users[invalid_user_id].Points = 7;
+                for (int round = 1; round <= state.CurrentRound; round++)
+                    state.Users[localUserId].Rounds[round].Placement = round;
+
+                // Highest score.
+                state.Users[localUserId].Rounds[1].TotalScore = 1000;
+                state.Users[invalid_user_id].Rounds[1].TotalScore = 990;
+
+                // Highest accuracy.
+                state.Users[localUserId].Rounds[2].Accuracy = 0.9995;
+                state.Users[invalid_user_id].Rounds[2].Accuracy = 0.5;
+
+                // Highest combo.
+                state.Users[localUserId].Rounds[3].MaxCombo = 100;
+                state.Users[invalid_user_id].Rounds[3].MaxCombo = 10;
+
+                // Most bonus score.
+                state.Users[localUserId].Rounds[4].Statistics[HitResult.LargeBonus] = 50;
+                state.Users[invalid_user_id].Rounds[4].Statistics[HitResult.LargeBonus] = 25;
+
+                // Smallest score difference.
+                state.Users[localUserId].Rounds[5].TotalScore = 1000;
+                state.Users[invalid_user_id].Rounds[5].TotalScore = 999;
+
+                // Largest score difference.
+                state.Users[localUserId].Rounds[6].TotalScore = 1000;
+                state.Users[invalid_user_id].Rounds[6].TotalScore = 0;
+
+                MultiplayerClient.ChangeMatchRoomState(state).WaitSafely();
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneRoundResultsScreen.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneRoundResultsScreen.cs
new file mode 100644
index 0000000000..cbdbd33158
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneRoundResultsScreen.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 System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Framework.Utils;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.RoundResults;
+using osu.Game.Tests.Visual.Multiplayer;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneRoundResultsScreen : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            setupRequestHandler();
+
+            AddStep("load screen", () =>
+            {
+                Child = new ScreenStack(new SubScreenRoundResults())
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(0.8f)
+                };
+            });
+        }
+
+        private void setupRequestHandler()
+        {
+            AddStep("setup request handler", () =>
+            {
+                Func<APIRequest, bool>? defaultRequestHandler = null;
+
+                ((DummyAPIAccess)API).HandleRequest = request =>
+                {
+                    switch (request)
+                    {
+                        case GetBeatmapsRequest getBeatmaps:
+                            getBeatmaps.TriggerSuccess(new GetBeatmapsResponse
+                            {
+                                Beatmaps = getBeatmaps.BeatmapIds.Select(id => new APIBeatmap
+                                {
+                                    OnlineID = id,
+                                    StarRating = id,
+                                    DifficultyName = $"Beatmap {id}",
+                                    BeatmapSet = new APIBeatmapSet
+                                    {
+                                        Title = $"Title {id}",
+                                        Artist = $"Artist {id}",
+                                        AuthorString = $"Author {id}"
+                                    }
+                                }).ToList()
+                            });
+                            return true;
+
+                        case IndexPlaylistScoresRequest index:
+                            var result = new IndexedMultiplayerScores();
+
+                            for (int i = 0; i < 8; ++i)
+                            {
+                                result.Scores.Add(new MultiplayerScore
+                                {
+                                    ID = i,
+                                    Accuracy = 1 - (float)i / 16,
+                                    Position = i + 1,
+                                    EndedAt = DateTimeOffset.Now,
+                                    Passed = true,
+                                    Rank = (ScoreRank)RNG.Next((int)ScoreRank.D, (int)ScoreRank.XH),
+                                    MaxCombo = 1000 - i,
+                                    TotalScore = (long)(1_000_000 * (1 - (float)i / 16)),
+                                    User = new APIUser { Username = $"user {i}" },
+                                    Statistics = new Dictionary<HitResult, int>()
+                                });
+                            }
+
+                            index.TriggerSuccess(result);
+                            return true;
+
+                        default:
+                            return defaultRequestHandler?.Invoke(request) ?? false;
+                    }
+                };
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneStageDisplay.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneStageDisplay.cs
new file mode 100644
index 0000000000..dc4f09c555
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneStageDisplay.cs
@@ -0,0 +1,61 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneStageDisplay : MultiplayerTestScene
+    {
+        [Cached]
+        protected readonly OverlayColourProvider ColourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add display", () => Child = new StageDisplay
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.X,
+            });
+        }
+
+        [Test]
+        public void TestChangeStage()
+        {
+            addStage(MatchmakingStage.WaitingForClientsJoin);
+
+            for (int i = 1; i <= 5; i++)
+            {
+                addStage(MatchmakingStage.RoundWarmupTime);
+                addStage(MatchmakingStage.UserBeatmapSelect);
+                addStage(MatchmakingStage.ServerBeatmapFinalised);
+                addStage(MatchmakingStage.WaitingForClientsBeatmapDownload);
+                addStage(MatchmakingStage.GameplayWarmupTime);
+                addStage(MatchmakingStage.Gameplay);
+                addStage(MatchmakingStage.ResultsDisplaying);
+            }
+
+            addStage(MatchmakingStage.Ended);
+        }
+
+        private void addStage(MatchmakingStage stage)
+        {
+            AddStep($"{stage}", () => MultiplayerClient.MatchmakingChangeStage(stage).WaitSafely());
+            AddWaitStep("wait a bit", 10);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneStageSegment.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneStageSegment.cs
new file mode 100644
index 0000000000..c9d74cc99d
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneStageSegment.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 System;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Online.Matchmaking;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneStageSegment : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add bubble", () => Child = new StageDisplay.StageSegment(null, MatchmakingStage.RoundWarmupTime, "Next Round")
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+        }
+
+        [Test]
+        public void TestStartStopCountdown()
+        {
+            MultiplayerCountdown countdown = null!;
+
+            AddStep("start countdown", () => MultiplayerClient.StartCountdown(countdown = new MatchmakingStageCountdown
+            {
+                Stage = MatchmakingStage.RoundWarmupTime,
+                TimeRemaining = TimeSpan.FromSeconds(5)
+            }).WaitSafely());
+
+            AddWaitStep("wait a bit", 10);
+
+            AddStep("stop countdown", () => MultiplayerClient.StopCountdown(countdown).WaitSafely());
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneStatusText.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneStatusText.cs
new file mode 100644
index 0000000000..26380152b1
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneStatusText.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 System;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneStatusText : MultiplayerTestScene
+    {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("create display", () => Child = new StageDisplay.StatusText
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            });
+        }
+
+        [Test]
+        public void TestChangeStage()
+        {
+            foreach (var stage in Enum.GetValues<MatchmakingStage>())
+            {
+                AddStep($"{stage}", () => MultiplayerClient.MatchmakingChangeStage(stage).WaitSafely());
+                AddWaitStep("wait a bit", 10);
+            }
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Matchmaking/TestSceneUserPanelOverlay.cs b/osu.Game.Tests/Visual/Matchmaking/TestSceneUserPanelOverlay.cs
new file mode 100644
index 0000000000..c8b1d55028
--- /dev/null
+++ b/osu.Game.Tests/Visual/Matchmaking/TestSceneUserPanelOverlay.cs
@@ -0,0 +1,160 @@
+// 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.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Tests.Visual.Multiplayer;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Matchmaking
+{
+    public partial class TestSceneUserPanelOverlay : MultiplayerTestScene
+    {
+        private PlayerPanelOverlay list = null!;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom(MatchType.Matchmaking)));
+            WaitForJoined();
+
+            AddStep("add list", () => Child = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Size = new Vector2(0.8f),
+                Child = list = new PlayerPanelOverlay()
+            });
+        }
+
+        [Test]
+        public void TestChangeDisplayMode()
+        {
+            AddStep("join users", () =>
+            {
+                for (int i = 0; i < 7; i++)
+                {
+                    MultiplayerClient.AddUser(new MultiplayerRoomUser(i)
+                    {
+                        User = new APIUser
+                        {
+                            Username = $"User {i}"
+                        }
+                    });
+                }
+            });
+
+            AddStep("change to split mode", () => list.DisplayStyle = PanelDisplayStyle.Split);
+            AddStep("change to grid mode", () => list.DisplayStyle = PanelDisplayStyle.Grid);
+            AddStep("change to hidden mode", () => list.DisplayStyle = PanelDisplayStyle.Hidden);
+        }
+
+        [Test]
+        public void AddPanelsGrid()
+        {
+            AddStep("change to grid mode", () => list.DisplayStyle = PanelDisplayStyle.Grid);
+
+            int userId = 0;
+
+            AddRepeatStep("join user", () =>
+            {
+                MultiplayerClient.AddUser(new MultiplayerRoomUser(userId)
+                {
+                    User = new APIUser
+                    {
+                        Username = $"User {userId}"
+                    }
+                });
+
+                userId++;
+            }, 8);
+        }
+
+        [Test]
+        public void AddPanelsSplit()
+        {
+            AddStep("change to split mode", () => list.DisplayStyle = PanelDisplayStyle.Split);
+
+            int userId = 0;
+
+            AddRepeatStep("join user", () =>
+            {
+                MultiplayerClient.AddUser(new MultiplayerRoomUser(userId)
+                {
+                    User = new APIUser
+                    {
+                        Username = $"User {userId}"
+                    }
+                });
+
+                userId++;
+            }, 8);
+        }
+
+        [Test]
+        public void RemovePanels()
+        {
+            AddStep("join another user", () =>
+            {
+                MultiplayerClient.AddUser(new MultiplayerRoomUser(1)
+                {
+                    User = new APIUser
+                    {
+                        Username = "User 1"
+                    }
+                });
+            });
+
+            AddUntilStep("two panels displayed", () => this.ChildrenOfType<UserPanel>().Count(), () => Is.EqualTo(2));
+
+            AddStep("remove a user", () => MultiplayerClient.RemoveUser(new APIUser { Id = 1 }));
+            AddUntilStep("one panel displayed", () => this.ChildrenOfType<UserPanel>().Count(), () => Is.EqualTo(1));
+        }
+
+        [Test]
+        public void ChangeRankings()
+        {
+            AddStep("join users", () =>
+            {
+                for (int i = 0; i < 7; i++)
+                {
+                    MultiplayerClient.AddUser(new MultiplayerRoomUser(i)
+                    {
+                        User = new APIUser
+                        {
+                            Username = $"User {i}"
+                        }
+                    });
+                }
+            });
+
+            AddStep("set random placements", () =>
+            {
+                MultiplayerRoom room = MultiplayerClient.ServerRoom!;
+
+                int[] placements = Enumerable.Range(1, room.Users.Count).ToArray();
+                Random.Shared.Shuffle(placements);
+
+                MatchmakingRoomState state = new MatchmakingRoomState();
+
+                for (int i = 0; i < room.Users.Count; i++)
+                    state.Users[room.Users[i].UserID].Placement = placements[i];
+
+                MultiplayerClient.ChangeMatchRoomState(state).WaitSafely();
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Menus/TestSceneLoginOverlay.cs b/osu.Game.Tests/Visual/Menus/TestSceneLoginOverlay.cs
index 3c97b291ee..0dfe055040 100644
--- a/osu.Game.Tests/Visual/Menus/TestSceneLoginOverlay.cs
+++ b/osu.Game.Tests/Visual/Menus/TestSceneLoginOverlay.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Linq;
 using System.Net;
 using NUnit.Framework;
@@ -9,10 +10,12 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Configuration;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 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.Overlays.Login;
 using osu.Game.Overlays.Settings;
@@ -54,7 +57,7 @@ namespace osu.Game.Tests.Visual.Menus
         }
 
         [Test]
-        public void TestLoginSuccess()
+        public void TestLoginSuccess_EmailVerification()
         {
             AddStep("logout", () => API.Logout());
             assertAPIState(APIState.Offline);
@@ -94,6 +97,152 @@ namespace osu.Game.Tests.Visual.Menus
             assertDropdownState(UserAction.DoNotDisturb);
         }
 
+        [Test]
+        public void TestLoginSuccess_TOTPVerification()
+        {
+            AddStep("logout", () => API.Logout());
+            assertAPIState(APIState.Offline);
+            AddStep("expect totp verification", () => dummyAPI.SessionVerificationMethod = SessionVerificationMethod.TimedOneTimePassword);
+
+            AddStep("enter password", () => loginOverlay.ChildrenOfType<OsuPasswordTextBox>().First().Text = "password");
+            AddStep("submit", () => loginOverlay.ChildrenOfType<OsuButton>().First(b => b.Text.ToString() == "Sign in").TriggerClick());
+
+            assertAPIState(APIState.RequiresSecondFactorAuth);
+            AddUntilStep("wait for second factor auth form", () => loginOverlay.ChildrenOfType<SecondFactorAuthForm>().SingleOrDefault(), () => Is.Not.Null);
+
+            AddStep("set up verification handling", () => dummyAPI.HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case VerifySessionRequest verifySessionRequest:
+                        if (verifySessionRequest.VerificationKey == "012345")
+                            verifySessionRequest.TriggerSuccess();
+                        else
+                            verifySessionRequest.TriggerFailure(new WebException());
+                        return true;
+                }
+
+                return false;
+            });
+
+            AddStep("enter code", () => loginOverlay.ChildrenOfType<OsuTextBox>().First().Text = "012345");
+            assertAPIState(APIState.Online);
+            assertDropdownState(UserAction.Online);
+
+            AddStep("set failing", () => { dummyAPI.SetState(APIState.Failing); });
+            AddStep("return to online", () => { dummyAPI.SetState(APIState.Online); });
+
+            AddStep("clear handler", () => dummyAPI.HandleRequest = null);
+
+            assertDropdownState(UserAction.Online);
+            AddStep("change user state", () => localConfig.SetValue(OsuSetting.UserOnlineStatus, UserStatus.DoNotDisturb));
+            assertDropdownState(UserAction.DoNotDisturb);
+        }
+
+        [Test]
+        public void TestLoginSuccess_TOTPVerification_FallbackToEmail()
+        {
+            AddStep("logout", () => API.Logout());
+            assertAPIState(APIState.Offline);
+            AddStep("expect totp verification", () => dummyAPI.SessionVerificationMethod = SessionVerificationMethod.TimedOneTimePassword);
+
+            AddStep("enter password", () => loginOverlay.ChildrenOfType<OsuPasswordTextBox>().First().Text = "password");
+            AddStep("submit", () => loginOverlay.ChildrenOfType<OsuButton>().First(b => b.Text.ToString() == "Sign in").TriggerClick());
+
+            assertAPIState(APIState.RequiresSecondFactorAuth);
+            AddUntilStep("wait for second factor auth form", () => loginOverlay.ChildrenOfType<SecondFactorAuthForm>().SingleOrDefault(), () => Is.Not.Null);
+
+            AddStep("set up verification handling", () => dummyAPI.HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case VerifySessionRequest verifySessionRequest:
+                        if (verifySessionRequest.VerificationKey == "deadbeef")
+                            verifySessionRequest.TriggerSuccess();
+                        else
+                            verifySessionRequest.TriggerFailure(new WebException());
+                        return true;
+
+                    case VerificationMailFallbackRequest verificationMailFallbackRequest:
+                        verificationMailFallbackRequest.TriggerSuccess();
+                        return true;
+                }
+
+                return false;
+            });
+
+            AddStep("request fallback to email", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<OsuSpriteText>().Single(t => t.Text.ToString().Contains("email", StringComparison.InvariantCultureIgnoreCase)));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("enter code", () => loginOverlay.ChildrenOfType<OsuTextBox>().First().Text = "deadbeef");
+            assertAPIState(APIState.Online);
+            assertDropdownState(UserAction.Online);
+
+            AddStep("set failing", () => { dummyAPI.SetState(APIState.Failing); });
+            AddStep("return to online", () => { dummyAPI.SetState(APIState.Online); });
+
+            AddStep("clear handler", () => dummyAPI.HandleRequest = null);
+
+            assertDropdownState(UserAction.Online);
+            AddStep("change user state", () => localConfig.SetValue(OsuSetting.UserOnlineStatus, UserStatus.DoNotDisturb));
+            assertDropdownState(UserAction.DoNotDisturb);
+        }
+
+        [Test]
+        public void TestLoginSuccess_TOTPVerification_TurnedOffMidwayThrough()
+        {
+            bool firstAttemptHandled = false;
+
+            AddStep("logout", () => API.Logout());
+            assertAPIState(APIState.Offline);
+            AddStep("expect totp verification", () => dummyAPI.SessionVerificationMethod = SessionVerificationMethod.TimedOneTimePassword);
+
+            AddStep("enter password", () => loginOverlay.ChildrenOfType<OsuPasswordTextBox>().First().Text = "password");
+            AddStep("submit", () => loginOverlay.ChildrenOfType<OsuButton>().First(b => b.Text.ToString() == "Sign in").TriggerClick());
+
+            assertAPIState(APIState.RequiresSecondFactorAuth);
+            AddUntilStep("wait for second factor auth form", () => loginOverlay.ChildrenOfType<SecondFactorAuthForm>().SingleOrDefault(), () => Is.Not.Null);
+
+            AddStep("set up verification handling", () => dummyAPI.HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case VerifySessionRequest verifySessionRequest:
+                        verifySessionRequest.RequiredVerificationMethod = SessionVerificationMethod.EmailMessage;
+                        verifySessionRequest.TriggerFailure(new WebException());
+                        firstAttemptHandled = true;
+                        return true;
+                }
+
+                return false;
+            });
+
+            AddStep("enter code", () => loginOverlay.ChildrenOfType<OsuTextBox>().First().Text = "123456");
+            AddUntilStep("first verification attempt handled", () => firstAttemptHandled);
+            assertAPIState(APIState.RequiresSecondFactorAuth);
+
+            AddStep("set up verification handling", () => dummyAPI.HandleRequest = req =>
+            {
+                switch (req)
+                {
+                    case VerifySessionRequest verifySessionRequest:
+                        if (verifySessionRequest.VerificationKey == "deadbeef")
+                            verifySessionRequest.TriggerSuccess();
+                        else
+                            verifySessionRequest.TriggerFailure(new WebException());
+                        return true;
+                }
+
+                return false;
+            });
+            AddStep("enter code", () => loginOverlay.ChildrenOfType<OsuTextBox>().First().Text = "deadbeef");
+            assertAPIState(APIState.Online);
+            assertDropdownState(UserAction.Online);
+        }
+
         private void assertDropdownState(UserAction state)
         {
             AddAssert($"dropdown state is {state}", () => loginOverlay.ChildrenOfType<UserDropdown>().First().Current.Value, () => Is.EqualTo(state));
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
index faf8f35a8e..0a042d189d 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
@@ -20,6 +20,7 @@ using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.UI;
+using osu.Game.Scoring;
 using osu.Game.Screens.OnlinePlay.Multiplayer.Spectate;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Play.HUD;
@@ -28,6 +29,7 @@ using osu.Game.Storyboards;
 using osu.Game.Tests.Beatmaps.IO;
 using osuTK;
 using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -302,9 +304,69 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddWaitStep("wait a bit", 10);
         }
 
+        [Test]
+        [Explicit("Test relies on timing of arriving frames to exercise assertions which doesn't work headless.")]
+        public void TestMaximisedUserIsAudioSource()
+        {
+            start(new[] { PLAYER_1_ID, PLAYER_2_ID });
+            loadSpectateScreen();
+
+            // With no frames, the synchronisation state will be TooFarAhead.
+            // In this state, all players should be muted.
+            assertMuted(PLAYER_1_ID, true);
+            assertMuted(PLAYER_2_ID, true);
+
+            // Send frames for both players.
+            sendFrames(PLAYER_1_ID, 20);
+            sendFrames(PLAYER_2_ID, 40);
+
+            waitUntilRunning(PLAYER_1_ID);
+            AddStep("maximise player 1", () =>
+            {
+                InputManager.MoveMouseTo(getInstance(PLAYER_1_ID));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertMuted(PLAYER_1_ID, false);
+            assertMuted(PLAYER_2_ID, true);
+
+            waitUntilPaused(PLAYER_1_ID);
+            assertMuted(PLAYER_1_ID, false);
+            assertMuted(PLAYER_2_ID, true);
+
+            AddStep("minimise player 1", () =>
+            {
+                InputManager.MoveMouseTo(getInstance(PLAYER_1_ID));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertMuted(PLAYER_1_ID, true);
+            assertMuted(PLAYER_2_ID, false);
+
+            AddStep("maximise player 2", () =>
+            {
+                InputManager.MoveMouseTo(getInstance(PLAYER_2_ID));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertMuted(PLAYER_1_ID, true);
+            assertMuted(PLAYER_2_ID, false);
+
+            waitUntilPaused(PLAYER_2_ID);
+            sendFrames(PLAYER_1_ID, 60);
+
+            assertMuted(PLAYER_1_ID, true);
+            assertMuted(PLAYER_2_ID, false);
+
+            AddStep("minimise player 2", () =>
+            {
+                InputManager.MoveMouseTo(getInstance(PLAYER_2_ID));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertMuted(PLAYER_1_ID, false);
+            assertMuted(PLAYER_2_ID, true);
+        }
+
         [Test]
         [FlakyTest]
-        public void TestMostInSyncUserIsAudioSource()
+        public void TestMostInSyncUserIsAudioSourceIfNoneMaximised()
         {
             start(new[] { PLAYER_1_ID, PLAYER_2_ID });
             loadSpectateScreen();
@@ -436,6 +498,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
             b.Storyboard.GetLayer("Background").Add(sprite);
         });
 
+        [Test]
+        public void TestFRankDisplay()
+        {
+            int[] userIds = getPlayerIds(1);
+
+            start(userIds);
+            loadSpectateScreen();
+
+            sendFrames(userIds, 1000);
+            AddUntilStep("player has F rank", () => this.ChildrenOfType<MultiSpectatorPlayer>().All(msp => msp.GameplayState.ScoreProcessor.Rank.Value == ScoreRank.F));
+        }
+
         private void testLeadIn(Action<WorkingBeatmap>? applyToBeatmap = null)
         {
             start(PLAYER_1_ID);
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
index 58473f5fa2..7f6fb97e0c 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
@@ -52,25 +52,25 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestBasicListChanges()
         {
-            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(5, withSpotlightRooms: true)));
+            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(5, withPinnedRooms: true)));
 
             AddAssert("has 5 rooms", () => container.DrawableRooms.Count == 5);
 
-            AddAssert("all spotlights at top", () => container.DrawableRooms
-                                                              .SkipWhile(r => r.Room.Category == RoomCategory.Spotlight)
-                                                              .All(r => r.Room.Category == RoomCategory.Normal));
+            AddAssert("all pinned at top", () => container.DrawableRooms
+                                                          .SkipWhile(r => r.Room.Pinned)
+                                                          .All(r => !r.Room.Pinned));
 
             AddStep("remove first room", () => rooms.RemoveAt(0));
             AddAssert("has 4 rooms", () => container.DrawableRooms.Count == 4);
             AddAssert("first room removed", () => container.DrawableRooms.All(r => r.Room.RoomID != 0));
 
             AddStep("select first room", () => container.DrawableRooms.First().TriggerClick());
-            AddAssert("first spotlight selected", () => checkRoomSelected(rooms.First(r => r.Category == RoomCategory.Spotlight)));
+            AddAssert("first pinned room selected", () => checkRoomSelected(rooms.First(r => r.Pinned)));
 
             AddStep("remove last room", () => rooms.RemoveAt(rooms.Count - 1));
-            AddAssert("first spotlight still selected", () => checkRoomSelected(rooms.First(r => r.Category == RoomCategory.Spotlight)));
+            AddAssert("first pinned room selected", () => checkRoomSelected(rooms.First(r => r.Pinned)));
 
-            AddStep("remove spotlight room", () => rooms.RemoveAll(r => r.Category == RoomCategory.Spotlight));
+            AddStep("remove pinned rooms", () => rooms.RemoveAll(r => r.Pinned));
             AddAssert("selection vacated", () => checkRoomSelected(null));
         }
 
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
index 037c5faae3..aa9dddae4d 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomPanel.cs
@@ -19,6 +19,7 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
+using osu.Game.Screens.OnlinePlay.Playlists;
 using osu.Game.Tests.Beatmaps;
 using osuTK;
 
@@ -38,10 +39,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create rooms", () =>
             {
-                PlaylistItem item1 = new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo)
+                PlaylistItem item1 = new PlaylistItem(new APIBeatmap
                 {
-                    BeatmapInfo = { StarRating = 2.5 }
-                }.BeatmapInfo);
+                    OnlineBeatmapSetID = 173612,
+                    OnlineID = 502132,
+                });
 
                 PlaylistItem item2 = new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo)
                 {
@@ -72,6 +74,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     Spacing = new Vector2(10),
                     Children = new Drawable[]
                     {
+                        createMultiplayerPanel(new Room
+                        {
+                            Name = "Multiplayer room",
+                            EndDate = DateTimeOffset.Now.AddDays(1),
+                            Type = MatchType.HeadToHead,
+                            Playlist = [item1],
+                            CurrentPlaylistItem = item1
+                        }),
                         createLoungeRoom(new Room
                         {
                             Name = "Multiplayer room",
@@ -81,6 +91,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
                             CurrentPlaylistItem = item1
                         }),
                         createLoungeRoom(new Room
+                        {
+                            Name = "Pinned room",
+                            Pinned = true,
+                            EndDate = DateTimeOffset.Now.AddDays(1),
+                            Type = MatchType.HeadToHead,
+                            Playlist = [item1],
+                            CurrentPlaylistItem = item1
+                        }),
+                        createLoungeRoom(new Room
                         {
                             Name = "Private room",
                             Password = "*",
@@ -89,6 +108,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
                             Playlist = [item3],
                             CurrentPlaylistItem = item3
                         }),
+                        createPlaylistRoomPanel(new Room
+                        {
+                            Name = "Playlist room with multiple beatmaps",
+                            Status = RoomStatus.Playing,
+                            EndDate = DateTimeOffset.Now.AddDays(1),
+                            Playlist = [item1, item2],
+                            CurrentPlaylistItem = item1
+                        }),
                         createLoungeRoom(new Room
                         {
                             Name = "Playlist room with multiple beatmaps",
@@ -121,9 +148,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 };
             });
 
-            AddUntilStep("wait for panel load", () => rooms.Count == 7);
-            AddUntilStep("correct status text", () => rooms.ChildrenOfType<OsuSpriteText>().Count(s => s.Text.ToString().StartsWith("Currently playing", StringComparison.Ordinal)) == 2);
-            AddUntilStep("correct status text", () => rooms.ChildrenOfType<OsuSpriteText>().Count(s => s.Text.ToString().StartsWith("Ready to play", StringComparison.Ordinal)) == 5);
+            AddUntilStep("wait for panel load", () => rooms.Count, () => Is.EqualTo(10));
+            AddUntilStep("\"currently playing\" room count correct",
+                () => rooms.ChildrenOfType<OsuSpriteText>().Count(s => s.Text.ToString().StartsWith("Currently playing", StringComparison.Ordinal)), () => Is.EqualTo(4));
+            AddUntilStep("\"ready to play\" room count correct", () => rooms.ChildrenOfType<OsuSpriteText>().Count(s => s.Text.ToString().StartsWith("Ready to play", StringComparison.Ordinal)),
+                () => Is.EqualTo(5));
         }
 
         [Test]
@@ -140,13 +169,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for panel load", () => panel.ChildrenOfType<DrawableRoomParticipantsList>().Any());
 
-            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.CornerIcon>().First().Alpha));
 
             AddStep("set password", () => room.Password = "password");
-            AddAssert("password icon visible", () => Precision.AlmostEquals(1, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon visible", () => Precision.AlmostEquals(1, panel.ChildrenOfType<RoomPanel.CornerIcon>().First().Alpha));
 
             AddStep("unset password", () => room.Password = string.Empty);
-            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.PasswordProtectedIcon>().Single().Alpha));
+            AddAssert("password icon hidden", () => Precision.AlmostEquals(0, panel.ChildrenOfType<RoomPanel.CornerIcon>().First().Alpha));
         }
 
         [Test]
@@ -198,7 +227,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 {
                     new MultiplayerRoomPanel(new Room
                     {
-                        Name = "This room has a very very long title enough to make the external link button reach the participants list on the right side unless the test window is very wide, at which point I don't know, hi.",
+                        Name =
+                            "This room has a very very long title enough to make the external link button reach the participants list on the right side unless the test window is very wide, at which point I don't know, hi.",
                         QueueMode = QueueMode.HostOnly,
                         Type = MatchType.HeadToHead,
                         RoomID = 1337,
@@ -222,7 +252,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 {
                     new MultiplayerRoomPanel(room = new Room
                     {
-                        Name = "This room has a very very long title enough to make the external link button reach the participants list on the right side unless the test window is very wide, at which point I don't know, hi.",
+                        Name =
+                            "This room has a very very long title enough to make the external link button reach the participants list on the right side unless the test window is very wide, at which point I don't know, hi.",
                         QueueMode = QueueMode.HostOnly,
                         Type = MatchType.HeadToHead,
                     }),
@@ -234,6 +265,41 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("clear room ID", () => room.RoomID = null);
         }
 
+        private RoomPanel createPlaylistRoomPanel(Room room)
+        {
+            room.Host ??= new APIUser { Username = "peppy", Id = 2 };
+
+            if (room.RecentParticipants.Count == 0)
+            {
+                room.RecentParticipants = Enumerable.Range(0, 20).Select(i => new APIUser
+                {
+                    Id = i,
+                    Username = $"User {i}"
+                }).ToArray();
+            }
+
+            return new PlaylistsRoomPanel(room)
+            {
+                SelectedItem = new Bindable<PlaylistItem?>(room.CurrentPlaylistItem),
+            };
+        }
+
+        private RoomPanel createMultiplayerPanel(Room room)
+        {
+            room.Host ??= new APIUser { Username = "peppy", Id = 2 };
+
+            if (room.RecentParticipants.Count == 0)
+            {
+                room.RecentParticipants = Enumerable.Range(0, 20).Select(i => new APIUser
+                {
+                    Id = i,
+                    Username = $"User {i}"
+                }).ToArray();
+            }
+
+            return new MultiplayerRoomPanel(room);
+        }
+
         private RoomPanel createLoungeRoom(Room room)
         {
             room.Host ??= new APIUser { Username = "peppy", Id = 2 };
diff --git a/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs b/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
index e7172cacbf..1dd39e5bf9 100644
--- a/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs
@@ -181,7 +181,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("beatmap in song select", () =>
             {
                 var songSelect = (SoloSongSelect)Game.ScreenStack.CurrentScreen;
-                return songSelect.ChildrenOfType<BeatmapCarousel>().Single().GetCarouselItems()!.Any(i => i.Model is BeatmapSetInfo bsi && bsi.MatchesOnlineID(getImport()));
+                return songSelect.ChildrenOfType<BeatmapCarousel>().Single().GetCarouselItems()!.Any(i => i.Model is GroupedBeatmapSet gbs && gbs.BeatmapSet.MatchesOnlineID(getImport()));
             });
         }
 
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
index 02b2db6e31..0e1fa63439 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneSkinEditorNavigation.cs
@@ -278,6 +278,8 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             advanceToSongSelect();
             openSkinEditor();
+            AddUntilStep("skin editor visible", () => skinEditor.State.Value == Visibility.Visible);
+
             AddStep("select autoplay", () => Game.SelectedMods.Value = new Mod[] { new OsuModAutoplay() });
             AddStep("import beatmap", () => BeatmapImportHelper.LoadQuickOszIntoOsu(Game).WaitSafely());
             AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
@@ -290,8 +292,9 @@ namespace osu.Game.Tests.Visual.Navigation
             AddAssert("settings not visible", () => getPlayerSettingsOverlay().DrawWidth, () => Is.EqualTo(0));
 
             toggleSkinEditor();
+            AddUntilStep("skin editor hidden", () => skinEditor.State.Value == Visibility.Hidden);
 
-            AddStep("move cursor slightly", () => InputManager.MoveMouseTo(InputManager.ScreenSpaceDrawQuad.TopRight + new Vector2(1)));
+            AddStep("move cursor slightly", () => InputManager.MoveMouseTo(InputManager.ScreenSpaceDrawQuad.TopRight + new Vector2(2)));
             AddUntilStep("settings visible", () => getPlayerSettingsOverlay().DrawWidth, () => Is.GreaterThan(0));
 
             AddStep("move cursor to right of screen too far", () => InputManager.MoveMouseTo(InputManager.ScreenSpaceDrawQuad.TopRight + new Vector2(10240, 0)));
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs
index 9a1f1dc515..f3e9d5b3ab 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneSongSelectNavigation.cs
@@ -9,6 +9,7 @@ using osu.Framework.Extensions;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
@@ -217,6 +218,26 @@ namespace osu.Game.Tests.Visual.Navigation
             AddAssert("leaderboard matches gameplay beatmap", () => Game.ChildrenOfType<LeaderboardManager>().Single().CurrentCriteria?.Beatmap, () => Is.EqualTo(beatmap().BeatmapInfo));
         }
 
+        [Test]
+        public void TestEnterKeyProgressesToGameplayEvenIfCarouselFilteredOut()
+        {
+            PushAndConfirm(() => new SoloSongSelect());
+
+            AddStep("import beatmap", () => BeatmapImportHelper.LoadOszIntoOsu(Game, virtualTrack: true).WaitSafely());
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("filter out active beatmap", () => this.ChildrenOfType<SearchTextBox>().First().Text = "abacadabadaeba");
+            AddUntilStep("wait for filter", () => this.ChildrenOfType<BeatmapCarousel>().Single().IsFiltering, () => Is.False);
+
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
+
+            AddUntilStep("player entered", () =>
+            {
+                DismissAnyNotifications();
+                return Game.ScreenStack.CurrentScreen is Player;
+            });
+        }
+
         private Func<Player> playToResults()
         {
             var player = playToCompletion();
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs
index db004b1d0d..8fcbcb2fbc 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneCollectionDropdown.cs
@@ -86,11 +86,11 @@ namespace osu.Game.Tests.Visual.SongSelect
             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));
+            AddUntilStep("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));
+            AddUntilStep("check count 2", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(2));
         }
 
         [Test]
@@ -185,11 +185,11 @@ namespace osu.Game.Tests.Visual.SongSelect
             assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
 
             addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection contains beatmap", () => getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            AddUntilStep("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));
+            AddUntilStep("collection does not contain beatmap", () => !getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
             assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
         }
 
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneTopLocalRank.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneTopLocalRank.cs
index 79baae53e8..93b9efed6a 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneTopLocalRank.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneTopLocalRank.cs
@@ -10,6 +10,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
 using osu.Game.Screens.Select.Carousel;
@@ -161,5 +163,53 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("SS rank displayed", () => topLocalRank.DisplayedRank == ScoreRank.X);
         }
+
+        [Test]
+        public void TestGuestScore()
+        {
+            AddStep("Add score for guest user", () =>
+            {
+                var testScoreInfo = TestResources.CreateTestScoreInfo(importedBeatmap);
+
+                testScoreInfo.User = new GuestUser();
+                testScoreInfo.Rank = ScoreRank.B;
+
+                scoreManager.Import(testScoreInfo);
+            });
+
+            AddUntilStep("B rank displayed", () => topLocalRank.DisplayedRank, () => Is.EqualTo(ScoreRank.B));
+        }
+
+        [Test]
+        public void TestUnknownUserScore()
+        {
+            AddStep("Add score for unknown user", () =>
+            {
+                var testScoreInfo = TestResources.CreateTestScoreInfo(importedBeatmap);
+
+                testScoreInfo.User = new APIUser { Username = "AAA", };
+                testScoreInfo.Rank = ScoreRank.S;
+
+                scoreManager.Import(testScoreInfo);
+            });
+
+            AddUntilStep("S rank displayed", () => topLocalRank.DisplayedRank, () => Is.EqualTo(ScoreRank.S));
+        }
+
+        [Test]
+        public void TestAnotherUserScore()
+        {
+            AddStep("Add score for not-current user", () =>
+            {
+                var testScoreInfo = TestResources.CreateTestScoreInfo(importedBeatmap);
+
+                testScoreInfo.User = new APIUser { Username = "notme", Id = 43, };
+                testScoreInfo.Rank = ScoreRank.S;
+
+                scoreManager.Import(testScoreInfo);
+            });
+
+            AddUntilStep("No rank displayed", () => topLocalRank.DisplayedRank, () => Is.Null);
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
index c8f1c1e017..dcd7a5a8fc 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselFilterGroupingTest.cs
@@ -42,8 +42,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             ];
 
             var results = await runGrouping(GroupMode.None, beatmapSets);
-            Assert.That(results.Select(r => r.Model).OfType<BeatmapSetInfo>(), Is.EquivalentTo(beatmapSets));
-            Assert.That(results.Select(r => r.Model).OfType<BeatmapInfo>(), Is.EquivalentTo(allBeatmaps));
+            Assert.That(results.Select(r => r.Model).OfType<GroupedBeatmapSet>().Select(groupedSet => groupedSet.BeatmapSet), Is.EquivalentTo(beatmapSets));
+            Assert.That(results.Select(r => r.Model).OfType<GroupedBeatmap>().Select(groupedBeatmap => groupedBeatmap.Beatmap), Is.EquivalentTo(allBeatmaps));
             assertTotal(results, beatmapSets.Count + allBeatmaps.Length);
         }
 
@@ -74,11 +74,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(applyBeatmap('_'), beatmapSets, out var underscoreBeatmap);
 
             var results = await runGrouping(mode, beatmapSets);
-            assertGroup(results, 0, "0-9", new[] { fiveBeatmap, fourBeatmap }, ref total);
-            assertGroup(results, 1, "A", new[] { aBeatmap }, ref total);
-            assertGroup(results, 2, "F", new[] { fBeatmap }, ref total);
-            assertGroup(results, 3, "Z", new[] { zBeatmap }, ref total);
-            assertGroup(results, 4, "Other", new[] { dashBeatmap, underscoreBeatmap }, ref total);
+            assertGroup(results, 0, "0-9", fiveBeatmap.Beatmaps.Concat(fourBeatmap.Beatmaps), ref total);
+            assertGroup(results, 1, "A", aBeatmap.Beatmaps, ref total);
+            assertGroup(results, 2, "F", fBeatmap.Beatmaps, ref total);
+            assertGroup(results, 3, "Z", zBeatmap.Beatmaps, ref total);
+            assertGroup(results, 4, "Other", dashBeatmap.Beatmaps.Concat(underscoreBeatmap.Beatmaps), ref total);
             assertTotal(results, total);
         }
 
@@ -115,12 +115,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(s => s.DateAdded = DateTimeOffset.Now.AddMonths(-2).AddDays(-3), beatmapSets, out var twoMonthsAgoBeatmap);
 
             var results = await runGrouping(GroupMode.DateAdded, beatmapSets);
-            assertGroup(results, 0, "Today", new[] { todayBeatmap }, ref total);
-            assertGroup(results, 1, "Yesterday", new[] { yesterdayBeatmap }, ref total);
-            assertGroup(results, 2, "Last week", new[] { lastWeekBeatmap }, ref total);
-            assertGroup(results, 3, "Last month", new[] { lastMonthBeatmap }, ref total);
-            assertGroup(results, 4, "1 month ago", new[] { oneMonthAgoBeatmap }, ref total);
-            assertGroup(results, 5, "2 months ago", new[] { twoMonthsAgoBeatmap }, ref total);
+            assertGroup(results, 0, "Today", todayBeatmap.Beatmaps, ref total);
+            assertGroup(results, 1, "Yesterday", yesterdayBeatmap.Beatmaps, ref total);
+            assertGroup(results, 2, "Last week", lastWeekBeatmap.Beatmaps, ref total);
+            assertGroup(results, 3, "Last month", lastMonthBeatmap.Beatmaps, ref total);
+            assertGroup(results, 4, "1 month ago", oneMonthAgoBeatmap.Beatmaps, ref total);
+            assertGroup(results, 5, "2 months ago", twoMonthsAgoBeatmap.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -139,13 +139,13 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(applyLastPlayed(null), beatmapSets, out var neverBeatmap);
 
             var results = await runGrouping(GroupMode.LastPlayed, beatmapSets);
-            assertGroup(results, 0, "Today", new[] { todayBeatmap }, ref total);
-            assertGroup(results, 1, "Yesterday", new[] { yesterdayBeatmap }, ref total);
-            assertGroup(results, 2, "Last week", new[] { lastWeekBeatmap }, ref total);
-            assertGroup(results, 3, "Last month", new[] { lastMonthBeatmap }, ref total);
-            assertGroup(results, 4, "1 month ago", new[] { oneMonthAgoBeatmap }, ref total);
-            assertGroup(results, 5, "2 months ago", new[] { twoMonthsBeatmap }, ref total);
-            assertGroup(results, 6, "Never", new[] { neverBeatmap }, ref total);
+            assertGroup(results, 0, "Today", todayBeatmap.Beatmaps, ref total);
+            assertGroup(results, 1, "Yesterday", yesterdayBeatmap.Beatmaps, ref total);
+            assertGroup(results, 2, "Last week", lastWeekBeatmap.Beatmaps, ref total);
+            assertGroup(results, 3, "Last month", lastMonthBeatmap.Beatmaps, ref total);
+            assertGroup(results, 4, "1 month ago", oneMonthAgoBeatmap.Beatmaps, ref total);
+            assertGroup(results, 5, "2 months ago", twoMonthsBeatmap.Beatmaps, ref total);
+            assertGroup(results, 6, "Never", neverBeatmap.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -162,7 +162,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             var results = await runGrouping(GroupMode.LastPlayed, beatmapSets);
             int total = 0;
 
-            assertGroup(results, 0, "Today", new[] { set }, ref total);
+            assertGroup(results, 0, "Today", [set.Beatmaps[2]], ref total);
+            assertGroup(results, 1, "Never", [set.Beatmaps[0], set.Beatmaps[1]], ref total);
             assertTotal(results, total);
         }
 
@@ -176,8 +177,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             var results = await runGrouping(GroupMode.LastPlayed, beatmapSets);
             int total = 0;
 
-            assertGroup(results, 0, "Over 5 months ago", new[] { overFiveMonthsBeatmap }, ref total);
-            assertGroup(results, 1, "Never", new[] { neverBeatmap }, ref total);
+            assertGroup(results, 0, "Over 5 months ago", overFiveMonthsBeatmap.Beatmaps, ref total);
+            assertGroup(results, 1, "Never", neverBeatmap.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -207,14 +208,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(s => s.Status = BeatmapOnlineStatus.LocallyModified, beatmapSets, out var localBeatmap);
 
             var results = await runGrouping(GroupMode.RankedStatus, beatmapSets);
-            assertGroup(results, 0, "Ranked", new[] { rankedBeatmap, approvedBeatmap }, ref total);
-            assertGroup(results, 1, "Qualified", new[] { qualifiedBeatmap }, ref total);
-            assertGroup(results, 2, "WIP", new[] { wipBeatmap }, ref total);
-            assertGroup(results, 3, "Pending", new[] { pendingBeatmap }, ref total);
-            assertGroup(results, 4, "Graveyard", new[] { graveyardBeatmap }, ref total);
-            assertGroup(results, 5, "Local", new[] { localBeatmap }, ref total);
-            assertGroup(results, 6, "Unknown", new[] { noneBeatmap }, ref total);
-            assertGroup(results, 7, "Loved", new[] { lovedBeatmap }, ref total);
+            assertGroup(results, 0, "Ranked", rankedBeatmap.Beatmaps.Concat(approvedBeatmap.Beatmaps), ref total);
+            assertGroup(results, 1, "Qualified", qualifiedBeatmap.Beatmaps, ref total);
+            assertGroup(results, 2, "WIP", wipBeatmap.Beatmaps, ref total);
+            assertGroup(results, 3, "Pending", pendingBeatmap.Beatmaps, ref total);
+            assertGroup(results, 4, "Graveyard", graveyardBeatmap.Beatmaps, ref total);
+            assertGroup(results, 5, "Local", localBeatmap.Beatmaps, ref total);
+            assertGroup(results, 6, "Unknown", noneBeatmap.Beatmaps, ref total);
+            assertGroup(results, 7, "Loved", lovedBeatmap.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -240,12 +241,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(applyBPM(330), beatmapSets, out var beatmap330);
 
             var results = await runGrouping(GroupMode.BPM, beatmapSets);
-            assertGroup(results, 0, "Under 60 BPM", new[] { beatmap30 }, ref total);
-            assertGroup(results, 1, "60 - 70 BPM", new[] { beatmap59, beatmap60 }, ref total);
-            assertGroup(results, 2, "90 - 100 BPM", new[] { beatmap90, beatmap95 }, ref total);
-            assertGroup(results, 3, "270 - 280 BPM", new[] { beatmap269, beatmap270 }, ref total);
-            assertGroup(results, 4, "290 - 300 BPM", new[] { beatmap299 }, ref total);
-            assertGroup(results, 5, "Over 300 BPM", new[] { beatmap300, beatmap330 }, ref total);
+            assertGroup(results, 0, "Under 60 BPM", beatmap30.Beatmaps, ref total);
+            assertGroup(results, 1, "60 - 70 BPM", (beatmap59.Beatmaps.Concat(beatmap60.Beatmaps)), ref total);
+            assertGroup(results, 2, "90 - 100 BPM", (beatmap90.Beatmaps.Concat(beatmap95.Beatmaps)), ref total);
+            assertGroup(results, 3, "270 - 280 BPM", (beatmap269.Beatmaps.Concat(beatmap270.Beatmaps)), ref total);
+            assertGroup(results, 4, "290 - 300 BPM", beatmap299.Beatmaps, ref total);
+            assertGroup(results, 5, "Over 300 BPM", (beatmap300.Beatmaps.Concat(beatmap330.Beatmaps)), ref total);
             assertTotal(results, total);
         }
 
@@ -272,10 +273,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(applyStars(7), beatmapSets, out var beatmap7);
 
             var results = await runGrouping(GroupMode.Difficulty, beatmapSets);
-            assertGroup(results, 0, "Below 1 Star", new[] { beatmapBelow1 }, ref total);
-            assertGroup(results, 1, "1 Star", new[] { beatmapAbove1, beatmapAlmost2 }, ref total);
-            assertGroup(results, 2, "2 Stars", new[] { beatmap2, beatmapAbove2 }, ref total);
-            assertGroup(results, 3, "7 Stars", new[] { beatmap7 }, ref total);
+            assertGroup(results, 0, "Below 1 Star", beatmapBelow1.Beatmaps, ref total);
+            assertGroup(results, 1, "1 Star", (beatmapAbove1.Beatmaps.Concat(beatmapAlmost2.Beatmaps)), ref total);
+            assertGroup(results, 2, "2 Stars", (beatmap2.Beatmaps.Concat(beatmapAbove2.Beatmaps)), ref total);
+            assertGroup(results, 3, "7 Stars", beatmap7.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -304,11 +305,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(applyLength(630_000), beatmapSets, out var beatmap10Min30Sec);
 
             var results = await runGrouping(GroupMode.Length, beatmapSets);
-            assertGroup(results, 0, "1 minute or less", new[] { beatmap30Sec, beatmap1Min }, ref total);
-            assertGroup(results, 1, "2 minutes or less", new[] { beatmap1Min30Sec, beatmap2Min }, ref total);
-            assertGroup(results, 2, "5 minutes or less", new[] { beatmap5Min }, ref total);
-            assertGroup(results, 3, "10 minutes or less", new[] { beatmap6Min, beatmap10Min }, ref total);
-            assertGroup(results, 4, "Over 10 minutes", new[] { beatmap10Min30Sec }, ref total);
+            assertGroup(results, 0, "1 minute or less", (beatmap30Sec.Beatmaps.Concat(beatmap1Min.Beatmaps)), ref total);
+            assertGroup(results, 1, "2 minutes or less", (beatmap1Min30Sec.Beatmaps.Concat(beatmap2Min.Beatmaps)), ref total);
+            assertGroup(results, 2, "5 minutes or less", beatmap5Min.Beatmaps, ref total);
+            assertGroup(results, 3, "10 minutes or less", (beatmap6Min.Beatmaps.Concat(beatmap10Min.Beatmaps)), ref total);
+            assertGroup(results, 4, "Over 10 minutes", beatmap10Min30Sec.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -334,10 +335,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(s => s.DateRanked = null, beatmapSets, out var beatmapUnranked);
 
             var results = await runGrouping(GroupMode.DateRanked, beatmapSets);
-            assertGroup(results, 0, "2025", new[] { beatmap2025 }, ref total);
-            assertGroup(results, 1, "2010", new[] { beatmap2010 }, ref total);
-            assertGroup(results, 2, "2007", new[] { beatmapOct2007, beatmapDec2007 }, ref total);
-            assertGroup(results, 3, "Unranked", new[] { beatmapUnranked }, ref total);
+            assertGroup(results, 0, "2025", beatmap2025.Beatmaps, ref total);
+            assertGroup(results, 1, "2010", beatmap2010.Beatmaps, ref total);
+            assertGroup(results, 2, "2007", (beatmapOct2007.Beatmaps.Concat(beatmapDec2007.Beatmaps)), ref total);
+            assertGroup(results, 3, "Unranked", beatmapUnranked.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -357,9 +358,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             addBeatmapSet(s => s.Beatmaps[0].Metadata.Source = string.Empty, beatmapSets, out var beatmapUnsourced);
 
             var results = await runGrouping(GroupMode.Source, beatmapSets);
-            assertGroup(results, 0, "Cool Game", new[] { beatmapCoolGame, beatmapCoolGameB }, ref total);
-            assertGroup(results, 1, "Nice Movie", new[] { beatmapNiceMovie }, ref total);
-            assertGroup(results, 2, "Unsourced", new[] { beatmapUnsourced }, ref total);
+            assertGroup(results, 0, "Cool Game", (beatmapCoolGame.Beatmaps.Concat(beatmapCoolGameB.Beatmaps)), ref total);
+            assertGroup(results, 1, "Nice Movie", beatmapNiceMovie.Beatmaps, ref total);
+            assertGroup(results, 2, "Unsourced", beatmapUnsourced.Beatmaps, ref total);
             assertTotal(results, total);
         }
 
@@ -375,7 +376,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             return await groupingFilter.Run(beatmapSets.SelectMany(s => s.Beatmaps.Select(b => new CarouselItem(b))).ToList(), CancellationToken.None);
         }
 
-        private static void assertGroup(List<CarouselItem> items, int index, string expectedTitle, IEnumerable<BeatmapSetInfo> expectedBeatmapSets, ref int totalItems)
+        private static void assertGroup(List<CarouselItem> items, int index, string expectedTitle, IEnumerable<BeatmapInfo> expectedBeatmaps, ref int totalItems)
         {
             var groupItem = items.Where(i => i.Model is GroupDefinition).ElementAtOrDefault(index);
 
@@ -389,8 +390,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             var groupModel = (GroupDefinition)groupItem.Model;
 
-            Assert.That(groupModel.Title, Is.EqualTo(expectedTitle));
-            Assert.That(itemsInGroup.Select(i => i.Model).OfType<BeatmapInfo>(), Is.EquivalentTo(expectedBeatmapSets.SelectMany(bs => bs.Beatmaps)));
+            Assert.That(groupModel.Title.ToString(), Is.EqualTo(expectedTitle));
+            Assert.That(itemsInGroup.Select(i => i.Model).OfType<GroupedBeatmap>().Select(gb => gb.Beatmap), Is.EquivalentTo(expectedBeatmaps));
 
             totalItems += itemsInGroup.Count() + 1;
         }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
index bc507fbffa..02c017f570 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/BeatmapCarouselTestScene.cs
@@ -16,11 +16,13 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Collections;
 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.Scoring;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -70,6 +72,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             Scheduler.AddDelayed(updateStats, 100, true);
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Dependencies.Cache(Realm);
+        }
+
         protected void CreateCarousel()
         {
             AddStep("create components", () =>
@@ -115,13 +123,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                                     NewItemsPresented = _ => NewItemsPresentedInvocationCount++,
                                     RequestSelection = b =>
                                     {
-                                        BeatmapRequestedSelections.Push(b);
-                                        Carousel.CurrentSelection = b;
+                                        BeatmapRequestedSelections.Push(b.Beatmap);
+                                        Carousel.CurrentGroupedBeatmap = b;
                                     },
-                                    RequestRecommendedSelection = beatmaps =>
+                                    RequestRecommendedSelection = groupedBeatmaps =>
                                     {
-                                        BeatmapSetRequestedSelections.Push(beatmaps.First().BeatmapSet!);
-                                        Carousel.CurrentSelection = BeatmapRecommendationFunction?.Invoke(beatmaps) ?? beatmaps.First();
+                                        var recommendedBeatmap = BeatmapRecommendationFunction?.Invoke(groupedBeatmaps.Select(gb => gb.Beatmap)) ?? groupedBeatmaps.First().Beatmap;
+                                        var recommendedGroupedBeatmap = groupedBeatmaps.First(gb => gb.Beatmap.Equals(recommendedBeatmap));
+                                        BeatmapSetRequestedSelections.Push(recommendedBeatmap.BeatmapSet!);
+                                        Carousel.CurrentGroupedBeatmap = recommendedGroupedBeatmap;
                                     },
                                     BleedTop = 50,
                                     BleedBottom = 50,
@@ -215,8 +225,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
         protected void Select() => AddStep("select", () => InputManager.Key(Key.Enter));
 
-        protected void CheckNoSelection() => AddAssert("has no selection", () => Carousel.CurrentSelection, () => Is.Null);
-        protected void CheckHasSelection() => AddAssert("has selection", () => Carousel.CurrentSelection, () => Is.Not.Null);
+        protected void CheckNoSelection() => AddAssert("has no selection", () => Carousel.CurrentGroupedBeatmap, () => Is.Null);
+        protected void CheckHasSelection() => AddAssert("has selection", () => Carousel.CurrentGroupedBeatmap, () => Is.Not.Null);
 
         protected void CheckRequestPresentCount(int expected) =>
             AddAssert($"check present count is {expected}", () => Carousel.RequestPresentBeatmapCount, () => Is.EqualTo(expected));
@@ -237,7 +247,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
                 // Using groupingFilter.SetItems.Count alone doesn't work.
                 // When sorting by difficulty, there can be more than one set panel for the same set displayed.
-                return groupingFilter.SetItems.Sum(s => s.Value.Count(i => i.Model is BeatmapSetInfo));
+                return groupingFilter.SetItems.Sum(s => s.Value.Count(i => i.Model is GroupedBeatmapSet));
             }, () => Is.EqualTo(expected));
         }
 
@@ -281,8 +291,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 // offset by one because the group itself is included in the items list.
                 CarouselItem item = groupingFilter.GroupItems[groupDefinition].ElementAt(panel + 1);
 
-                return (Carousel.CurrentSelection as BeatmapInfo)?
-                    .Equals(item.Model as BeatmapInfo) == true;
+                return Carousel.CurrentGroupedBeatmap?.Equals(item.Model as GroupedBeatmap) == true;
             });
         }
 
@@ -291,12 +300,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             if (diff != null)
             {
                 AddUntilStep($"selected is set{set} diff{diff.Value}",
-                    () => (Carousel.CurrentSelection as BeatmapInfo),
+                    () => Carousel.CurrentBeatmap,
                     () => Is.EqualTo(BeatmapSets[set].Beatmaps[diff.Value]));
             }
             else
             {
-                AddUntilStep($"selected is set{set}", () => BeatmapSets[set].Beatmaps.Contains(Carousel.CurrentSelection));
+                AddUntilStep($"selected is set{set}", () => BeatmapSets[set].Beatmaps.Contains(Carousel.CurrentBeatmap!));
             }
         }
 
@@ -415,7 +424,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                                 tracked: {Carousel.ItemsTracked}
                                 displayable: {Carousel.DisplayableItems}
                                 displayed: {Carousel.VisibleItems}
-                                selected: {Carousel.CurrentSelection}
+                                selected: {Carousel.CurrentGroupedBeatmap}
                                 """);
 
             void createHeader(string text)
@@ -437,12 +446,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             public IEnumerable<BeatmapInfo> PostFilterBeatmaps = null!;
 
-            public BeatmapInfo? SelectedBeatmapInfo => CurrentSelection as BeatmapInfo;
+            public BeatmapInfo? SelectedBeatmapInfo => (CurrentSelection as GroupedBeatmap)?.Beatmap;
             public BeatmapSetInfo? SelectedBeatmapSet => SelectedBeatmapInfo?.BeatmapSet;
 
-            public new BeatmapSetInfo? ExpandedBeatmapSet => base.ExpandedBeatmapSet;
+            public new GroupedBeatmapSet? ExpandedBeatmapSet => base.ExpandedBeatmapSet;
             public new GroupDefinition? ExpandedGroup => base.ExpandedGroup;
 
+            public Func<List<BeatmapCollection>> AllCollections { get; set; } = () => [];
+            public Func<FilterCriteria, Dictionary<Guid, ScoreRank>> BeatmapInfoGuidToTopRankMapping { get; set; } = _ => new Dictionary<Guid, ScoreRank>();
+
             public TestBeatmapCarousel()
             {
                 RequestPresentBeatmap = _ => RequestPresentBeatmapCount++;
@@ -461,9 +473,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 if (FilterDelay != 0)
                     await Task.Delay(FilterDelay).ConfigureAwait(true);
 
-                PostFilterBeatmaps = items.Select(i => i.Model).OfType<BeatmapInfo>();
+                PostFilterBeatmaps = items.Select(i => i.Model).OfType<GroupedBeatmap>().Select(i => i.Beatmap);
                 return items;
             }
+
+            protected override List<BeatmapCollection> GetAllCollections() => AllCollections.Invoke();
+            protected override Dictionary<Guid, ScoreRank> GetBeatmapInfoGuidToTopRankMapping(FilterCriteria criteria) => BeatmapInfoGuidToTopRankMapping.Invoke(criteria);
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
index b1d1ed8c61..e3b02e5905 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/SongSelectTestScene.cs
@@ -22,8 +22,6 @@ using osu.Game.Overlays.Toolbar;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
-using osu.Game.Screens;
-using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -43,9 +41,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         protected Screens.SelectV2.SongSelect SongSelect { get; private set; } = null!;
         protected BeatmapCarousel Carousel => SongSelect.ChildrenOfType<BeatmapCarousel>().Single();
 
-        [Cached]
-        protected readonly ScreenFooter Footer;
-
         [Cached]
         private readonly OsuLogo logo;
 
@@ -72,10 +67,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                         {
                             State = { Value = Visibility.Visible },
                         },
-                        Footer = new ScreenFooter
-                        {
-                            BackButtonPressed = () => Stack.CurrentScreen.Exit(),
-                        },
                         logo = new OsuLogo
                         {
                             Alpha = 0f,
@@ -111,14 +102,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             Add(beatmapStore);
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Stack.ScreenPushed += updateFooter;
-            Stack.ScreenExited += updateFooter;
-        }
-
         public override void SetUpSteps()
         {
             base.SetUpSteps();
@@ -207,38 +190,5 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         }
 
         protected void WaitForSuspension() => AddUntilStep("wait for not current", () => !SongSelect.AsNonNull().IsCurrentScreen());
-
-        private void updateFooter(IScreen? _, IScreen? newScreen)
-        {
-            if (newScreen is OsuScreen osuScreen && osuScreen.ShowFooter)
-            {
-                Footer.Show();
-
-                if (osuScreen.IsLoaded)
-                    updateFooterButtons();
-                else
-                {
-                    // ensure the current buttons are immediately disabled on screen change (so they can't be pressed).
-                    Footer.SetButtons(Array.Empty<ScreenFooterButton>());
-
-                    osuScreen.OnLoadComplete += _ => updateFooterButtons();
-                }
-
-                void updateFooterButtons()
-                {
-                    var buttons = osuScreen.CreateFooterButtons();
-
-                    osuScreen.LoadComponentsAgainstScreenDependencies(buttons);
-
-                    Footer.SetButtons(buttons);
-                    Footer.Show();
-                }
-            }
-            else
-            {
-                Footer.Hide();
-                Footer.SetButtons(Array.Empty<ScreenFooterButton>());
-            }
-        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
index 521221f0c7..1178f89da6 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselArtistGrouping.cs
@@ -4,7 +4,6 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -81,7 +80,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             CheckHasSelection();
             AddAssert("drawable selection non-null", () => selection, () => Is.Not.Null);
-            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
 
             RemoveAllBeatmaps();
             AddUntilStep("no drawable selection", GetSelectedPanel, () => Is.Null);
@@ -92,9 +91,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckHasSelection();
             AddAssert("no drawable selection", GetSelectedPanel, () => Is.Null);
 
-            AddStep("add previous selection", () => BeatmapSets.Add(((BeatmapInfo)selection!).BeatmapSet!));
+            AddStep("add previous selection", () => BeatmapSets.Add(((GroupedBeatmap)selection!).Beatmap.BeatmapSet!));
 
-            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
             AddUntilStep("drawable selection restored", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(selection));
             AddAssert("carousel item is visible", () => GetSelectedPanel()?.Item?.IsVisible, () => Is.True);
 
@@ -132,7 +131,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             WaitForBeatmapSelection(0, 1);
             // Expanding a group will move keyboard selection to the selected beatmap if contained.
             AddAssert("keyboard selected panel is expanded", () => groupPanel?.Expanded.Value, () => Is.True);
-            AddAssert("keyboard selected panel is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, Is.TypeOf<BeatmapInfo>);
+            AddAssert("keyboard selected panel is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, Is.TypeOf<GroupedBeatmap>);
         }
 
         [Test]
@@ -250,5 +249,39 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckDisplayedBeatmapSetsCount(10);
             CheckDisplayedBeatmapsCount(30);
         }
+
+        [Test]
+        public void TestGroupDoesNotExpandAgainOnRefilterIfManuallyCollapsed()
+        {
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = BeatmapSets[2].Metadata.Title);
+
+            CheckDisplayedGroupsCount(1);
+            CheckDisplayedBeatmapSetsCount(1);
+            CheckDisplayedBeatmapsCount(3);
+
+            CheckHasSelection();
+
+            ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
+
+            CheckDisplayedGroupsCount(5);
+            CheckDisplayedBeatmapSetsCount(10);
+            CheckDisplayedBeatmapsCount(30);
+
+            ToggleGroupCollapse();
+
+            ApplyToFilterAndWaitForFilter("apply no-op filter", c => c.AllowConvertedBeatmaps = !c.AllowConvertedBeatmaps);
+            AddAssert("group didn't re-expand", () => Carousel.ExpandedGroup, () => Is.Null);
+
+            ToggleGroupCollapse();
+            AddAssert("beatmap set re-expanded correctly", () => Carousel.ExpandedBeatmapSet?.BeatmapSet, () => Is.EqualTo(BeatmapSets[2]));
+
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = BeatmapSets[1].Metadata.Title);
+
+            CheckDisplayedGroupsCount(1);
+            CheckDisplayedBeatmapSetsCount(1);
+            CheckDisplayedBeatmapsCount(3);
+
+            CheckHasSelection();
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselCollectionGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselCollectionGrouping.cs
new file mode 100644
index 0000000000..e410d66ce8
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselCollectionGrouping.cs
@@ -0,0 +1,66 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Collections;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Tests.Visual.SongSelectV2
+{
+    [TestFixture]
+    public partial class TestSceneBeatmapCarouselCollectionGrouping : BeatmapCarouselTestScene
+    {
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            RemoveAllBeatmaps();
+            CreateCarousel();
+
+            AddBeatmaps(10, 3);
+
+            AddStep("set up collections", () =>
+            {
+                List<BeatmapCollection> collections =
+                [
+                    new BeatmapCollection("collection one", [
+                        ..BeatmapSets[0].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[1].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[2].Beatmaps.Select(b => b.MD5Hash),
+                        BeatmapSets[5].Beatmaps[1].MD5Hash,
+                        BeatmapSets[8].Beatmaps[0].MD5Hash,
+                    ]),
+                    new BeatmapCollection("collection two", [
+                        BeatmapSets[0].Beatmaps[0].MD5Hash,
+                        ..BeatmapSets[1].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[2].Beatmaps.Select(b => b.MD5Hash),
+                        BeatmapSets[6].Beatmaps[2].MD5Hash,
+                        BeatmapSets[8].Beatmaps[2].MD5Hash,
+                    ]),
+                    new BeatmapCollection("collection one copy", [
+                        ..BeatmapSets[0].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[1].Beatmaps.Select(b => b.MD5Hash),
+                        ..BeatmapSets[2].Beatmaps.Select(b => b.MD5Hash),
+                        BeatmapSets[5].Beatmaps[1].MD5Hash,
+                        BeatmapSets[8].Beatmaps[0].MD5Hash,
+                    ]),
+                ];
+                Carousel.AllCollections = () => collections;
+            });
+
+            SortAndGroupBy(SortMode.Title, GroupMode.Collections);
+            WaitForDrawablePanels();
+        }
+
+        [Test]
+        public void TestMultipleCopiesOfBeatmapsPresent()
+        {
+            CheckDisplayedGroupsCount(4); // one for each collection, plus no collections
+            // all three collections have beatmaps from 5 beatmap sets
+            // 7 beatmap sets have beatmaps which belong to no collection
+            CheckDisplayedBeatmapSetsCount(5 + 5 + 5 + 7);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
index 2ab0eda172..2cffe60ec1 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselDifficultyGrouping.cs
@@ -4,7 +4,6 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
@@ -71,7 +70,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             CheckHasSelection();
             AddAssert("drawable selection non-null", () => selection, () => Is.Not.Null);
-            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
 
             RemoveAllBeatmaps();
             AddUntilStep("no drawable selection", GetSelectedPanel, () => Is.Null);
@@ -82,9 +81,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckHasSelection();
             AddAssert("no drawable selection", GetSelectedPanel, () => Is.Null);
 
-            AddStep("add previous selection", () => BeatmapSets.Add(((BeatmapInfo)selection!).BeatmapSet!));
+            AddStep("add previous selection", () => BeatmapSets.Add(((GroupedBeatmap)selection!).Beatmap.BeatmapSet!));
 
-            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
             AddUntilStep("drawable selection restored", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(selection));
             AddAssert("carousel item is visible", () => GetSelectedPanel()?.Item?.IsVisible, () => Is.True);
 
@@ -121,7 +120,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             WaitForBeatmapSelection(0, 0);
             // Expanding a group will move keyboard selection to the selected beatmap if contained.
             AddAssert("keyboard selected panel is expanded", () => groupPanel?.Expanded.Value, () => Is.True);
-            AddAssert("keyboard selected panel is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, Is.TypeOf<BeatmapInfo>);
+            AddAssert("keyboard selected panel is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, Is.TypeOf<GroupedBeatmap>);
         }
 
         [Test]
@@ -199,7 +198,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         }
 
         private void checkBeatmapIsKeyboardSelected() =>
-            AddUntilStep("check keyboard selected group is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddUntilStep("check keyboard selected group is beatmap", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
 
         private void checkGroupKeyboardSelected(int index) => AddUntilStep($"check keyboard selected group is {index}", () => GetKeyboardSelectedPanel()?.Item?.Model, () =>
         {
@@ -338,5 +337,31 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddAssert("expanded group is still first", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(0));
         }
+
+        [Test]
+        public void TestExpandedGroupDoesNotExpandAgainOnRefilterIfManuallyCollapsed()
+        {
+            SelectPrevSet();
+
+            WaitForBeatmapSelection(2, 9);
+            AddAssert("expanded group is last", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(6));
+
+            SelectNextPanel();
+            Select();
+
+            WaitForBeatmapSelection(2, 9);
+            AddAssert("expanded group is first", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(0));
+
+            ToggleGroupCollapse();
+
+            // doesn't actually filter anything away, but triggers a filter.
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = "Some");
+            AddAssert("group didn't re-expand", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.Null);
+
+            ToggleGroupCollapse();
+
+            ApplyToFilterAndWaitForFilter("filter", c => c.SearchText = "Som");
+            AddAssert("expanded group is first", () => (Carousel.ExpandedGroup as StarDifficultyGroupDefinition)?.Difficulty.Stars, () => Is.EqualTo(0));
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs
index 78c12e2730..b1bd9fd3ed 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselFiltering.cs
@@ -130,14 +130,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextPanel();
             Select();
 
-            AddStep("record selection", () => selectedID = ((BeatmapInfo)Carousel.CurrentSelection!).ID);
+            AddStep("record selection", () => selectedID = Carousel.CurrentBeatmap!.ID);
 
             for (int i = 0; i < 5; i++)
             {
                 ApplyToFilterAndWaitForFilter("filter all", c => c.SearchText = Guid.NewGuid().ToString());
-                AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
+                AddAssert("selection not changed", () => Carousel.CurrentBeatmap!.ID == selectedID);
                 ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
-                AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
+                AddAssert("selection not changed", () => Carousel.CurrentBeatmap!.ID == selectedID);
             }
         }
 
@@ -177,14 +177,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             SelectNextSet();
 
-            AddStep("record selection", () => selectedID = ((BeatmapInfo)Carousel.CurrentSelection!).ID);
+            AddStep("record selection", () => selectedID = Carousel.CurrentBeatmap!.ID);
 
             for (int i = 0; i < 5; i++)
             {
                 ApplyToFilterAndWaitForFilter("filter all", c => c.SearchText = Guid.NewGuid().ToString());
-                AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
+                AddAssert("selection not changed", () => Carousel.CurrentBeatmap!.ID == selectedID);
                 ApplyToFilterAndWaitForFilter("remove filter", c => c.SearchText = string.Empty);
-                AddAssert("selection not changed", () => ((BeatmapInfo)Carousel.CurrentSelection!).ID == selectedID);
+                AddAssert("selection not changed", () => Carousel.CurrentBeatmap!.ID == selectedID);
             }
         }
 
@@ -200,14 +200,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             {
                 int diff = i;
 
-                AddStep($"select diff {diff}", () => Carousel.CurrentSelection = chosenBeatmap = BeatmapSets[20].Beatmaps[diff]);
-                AddUntilStep("selection changed", () => Carousel.CurrentSelection, () => Is.EqualTo(chosenBeatmap));
+                AddStep($"select diff {diff}", () => Carousel.CurrentBeatmap = chosenBeatmap = BeatmapSets[20].Beatmaps[diff]);
+                AddUntilStep("selection changed", () => Carousel.CurrentBeatmap, () => Is.EqualTo(chosenBeatmap));
 
                 SortBy(SortMode.Difficulty);
-                AddAssert("selection retained", () => Carousel.CurrentSelection, () => Is.EqualTo(chosenBeatmap));
+                AddAssert("selection retained", () => Carousel.CurrentBeatmap, () => Is.EqualTo(chosenBeatmap));
 
                 SortBy(SortMode.Title);
-                AddAssert("selection retained", () => Carousel.CurrentSelection, () => Is.EqualTo(chosenBeatmap));
+                AddAssert("selection retained", () => Carousel.CurrentBeatmap, () => Is.EqualTo(chosenBeatmap));
             }
         }
 
@@ -239,7 +239,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 var visibleBeatmapPanels = GetVisiblePanels<PanelBeatmap>();
 
                 return visibleBeatmapPanels.Count() == 1
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 0) == 1;
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 0) == 1;
             });
 
             ApplyToFilterAndWaitForFilter("filter to taiko", c => c.Ruleset = rulesets.AvailableRulesets.ElementAt(1));
@@ -249,8 +249,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 var visibleBeatmapPanels = GetVisiblePanels<PanelBeatmap>();
 
                 return visibleBeatmapPanels.Count() == 2
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 0) == 1
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 1) == 1;
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 0) == 1
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 1) == 1;
             });
 
             ApplyToFilterAndWaitForFilter("filter to catch", c => c.Ruleset = rulesets.AvailableRulesets.ElementAt(2));
@@ -260,8 +260,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 var visibleBeatmapPanels = GetVisiblePanels<PanelBeatmap>();
 
                 return visibleBeatmapPanels.Count() == 2
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 0) == 1
-                       && visibleBeatmapPanels.Count(p => ((BeatmapInfo)p.Item!.Model).Ruleset.OnlineID == 2) == 1;
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 0) == 1
+                       && visibleBeatmapPanels.Count(p => ((GroupedBeatmap)p.Item!.Model).Beatmap.Ruleset.OnlineID == 2) == 1;
             });
         }
 
@@ -396,7 +396,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             ApplyToFilterAndWaitForFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
 
             SelectNextPanel();
-            AddAssert("keyboard selected is first set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.First()));
+            AddAssert("keyboard selected is first set",
+                () => (GetKeyboardSelectedPanel()?.Item?.Model as GroupedBeatmapSet)?.BeatmapSet,
+                () => Is.EqualTo(BeatmapSets.First()));
         }
 
         [Test]
@@ -413,7 +415,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             ApplyToFilterAndWaitForFilter("filter first away", c => c.UserStarDifficulty.Min = 3);
 
             SelectPrevPanel();
-            AddAssert("keyboard selected is last set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.Last()));
+            AddAssert("keyboard selected is last set",
+                () => (GetKeyboardSelectedPanel()?.Item?.Model as GroupedBeatmapSet)?.BeatmapSet,
+                () => Is.EqualTo(BeatmapSets.Last()));
         }
 
         [Test]
@@ -428,7 +432,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             ApplyToFilterAndWaitForFilter("filter last set away", c => c.SearchText = BeatmapSets.First().Metadata.Title);
 
             SelectPrevPanel();
-            AddAssert("keyboard selected is first set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.First()));
+            AddAssert("keyboard selected is first set",
+                () => (GetKeyboardSelectedPanel()?.Item?.Model as GroupedBeatmapSet)?.BeatmapSet,
+                () => Is.EqualTo(BeatmapSets.First()));
         }
 
         [Test]
@@ -444,7 +450,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             // Single result is automatically selected for us, so we iterate once backwards to the set header.
             SelectPrevPanel();
-            AddAssert("keyboard selected is second set", () => GetKeyboardSelectedPanel()?.Item?.Model, () => Is.EqualTo(BeatmapSets.Last()));
+            AddAssert("keyboard selected is second set",
+                () => (GetKeyboardSelectedPanel()?.Item?.Model as GroupedBeatmapSet)?.BeatmapSet,
+                () => Is.EqualTo(BeatmapSets.Last()));
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
index 648f531a6e..c839a28055 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselNoGrouping.cs
@@ -4,7 +4,6 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Screens.SelectV2;
 using osuTK;
@@ -90,7 +89,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             CheckHasSelection();
             AddAssert("drawable selection non-null", () => selection, () => Is.Not.Null);
-            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("drawable selection matches carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
 
             RemoveAllBeatmaps();
             AddUntilStep("no drawable selection", GetSelectedPanel, () => Is.Null);
@@ -101,9 +100,9 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             CheckHasSelection();
             AddAssert("no drawable selection", GetSelectedPanel, () => Is.Null);
 
-            AddStep("add previous selection", () => BeatmapSets.Add(((BeatmapInfo)selection!).BeatmapSet!));
+            AddStep("add previous selection", () => BeatmapSets.Add(((GroupedBeatmap)selection!).Beatmap.BeatmapSet!));
 
-            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentSelection));
+            AddAssert("selection matches original carousel selection", () => selection, () => Is.EqualTo(Carousel.CurrentGroupedBeatmap));
             AddUntilStep("drawable selection restored", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(selection));
             AddAssert("carousel item is visible", () => GetSelectedPanel()?.Item?.IsVisible, () => Is.True);
         }
@@ -390,15 +389,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
         private void checkSelectionIterating(bool isIterating)
         {
-            object? selection = null;
+            GroupedBeatmap? selection = null;
 
             for (int i = 0; i < 3; i++)
             {
-                AddStep("store selection", () => selection = Carousel.CurrentSelection);
+                AddStep("store selection", () => selection = Carousel.CurrentGroupedBeatmap);
                 if (isIterating)
-                    AddUntilStep("selection changed", () => Carousel.CurrentSelection != selection);
+                    AddUntilStep("selection changed", () => Carousel.CurrentGroupedBeatmap != selection);
                 else
-                    AddUntilStep("selection not changed", () => Carousel.CurrentSelection == selection);
+                    AddUntilStep("selection not changed", () => Carousel.CurrentGroupedBeatmap == selection);
             }
         }
     }
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs
index ed694c9e3d..ce68d587c8 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselRandom.cs
@@ -50,12 +50,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             nextRandom();
             ensureRandomDidNotRepeat();
 
-            AddStep("store selection", () => originalSelected = (BeatmapInfo)Carousel.CurrentSelection!);
+            AddStep("store selection", () => originalSelected = Carousel.CurrentBeatmap!);
 
             SortAndGroupBy(SortMode.Artist, GroupMode.Difficulty);
             WaitForFiltering();
 
-            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(originalSelected));
+            AddAssert("selection not changed", () => Carousel.CurrentBeatmap, () => Is.EqualTo(originalSelected));
 
             storeExpandedGroup();
 
@@ -247,18 +247,42 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             }
         }
 
+        [Test]
+        public void TestRewindOverGroupingModeChange()
+        {
+            const int local_set_count = 3;
+
+            SortAndGroupBy(SortMode.Artist, GroupMode.Artist);
+            AddBeatmaps(local_set_count, 3);
+            WaitForDrawablePanels();
+
+            SelectNextSet();
+
+            for (int i = 0; i < local_set_count; i++)
+                nextRandom();
+
+            SortAndGroupBy(SortMode.Title, GroupMode.LastPlayed);
+            WaitForDrawablePanels();
+
+            for (int i = 0; i < local_set_count; i++)
+            {
+                prevRandomSet();
+                checkRewindCorrectSet();
+            }
+        }
+
         [Test]
         public void TestRandomThenRewindSameFrame()
         {
             AddBeatmaps(10, 3, true);
             WaitForDrawablePanels();
 
-            BeatmapInfo? originalSelected = null;
+            GroupedBeatmap? originalSelected = null;
 
             nextRandom();
 
             CheckHasSelection();
-            AddStep("store selection", () => originalSelected = (BeatmapInfo)Carousel.CurrentSelection!);
+            AddStep("store selection", () => originalSelected = Carousel.CurrentGroupedBeatmap!);
 
             AddStep("random then rewind", () =>
             {
@@ -266,7 +290,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                 Carousel.PreviousRandom();
             });
 
-            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(originalSelected));
+            AddAssert("selection not changed", () => Carousel.CurrentGroupedBeatmap, () => Is.EqualTo(originalSelected));
         }
 
         [Test]
@@ -275,26 +299,26 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddBeatmaps(10, 3, true);
             WaitForDrawablePanels();
 
-            BeatmapInfo? originalSelected = null;
-            BeatmapInfo? postRandomSelection = null;
+            GroupedBeatmap? originalSelected = null;
+            GroupedBeatmap? postRandomSelection = null;
 
             nextRandom();
 
             CheckHasSelection();
-            AddStep("store selection", () => originalSelected = (BeatmapInfo)Carousel.CurrentSelection!);
+            AddStep("store selection", () => originalSelected = Carousel.CurrentGroupedBeatmap!);
 
             nextRandom();
-            AddStep("store selection", () => postRandomSelection = (BeatmapInfo)Carousel.CurrentSelection!);
+            AddStep("store selection", () => postRandomSelection = Carousel.CurrentGroupedBeatmap!);
 
             AddAssert("selection changed", () => originalSelected, () => Is.Not.SameAs(postRandomSelection));
 
-            AddStep("delete previous selection beatmaps", () => BeatmapSets.Remove(originalSelected!.BeatmapSet!));
+            AddStep("delete previous selection beatmaps", () => BeatmapSets.Remove(originalSelected!.Beatmap.BeatmapSet!));
             WaitForFiltering();
 
-            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(postRandomSelection));
+            AddAssert("selection not changed", () => Carousel.CurrentGroupedBeatmap, () => Is.EqualTo(postRandomSelection));
 
             prevRandomSet();
-            AddAssert("selection not changed", () => Carousel.CurrentSelection, () => Is.EqualTo(postRandomSelection));
+            AddAssert("selection not changed", () => Carousel.CurrentGroupedBeatmap, () => Is.EqualTo(postRandomSelection));
         }
 
         private void nextRandom() =>
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
index 29aa976fe3..c1cee4e398 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselScrolling.cs
@@ -27,7 +27,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             Quad positionBefore = default;
 
-            AddStep("select middle beatmap", () => Carousel.CurrentSelection = BeatmapSets.ElementAt(BeatmapSets.Count - 2).Beatmaps.First());
+            AddStep("select middle beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.ElementAt(BeatmapSets.Count - 2).Beatmaps.First()));
 
             WaitForScrolling();
 
@@ -45,7 +45,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             Quad positionBefore = default;
 
-            AddStep("select middle beatmap", () => Carousel.CurrentSelection = BeatmapSets.ElementAt(BeatmapSets.Count - 2).Beatmaps.First());
+            AddStep("select middle beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.ElementAt(BeatmapSets.Count - 2).Beatmaps.First()));
             WaitForScrolling();
 
             AddStep("override scroll with user scroll", () =>
@@ -71,7 +71,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddStep("scroll to end", () => Scroll.ScrollToEnd(false));
 
-            AddStep("select last beatmap", () => Carousel.CurrentSelection = BeatmapSets.Last().Beatmaps.Last());
+            AddStep("select last beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.Last().Beatmaps.Last()));
 
             WaitForScrolling();
 
@@ -88,7 +88,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             Quad positionBefore = default;
 
-            AddStep("select first beatmap", () => Carousel.CurrentSelection = BeatmapSets.First().Beatmaps.First());
+            AddStep("select first beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.First().Beatmaps.First()));
 
             WaitForScrolling();
 
@@ -108,7 +108,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             Quad positionBefore = default;
 
-            AddStep("select first beatmap", () => Carousel.CurrentSelection = BeatmapSets.First().Beatmaps.First());
+            AddStep("select first beatmap", () => Carousel.CurrentGroupedBeatmap = new GroupedBeatmap(null, BeatmapSets.First().Beatmaps.First()));
             WaitForScrolling();
 
             AddStep("override scroll with user scroll", () =>
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselSetsSplitApart.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselSetsSplitApart.cs
new file mode 100644
index 0000000000..fa635f9bde
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselSetsSplitApart.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.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Screens.Select.Filter;
+using osu.Game.Screens.SelectV2;
+
+namespace osu.Game.Tests.Visual.SongSelectV2
+{
+    [TestFixture]
+    public partial class TestSceneBeatmapCarouselSetsSplitApart : BeatmapCarouselTestScene
+    {
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            RemoveAllBeatmaps();
+            CreateCarousel();
+
+            SortAndGroupBy(SortMode.Title, GroupMode.Length);
+        }
+
+        [Test]
+        public void TestSetTraversal()
+        {
+            AddBeatmaps(3, splitApart: true);
+            AddBeatmaps(3, splitApart: false);
+            WaitForDrawablePanels();
+
+            SelectNextSet();
+            WaitForSetSelection(set: 0, diff: 0);
+
+            SelectNextSet();
+            WaitForSetSelection(set: 1, diff: 0);
+
+            SelectPrevSet();
+            WaitForSetSelection(set: 0, diff: 0);
+
+            SelectPrevSet();
+            WaitForSetSelection(set: 5, diff: 0);
+
+            SelectPrevSet();
+            SelectPrevSet();
+            SelectPrevSet();
+            WaitForSetSelection(set: 2, diff: 4);
+            AddAssert("only two beatmap panels visible", () => GetVisiblePanels<PanelBeatmap>().Count(), () => Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestBeatmapTraversal()
+        {
+            AddBeatmaps(3, splitApart: true);
+            AddBeatmaps(3, splitApart: false);
+            WaitForDrawablePanels();
+
+            SelectNextSet();
+            WaitForSetSelection(set: 0, diff: 0);
+
+            SelectNextPanel();
+            WaitForSetSelection(set: 0, diff: 1);
+
+            SelectNextPanel(); // header of set 1 in group 0
+            Select();
+            WaitForSetSelection(set: 1, diff: 0);
+
+            SelectPrevPanel(); // header of set 1 in group 0
+            SelectPrevPanel(); // header of set 0 in group 0
+            Select();
+            WaitForSetSelection(set: 0, diff: 0);
+
+            SelectPrevPanel(); // header of set 0 in group 0
+            SelectPrevPanel(); // header of group 0
+            SelectPrevPanel(); // header of group 2
+            Select();
+            SelectNextPanel(); // header of set 0 in group 2
+            Select();
+            WaitForSetSelection(set: 0, diff: 4);
+        }
+
+        [Test]
+        public void TestRandomStaysInGroup()
+        {
+            AddBeatmaps(2, splitApart: false);
+            AddBeatmaps(1, splitApart: true);
+            WaitForDrawablePanels();
+
+            SelectPrevSet();
+            SelectPrevSet();
+            WaitForSetSelection(set: 1);
+            WaitForExpandedGroup(2);
+
+            AddStep("select next random", () => Carousel.NextRandom());
+            WaitForExpandedGroup(2);
+            AddStep("select next random", () => Carousel.NextRandom());
+            WaitForExpandedGroup(2);
+        }
+
+        protected void AddBeatmaps(int count, bool splitApart) => AddStep($"add {count} beatmaps ({(splitApart ? "" : "not ")}split apart)", () =>
+        {
+            var beatmapSets = new List<BeatmapSetInfo>();
+
+            for (int i = 0; i < count; i++)
+            {
+                var beatmapSet = CreateTestBeatmapSetInfo(6, false);
+
+                for (int j = 0; j < beatmapSet.Beatmaps.Count; j++)
+                {
+                    beatmapSet.Beatmaps[j].Length = splitApart ? 30_000 * (j + 1) : 180_000;
+                }
+
+                beatmapSets.Add(beatmapSet);
+            }
+
+            BeatmapSets.AddRange(beatmapSets);
+        });
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs
index eb610a40f1..17f328b549 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneBeatmapCarouselUpdateHandling.cs
@@ -8,6 +8,7 @@ using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Extensions;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -22,12 +23,21 @@ namespace osu.Game.Tests.Visual.SongSelectV2
     {
         private BeatmapSetInfo baseTestBeatmap = null!;
 
+        private const int initial_filter_count = 3;
+
         [SetUpSteps]
         public void SetUpSteps()
         {
             RemoveAllBeatmaps();
             CreateCarousel();
-            AddBeatmaps(1, 3);
+            WaitForFiltering();
+            AddStep("add beatmap", () =>
+            {
+                var beatmap = CreateTestBeatmapSetInfo(3, false);
+                Realm.Write(r => r.Add(beatmap, update: true));
+                BeatmapSets.Add(beatmap.Detach());
+            });
+            WaitForFiltering();
             AddStep("generate and add test beatmap", () =>
             {
                 baseTestBeatmap = TestResources.CreateTestBeatmapSetInfo(3);
@@ -40,10 +50,13 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
                 foreach (var b in baseTestBeatmap.Beatmaps)
                     b.Metadata = metadata;
-                BeatmapSets.Add(baseTestBeatmap);
-            });
 
+                Realm.Write(r => r.Add(baseTestBeatmap, update: true));
+                BeatmapSets.Add(baseTestBeatmap.Detach());
+            });
             WaitForFiltering();
+
+            AddAssert("filter count correct", () => Carousel.FilterCount, () => Is.EqualTo(initial_filter_count));
         }
 
         [Test]
@@ -63,12 +76,19 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("drawables unchanged", () => Carousel.ChildrenOfType<Panel>(), () => Is.EqualTo(originalDrawables));
         }
 
-        [Test]
-        public void TestScrollPositionMaintainedWhenSetUpdated()
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestScrollPositionMaintainedWhenSetUpdated(bool difficultySort)
         {
-            PanelBeatmapSet panel = null!;
+            if (difficultySort)
+            {
+                SortAndGroupBy(SortMode.Difficulty, GroupMode.Difficulty);
+                assertDidFilter(1);
+            }
 
-            AddStep("find panel", () => panel = Carousel.ChildrenOfType<PanelBeatmapSet>().Single(p => p.ChildrenOfType<OsuSpriteText>().Any(t => t.Text.ToString() == "beatmap")));
+            Panel panel = null!;
+
+            AddStep("find panel", () => panel = Carousel.ChildrenOfType<Panel>().First(p => p.Item != null && p.ChildrenOfType<OsuSpriteText>().Any(t => t.Text.ToString() == "beatmap")));
 
             AddStep("select panel", () => panel.TriggerClick());
 
@@ -81,12 +101,18 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddUntilStep("is scrolled to end", () => Carousel.ChildrenOfType<UserTrackingScrollContainer>().Single().IsScrolledToEnd());
 
-            updateBeatmap(b => b.Metadata = new BeatmapMetadata
+            updateBeatmap(b =>
             {
-                Artist = "updated test",
-                Title = $"beatmap {RNG.Next().ToString()}"
+                // hash will be updated when important metadata changes, such as title, difficulty, author etc.
+                b.Hash = "new hash";
+                b.Metadata = new BeatmapMetadata
+                {
+                    Artist = "updated test",
+                    Title = $"beatmap {RNG.Next().ToString()}"
+                };
             });
 
+            assertDidFilter(difficultySort ? 2 : 1);
             WaitForFiltering();
 
             AddAssert("scroll is still at end", () => Carousel.ChildrenOfType<UserTrackingScrollContainer>().Single().IsScrolledToEnd());
@@ -113,8 +139,14 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             AddStep("find panel", () => panel = Carousel.ChildrenOfType<PanelBeatmapSet>().Single(p => p.ChildrenOfType<OsuSpriteText>().Any(t => t.Text.ToString() == "beatmap")));
 
-            updateBeatmap(b => b.Metadata = metadata);
+            updateBeatmap(b =>
+            {
+                b.Metadata = metadata;
+                // hash will be updated when important metadata changes, such as title, difficulty, author etc.
+                b.Hash = "new hash";
+            });
 
+            assertDidFilter();
             WaitForFiltering();
 
             AddAssert("drawables unchanged", () => Carousel.ChildrenOfType<Panel>(), () => Is.EqualTo(originalDrawables));
@@ -123,19 +155,73 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         }
 
         [Test]
-        public void TestSelectionHeld()
+        public void TestOnlineStatusUpdated()
+        {
+            List<Panel> originalDrawables = new List<Panel>();
+
+            AddStep("store drawable references", () =>
+            {
+                originalDrawables.Clear();
+                originalDrawables.AddRange(Carousel.ChildrenOfType<Panel>().ToList());
+            });
+
+            updateBeatmap(b => b.Status = BeatmapOnlineStatus.Graveyard);
+
+            assertDidFilter();
+            WaitForFiltering();
+
+            AddAssert("drawables unchanged", () => Carousel.ChildrenOfType<Panel>(), () => Is.EqualTo(originalDrawables));
+        }
+
+        [Test]
+        public void TestNoUpdateTriggeredOnUserTagsChange()
+        {
+            var metadata = new BeatmapMetadata
+            {
+                Artist = "updated test",
+                Title = "new beatmap title",
+                UserTags = { "hi" }
+            };
+
+            updateBeatmap(b => b.Metadata = metadata);
+            assertDidNotFilter();
+        }
+
+        [TestCase(false, false)]
+        [TestCase(false, true)]
+        [TestCase(true, false)]
+        [TestCase(true, true)]
+        public void TestSelectionHeld(bool difficultySort, bool hashChanged)
         {
             SelectNextSet();
 
+            if (difficultySort)
+            {
+                SortAndGroupBy(SortMode.Difficulty, GroupMode.Difficulty);
+                assertDidFilter(1);
+            }
+
             WaitForSetSelection(1, 0);
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+
+            updateBeatmap(b =>
+            {
+                if (hashChanged)
+                    b.Hash = "new hash";
+            });
+
+            int baseFilterCount = difficultySort ? 1 : 0;
+
+            if (hashChanged)
+                assertDidFilter(baseFilterCount + 1);
+            else
+                assertDidFilter(baseFilterCount);
 
-            updateBeatmap();
             WaitForFiltering();
 
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
         }
 
         [Test] // Checks that we keep selection based on online ID where possible.
@@ -144,14 +230,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextSet();
 
             WaitForSetSelection(1, 0);
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
 
             updateBeatmap(b => b.DifficultyName = "new name");
+            assertDidFilter();
             WaitForFiltering();
 
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
         }
 
         [Test] // Checks that we fallback to keeping selection based on difficulty name.
@@ -160,14 +247,15 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextSet();
 
             WaitForSetSelection(1, 0);
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
 
             updateBeatmap(b => b.OnlineID = b.OnlineID + 1);
+            assertDidFilter();
             WaitForFiltering();
 
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
         }
 
         [Test] // Checks that we don't crash if there exists a difficulty with the same online ID as the selected difficulty.
@@ -176,8 +264,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextSet();
 
             WaitForSetSelection(1, 0);
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
 
             // Add another difficulty with same online ID.
             updateBeatmap(null, bs =>
@@ -189,8 +277,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             WaitForFiltering();
 
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
         }
 
         [Test] // Checks that we don't crash if there exists a difficulty with the same name as the selected difficulty.
@@ -199,21 +287,24 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             SelectNextSet();
 
             WaitForSetSelection(1, 0);
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
 
             // Remove original selected difficulty, and add two difficulties with same name as selection.
             updateBeatmap(null, bs =>
             {
                 string selectedName = bs.Beatmaps[0].DifficultyName;
+                Realm.Write(r => r.Remove(r.Find<BeatmapInfo>(bs.Beatmaps[0].ID)!));
                 bs.Beatmaps.RemoveAt(0);
 
                 var newBeatmap = createBeatmap(bs);
+                newBeatmap.ID = Guid.NewGuid();
                 newBeatmap.DifficultyName = selectedName;
                 newBeatmap.OnlineID = -1;
                 bs.Beatmaps.Add(newBeatmap);
 
                 newBeatmap = createBeatmap(bs);
+                newBeatmap.ID = Guid.NewGuid();
                 newBeatmap.DifficultyName = selectedName;
                 newBeatmap.OnlineID = -1;
                 bs.Beatmaps.Add(newBeatmap);
@@ -221,8 +312,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             WaitForFiltering();
 
-            AddAssert("selection is updateable beatmap", () => Carousel.CurrentSelection, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
-            AddAssert("visible panel is updateable beatmap", () => GetSelectedPanel()?.Item?.Model, () => Is.EqualTo(baseTestBeatmap.Beatmaps[0]));
+            AddAssert("selection is updateable beatmap", () => Carousel.CurrentBeatmap, () => Is.EqualTo(BeatmapSets[1].Beatmaps[2]));
+            AddAssert("visible panel is updateable beatmap", () => (GetSelectedPanel()?.Item?.Model as GroupedBeatmap)?.Beatmap, () => Is.EqualTo(BeatmapSets[1].Beatmaps[2]));
         }
 
         /// <summary>
@@ -339,6 +430,10 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("Order didn't change", () => Carousel.PostFilterBeatmaps.Select(b => b.ID), () => Is.EqualTo(originalOrder));
         }
 
+        private void assertDidFilter(int count = 1) => AddAssert("did filter", () => Carousel.FilterCount, () => Is.EqualTo(initial_filter_count + count));
+
+        private void assertDidNotFilter() => AddAssert("did not filter", () => Carousel.FilterCount, () => Is.EqualTo(initial_filter_count));
+
         private void updateBeatmap(Action<BeatmapInfo>? updateBeatmap = null, Action<BeatmapSetInfo>? updateSet = null)
         {
             AddStep("update beatmap with different reference", () =>
@@ -372,7 +467,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
                 int originalIndex = BeatmapSets.IndexOf(baseTestBeatmap);
 
-                BeatmapSets.ReplaceRange(originalIndex, 1, [updatedSet]);
+                Realm.Write(r => r.Add(updatedSet, update: true));
+                BeatmapSets.ReplaceRange(originalIndex, 1, [updatedSet.Detach()]);
             });
         }
 
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs
index 5c4969f9ad..774d4a00ce 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneCollectionDropdown.cs
@@ -87,11 +87,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             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));
+            AddUntilStep("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));
+            AddUntilStep("check count 2", () => dropdown.ChildrenOfType<CollectionDropdown>().Single().ChildrenOfType<Menu.DrawableMenuItem>().Count(), () => Is.EqualTo(2));
         }
 
         [Test]
@@ -186,11 +186,11 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
 
             addClickAddOrRemoveButtonStep(1);
-            AddAssert("collection contains beatmap", () => getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
+            AddUntilStep("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));
+            AddUntilStep("collection does not contain beatmap", () => !getFirstCollection().BeatmapMD5Hashes.Contains(Beatmap.Value.BeatmapInfo.MD5Hash));
             assertFirstButtonIs(FontAwesome.Solid.PlusSquare);
         }
 
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs
index 09f8c68951..618b9e0d48 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmap.cs
@@ -104,21 +104,21 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     {
                         new PanelBeatmap
                         {
-                            Item = new CarouselItem(beatmap)
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap))
                         },
                         new PanelBeatmap
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             KeyboardSelected = { Value = true }
                         },
                         new PanelBeatmap
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             Selected = { Value = true }
                         },
                         new PanelBeatmap
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             KeyboardSelected = { Value = true },
                             Selected = { Value = true }
                         },
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs
index e9361b3d7f..67a9f54f1a 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelBeatmapStandalone.cs
@@ -104,21 +104,21 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     {
                         new PanelBeatmapStandalone
                         {
-                            Item = new CarouselItem(beatmap)
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap))
                         },
                         new PanelBeatmapStandalone
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             KeyboardSelected = { Value = true }
                         },
                         new PanelBeatmapStandalone
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             Selected = { Value = true }
                         },
                         new PanelBeatmapStandalone
                         {
-                            Item = new CarouselItem(beatmap),
+                            Item = new CarouselItem(new GroupedBeatmap(null, beatmap)),
                             KeyboardSelected = { Value = true },
                             Selected = { Value = true }
                         },
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelGroup.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelGroup.cs
index 3b9a07437a..f678ec372a 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelGroup.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelGroup.cs
@@ -9,6 +9,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.Cursor;
+using osu.Game.Scoring;
 using osu.Game.Screens.SelectV2;
 using osu.Game.Tests.Visual.UserInterface;
 using osuTK;
@@ -86,6 +87,64 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             }
         }
 
+        [Test]
+        public void TestRanks()
+        {
+            for (int i = -1; i <= 7; i++)
+            {
+                ScoreRank rank = (ScoreRank)i;
+
+                AddStep($"display rank {rank}", () =>
+                {
+                    ContentContainer.Child = new DependencyProvidingContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        CachedDependencies = new (Type, object)[]
+                        {
+                            (typeof(OverlayColourProvider), new OverlayColourProvider(OverlayColourScheme.Aquamarine))
+                        },
+                        Child = new OsuContextMenuContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            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 PanelGroupRankDisplay
+                                    {
+                                        Item = new CarouselItem(new RankDisplayGroupDefinition(rank))
+                                    },
+                                    new PanelGroupRankDisplay
+                                    {
+                                        Item = new CarouselItem(new RankDisplayGroupDefinition(rank)),
+                                        KeyboardSelected = { Value = true },
+                                    },
+                                    new PanelGroupRankDisplay
+                                    {
+                                        Item = new CarouselItem(new RankDisplayGroupDefinition(rank)),
+                                        Expanded = { Value = true },
+                                    },
+                                    new PanelGroupRankDisplay
+                                    {
+                                        Item = new CarouselItem(new RankDisplayGroupDefinition(rank)),
+                                        Expanded = { Value = true },
+                                        KeyboardSelected = { Value = true },
+                                    },
+                                },
+                            }
+                        }
+                    };
+                });
+            }
+        }
+
         protected override Drawable CreateContent()
         {
             return new OsuContextMenuContainer
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs
index 1723185b1f..b574262d55 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestScenePanelSet.cs
@@ -75,21 +75,21 @@ namespace osu.Game.Tests.Visual.SongSelectV2
                     {
                         new PanelBeatmapSet
                         {
-                            Item = new CarouselItem(beatmapSet)
+                            Item = new CarouselItem(new GroupedBeatmapSet(null, beatmapSet))
                         },
                         new PanelBeatmapSet
                         {
-                            Item = new CarouselItem(beatmapSet),
+                            Item = new CarouselItem(new GroupedBeatmapSet(null, beatmapSet)),
                             KeyboardSelected = { Value = true }
                         },
                         new PanelBeatmapSet
                         {
-                            Item = new CarouselItem(beatmapSet),
+                            Item = new CarouselItem(new GroupedBeatmapSet(null, beatmapSet)),
                             Expanded = { Value = true }
                         },
                         new PanelBeatmapSet
                         {
-                            Item = new CarouselItem(beatmapSet),
+                            Item = new CarouselItem(new GroupedBeatmapSet(null, beatmapSet)),
                             KeyboardSelected = { Value = true },
                             Expanded = { Value = true }
                         },
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
index 69bdb97617..945ec5d207 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
@@ -23,7 +24,9 @@ using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Screens.SelectV2;
+using osu.Game.Tests.Resources;
 using osuTK.Input;
+using BeatmapCarousel = osu.Game.Screens.SelectV2.BeatmapCarousel;
 using FooterButtonMods = osu.Game.Screens.SelectV2.FooterButtonMods;
 using FooterButtonOptions = osu.Game.Screens.SelectV2.FooterButtonOptions;
 using FooterButtonRandom = osu.Game.Screens.SelectV2.FooterButtonRandom;
@@ -302,6 +305,29 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             });
         }
 
+        /// <summary>
+        /// Last played and rank achieved may have changed, so we want to make sure filtering runs on resume to song select.
+        /// </summary>
+        [Test]
+        public void TestFilteringRunsAfterReturningFromGameplay()
+        {
+            AddStep("import actual beatmap", () => Beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely());
+
+            LoadSongSelect();
+
+            AddUntilStep("wait for filtered", () => SongSelect.ChildrenOfType<BeatmapCarousel>().Single().FilterCount, () => Is.EqualTo(1));
+
+            AddStep("enter gameplay", () => InputManager.Key(Key.Enter));
+
+            AddUntilStep("wait for player", () => Stack.CurrentScreen is Player);
+            AddUntilStep("wait for fail", () => ((Player)Stack.CurrentScreen).GameplayState.HasFailed);
+
+            AddStep("exit gameplay", () => Stack.CurrentScreen.Exit());
+
+            AddUntilStep("wait for song select", () => Stack.CurrentScreen is Screens.SelectV2.SongSelect);
+            AddUntilStep("wait for filtered", () => SongSelect.ChildrenOfType<BeatmapCarousel>().Single().FilterCount, () => Is.EqualTo(2));
+        }
+
         [Test]
         public void TestAutoplayShortcut()
         {
@@ -566,7 +592,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             LoadSongSelect();
 
             ImportBeatmapForRuleset(0);
-            AddAssert("options enabled", () => this.ChildrenOfType<FooterButtonOptions>().Single().Enabled.Value);
+            AddUntilStep("options enabled", () => this.ChildrenOfType<FooterButtonOptions>().Single().Enabled.Value);
 
             AddStep("click", () => this.ChildrenOfType<FooterButtonOptions>().Single().TriggerClick());
             AddUntilStep("popover displayed", () => this.ChildrenOfType<FooterButtonOptions.Popover>().Any(p => p.IsPresent));
@@ -623,7 +649,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             ImportBeatmapForRuleset(0);
 
-            AddAssert("options enabled", () => this.ChildrenOfType<FooterButtonOptions>().Single().Enabled.Value);
+            AddUntilStep("options enabled", () => this.ChildrenOfType<FooterButtonOptions>().Single().Enabled.Value);
             AddStep("delete all beatmaps", () => Beatmaps.Delete());
 
             AddAssert("beatmap selected", () => !Beatmap.IsDefault);
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs
index 0736925584..0ec61f59da 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectCurrentSelectionInvalidated.cs
@@ -27,7 +27,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
     /// </summary>
     public partial class TestSceneSongSelectCurrentSelectionInvalidated : SongSelectTestScene
     {
-        private BeatmapInfo? selectedBeatmap => (BeatmapInfo?)Carousel.CurrentSelection;
+        private BeatmapInfo? selectedBeatmap => Carousel.CurrentBeatmap;
         private BeatmapSetInfo? selectedBeatmapSet => selectedBeatmap?.BeatmapSet;
 
         [SetUpSteps]
@@ -55,22 +55,26 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             waitForFiltering(6);
 
             BeatmapInfo? initiallySelected = null;
-            AddAssert("selected is taiko", () => (initiallySelected = selectedBeatmap)?.Ruleset.OnlineID, () => Is.EqualTo(1));
+            AddAssert("carousel beatmap is taiko", () => (initiallySelected = selectedBeatmap)?.Ruleset.OnlineID, () => Is.EqualTo(1));
+            AddUntilStep("global beatmap is taiko", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(1));
 
             ChangeRuleset(0);
             waitForFiltering(7);
-            AddAssert("selected is osu", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(0));
-            AddAssert("selected is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
+            AddAssert("carousel beatmap is osu", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(0));
+            AddUntilStep("global beatmap is osu", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(0));
+            AddAssert("carousel beatmap is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
 
             ChangeRuleset(1);
             waitForFiltering(8);
-            AddAssert("selected is taiko", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(1));
-            AddAssert("selected is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
+            AddAssert("carousel beatmap is taiko", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(1));
+            AddUntilStep("global beatmap is taiko", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(1));
+            AddAssert("carousel beatmap is same set as original", () => selectedBeatmap?.BeatmapSet, () => Is.EqualTo(initiallySelected!.BeatmapSet));
 
             ChangeRuleset(2);
             waitForFiltering(9);
-            AddAssert("selected is catch", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(2));
-            AddAssert("selected is different set", () => selectedBeatmap?.BeatmapSet, () => Is.Not.EqualTo(initiallySelected!.BeatmapSet));
+            AddAssert("carousel beatmap is catch", () => selectedBeatmap?.Ruleset.OnlineID, () => Is.EqualTo(2));
+            AddUntilStep("global beatmap is catch", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID, () => Is.EqualTo(2));
+            AddAssert("carousel beatmap is different set", () => selectedBeatmap?.BeatmapSet, () => Is.Not.EqualTo(initiallySelected!.BeatmapSet));
         }
 
         /// <summary>
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs
index 16ad970239..076d84479a 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectFiltering.cs
@@ -302,7 +302,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
 
             checkMatchedBeatmaps(2);
 
-            AddAssert("selection changed", () => Beatmap.Value.BeatmapInfo, () => Is.Not.EqualTo(hiddenBeatmap));
+            AddUntilStep("selection changed", () => Beatmap.Value.BeatmapInfo, () => Is.Not.EqualTo(hiddenBeatmap));
 
             AddStep("restore", () => Beatmaps.Restore(hiddenBeatmap!));
 
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectGrouping.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectGrouping.cs
index 0f7c42946d..e65c9553c2 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectGrouping.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectGrouping.cs
@@ -94,7 +94,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             AddAssert("no-collection group present", () =>
             {
                 var group = grouping.GroupItems.Single(g => g.Key.Title == "Not in collection");
-                return group.Value.Select(i => i.Model).OfType<BeatmapSetInfo>().Single().Equals(beatmapSet);
+                return group.Value.Select(i => i.Model).OfType<GroupedBeatmapSet>().Single().BeatmapSet.Equals(beatmapSet);
             });
 
             AddStep("add beatmap to collection", () =>
@@ -245,7 +245,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             GroupBy(GroupMode.RankAchieved);
             WaitForFiltering();
 
-            assertGroupPresent("S+", () => new[] { beatmapSets[0] });
+            assertGroupPresent("Silver S", () => new[] { beatmapSets[0] });
             assertGroupPresent("A", () => new[] { beatmapSets[1] });
             assertGroupPresent("C", () => new[] { beatmapSets[2] });
             assertGroupPresent("Unplayed", () => new[] { beatmapSets[3], beatmapSets[4] });
@@ -316,8 +316,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             AddAssert($"\"{name}\" present", () =>
             {
-                var group = grouping.GroupItems.Single(g => g.Key.Title == name);
-                var actualBeatmaps = group.Value.Select(i => i.Model).OfType<BeatmapInfo>().OrderBy(b => b.ID);
+                var group = grouping.GroupItems.Single(g => g.Key.Title.ToString() == name);
+                var actualBeatmaps = group.Value.Select(i => i.Model).OfType<GroupedBeatmap>().Select(gb => gb.Beatmap).OrderBy(b => b.ID);
                 var expectedBeatmaps = getBeatmaps().SelectMany(s => s.Beatmaps).OrderBy(b => b.ID);
                 return actualBeatmaps.SequenceEqual(expectedBeatmaps);
             });
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneButtonSystem.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneButtonSystem.cs
index d8baca6d23..ba5cc56f34 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneButtonSystem.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneButtonSystem.cs
@@ -68,14 +68,15 @@ namespace osu.Game.Tests.Visual.UserInterface
         }
 
         [TestCase(Key.P, Key.P)]
-        [TestCase(Key.M, Key.P)]
-        [TestCase(Key.L, Key.P)]
-        [TestCase(Key.B, Key.E)]
-        [TestCase(Key.S, Key.E)]
-        [TestCase(Key.D, null)]
-        [TestCase(Key.Q, null)]
-        [TestCase(Key.O, null)]
-        public void TestShortcutKeys(Key key, Key? subMenuEnterKey)
+        [TestCase(Key.M, Key.M, Key.L)]
+        [TestCase(Key.M, Key.M, Key.M)]
+        [TestCase(Key.L, Key.L)]
+        [TestCase(Key.B, Key.E, Key.B)]
+        [TestCase(Key.S, Key.E, Key.S)]
+        [TestCase(Key.D)]
+        [TestCase(Key.Q)]
+        [TestCase(Key.O)]
+        public void TestShortcutKeys(params Key[] keys)
         {
             int activationCount = -1;
             AddStep("set up action", () =>
@@ -83,7 +84,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                 activationCount = 0;
                 void action() => activationCount++;
 
-                switch (key)
+                switch (keys.First())
                 {
                     case Key.P:
                         buttons.OnSolo = action;
@@ -119,16 +120,19 @@ namespace osu.Game.Tests.Visual.UserInterface
                 }
             });
 
-            AddStep($"press {key}", () => InputManager.Key(key));
+            // trigger out of idle state
+            AddStep($"press {keys.First()}", () => InputManager.Key(keys.First()));
             AddAssert("state is top level", () => buttons.State == ButtonSystemState.TopLevel);
 
-            if (subMenuEnterKey != null)
+            for (int i = 0; i < keys.Length; i++)
             {
-                AddStep($"press {subMenuEnterKey}", () => InputManager.Key(subMenuEnterKey.Value));
-                AddAssert("state is not top menu", () => buttons.State != ButtonSystemState.TopLevel);
+                var key = keys[i];
+                AddStep($"press {key}", () => InputManager.Key(key));
+
+                if (i > 0)
+                    AddAssert("state is not top menu", () => buttons.State != ButtonSystemState.TopLevel);
             }
 
-            AddStep($"press {key}", () => InputManager.Key(key));
             AddAssert("action triggered", () => activationCount == 1);
         }
 
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneMainMenuButton.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneMainMenuButton.cs
index c091c089cf..86659675a0 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneMainMenuButton.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneMainMenuButton.cs
@@ -13,8 +13,8 @@ using osu.Game.Online.Metadata;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.Menu;
+using osuTK.Graphics;
 using osuTK.Input;
-using Color4 = osuTK.Graphics.Color4;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
diff --git a/osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs b/osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs
index 31583bf8b7..eb9faa5930 100644
--- a/osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs
+++ b/osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs
@@ -6,6 +6,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Tournament.Components;
 using osu.Game.Tournament.IPC;
 using osu.Game.Tournament.Screens.Gameplay;
@@ -66,6 +67,6 @@ namespace osu.Game.Tournament.Tests.Screens
                 () => this.ChildrenOfType<TeamScore>().All(score => score.Alpha == (visible ? 1 : 0)));
 
         private void toggleWarmup()
-            => AddStep("toggle warmup", () => this.ChildrenOfType<TourneyButton>().First().TriggerClick());
+            => AddStep("toggle warmup", () => this.ChildrenOfType<LabelledSwitchButton>().First().ChildrenOfType<SwitchButton>().First().TriggerClick());
     }
 }
diff --git a/osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs b/osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs
index b2152eaf3d..2cf7ce1961 100644
--- a/osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs
+++ b/osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs
@@ -7,7 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Threading;
-using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Overlays.Settings;
 using osu.Game.Tournament.Components;
 using osu.Game.Tournament.IPC;
@@ -24,7 +24,6 @@ namespace osu.Game.Tournament.Screens.Gameplay
         private readonly BindableBool warmup = new BindableBool();
 
         public readonly Bindable<TourneyState> State = new Bindable<TourneyState>();
-        private OsuButton warmupButton = null!;
         private MatchIPCInfo ipc = null!;
 
         [Resolved]
@@ -40,6 +39,8 @@ namespace osu.Game.Tournament.Screens.Gameplay
         {
             this.ipc = ipc;
 
+            LabelledSwitchButton chatToggle;
+
             AddRangeInternal(new Drawable[]
             {
                 new TourneyVideo("gameplay")
@@ -95,17 +96,14 @@ namespace osu.Game.Tournament.Screens.Gameplay
                 {
                     Children = new Drawable[]
                     {
-                        warmupButton = new TourneyButton
+                        new LabelledSwitchButton
                         {
-                            RelativeSizeAxes = Axes.X,
-                            Text = "Toggle warmup",
-                            Action = () => warmup.Toggle()
+                            Label = "Warmup",
+                            Current = warmup,
                         },
-                        new TourneyButton
+                        chatToggle = new LabelledSwitchButton
                         {
-                            RelativeSizeAxes = Axes.X,
-                            Text = "Toggle chat",
-                            Action = () => { State.Value = State.Value == TourneyState.Idle ? TourneyState.Playing : TourneyState.Idle; }
+                            Label = "Show chat",
                         },
                         new SettingsSlider<int>
                         {
@@ -123,13 +121,12 @@ namespace osu.Game.Tournament.Screens.Gameplay
                 }
             });
 
+            State.BindValueChanged(state => chatToggle.Current.Value = State.Value == TourneyState.Idle, true);
+            chatToggle.Current.BindValueChanged(v => State.Value = v.NewValue ? TourneyState.Idle : TourneyState.Playing);
+
             LadderInfo.ChromaKeyWidth.BindValueChanged(width => chroma.Width = width.NewValue, true);
 
-            warmup.BindValueChanged(w =>
-            {
-                warmupButton.Alpha = !w.NewValue ? 0.5f : 1;
-                header.ShowScores = !w.NewValue;
-            }, true);
+            warmup.BindValueChanged(w => header.ShowScores = !w.NewValue, true);
         }
 
         protected override void LoadComplete()
diff --git a/osu.Game.Tournament/Screens/Schedule/ScheduleScreen.cs b/osu.Game.Tournament/Screens/Schedule/ScheduleScreen.cs
index d02559d6b7..848d510826 100644
--- a/osu.Game.Tournament/Screens/Schedule/ScheduleScreen.cs
+++ b/osu.Game.Tournament/Screens/Schedule/ScheduleScreen.cs
@@ -9,6 +9,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Tournament.Components;
 using osu.Game.Tournament.Models;
@@ -264,9 +265,9 @@ namespace osu.Game.Tournament.Screens.Schedule
             {
             }
 
-            protected override string Format() => Date < DateTimeOffset.Now
-                ? $"Started {base.Format()}"
-                : $"Starting {base.Format()}";
+            protected override LocalisableString Format() => Date < DateTimeOffset.Now
+                ? LocalisableString.Interpolate($"Started {base.Format()}")
+                : LocalisableString.Interpolate($"Starting {base.Format()}");
         }
 
         public partial class ScheduleContainer : Container
diff --git a/osu.Game/Beatmaps/BeatmapImporter.cs b/osu.Game/Beatmaps/BeatmapImporter.cs
index 28997509dc..f80c4de4ea 100644
--- a/osu.Game/Beatmaps/BeatmapImporter.cs
+++ b/osu.Game/Beatmaps/BeatmapImporter.cs
@@ -367,7 +367,11 @@ namespace osu.Game.Beatmaps
         {
             var beatmaps = new List<BeatmapInfo>();
 
-            foreach (var file in beatmapSet.Files.Where(f => f.Filename.EndsWith(".osu", StringComparison.OrdinalIgnoreCase)))
+            // stable appears to ignore `.osu` files which are not placed at the top level of the beatmap archive.
+            // the logic that achieves this is very difficult to make sense of, but appears to be located somewhere around
+            // https://github.com/peppy/osu-stable-reference/blob/67795dba3c308e7d0493b296149dcb073ca47ecb/osu!/GameplayElements/Beatmaps/BeatmapManager.cs#L207-L208
+            // only testing the `/` path separator character is sufficient as `RealmNamedFileUsage`s are normalised to use the front slash unix path separator convention
+            foreach (var file in beatmapSet.Files.Where(f => !f.Filename.Contains('/') && f.Filename.EndsWith(@".osu", StringComparison.OrdinalIgnoreCase)))
             {
                 using (var memoryStream = new MemoryStream(Files.Store.Get(file.File.GetStoragePath()))) // we need a memory stream so we can seek
                 {
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs
index 135e5129ae..8cd0ac965a 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCard.cs
@@ -7,7 +7,9 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
+using osu.Game.Configuration;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online;
@@ -22,7 +24,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
         public const float TRANSITION_DURATION = 340;
         public const float CORNER_RADIUS = 8;
 
-        protected const float WIDTH = 345;
+        public const float WIDTH = 345;
 
         public IBindable<bool> Expanded { get; }
 
@@ -35,6 +37,18 @@ namespace osu.Game.Beatmaps.Drawables.Cards
 
         protected readonly BeatmapDownloadTracker DownloadTracker;
 
+        private readonly Bindable<bool> preferNoVideo = new BindableBool();
+        private InputManager? containingInputManager;
+
+        [Resolved]
+        private BeatmapSetOverlay? beatmapSetOverlay { get; set; }
+
+        [Resolved]
+        private BeatmapModelDownloader? beatmaps { get; set; }
+
+        [Resolved]
+        private OsuGame? game { get; set; }
+
         protected BeatmapCard(APIBeatmapSet beatmapSet, bool allowExpansion = true)
             : base(HoverSampleSet.Button)
         {
@@ -45,10 +59,10 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             DownloadTracker = new BeatmapDownloadTracker(beatmapSet);
         }
 
-        [BackgroundDependencyLoader(true)]
-        private void load(BeatmapSetOverlay? beatmapSetOverlay)
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager configManager)
         {
-            Action = () => beatmapSetOverlay?.FetchAndShowBeatmapSet(BeatmapSet.OnlineID);
+            configManager.BindWith(OsuSetting.PreferNoVideo, preferNoVideo);
 
             AddInternal(DownloadTracker);
         }
@@ -60,6 +74,30 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             DownloadTracker.State.BindValueChanged(_ => UpdateState());
             Expanded.BindValueChanged(_ => UpdateState(), true);
             FinishTransforms(true);
+
+            containingInputManager = GetContainingInputManager();
+
+            if (Action == null)
+                throw new InvalidOperationException($"An action should be assigned to this {nameof(BeatmapCard)}. To use the default, assign {nameof(DefaultAction)}.");
+        }
+
+        protected void DefaultAction()
+        {
+            if (containingInputManager?.CurrentState.Keyboard.ShiftPressed == true)
+            {
+                switch (DownloadTracker.State.Value)
+                {
+                    case DownloadState.NotDownloaded:
+                        if (!BeatmapSet.Availability.DownloadDisabled) beatmaps?.Download(BeatmapSet, preferNoVideo.Value);
+                        break;
+
+                    case DownloadState.LocallyAvailable:
+                        game?.PresentBeatmap(BeatmapSet);
+                        break;
+                }
+            }
+            else
+                beatmapSetOverlay?.FetchAndShowBeatmapSet(BeatmapSet.OnlineID);
         }
 
         protected override bool OnHover(HoverEvent e)
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardContentBackground.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardContentBackground.cs
index deb56bb281..a57f3e7ce7 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardContentBackground.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardContentBackground.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
-        public BeatmapCardContentBackground(IBeatmapSetOnlineInfo onlineInfo)
+        public BeatmapCardContentBackground(IBeatmapSetOnlineInfo onlineInfo, bool keepLoaded = false)
         {
             InternalChildren = new Drawable[]
             {
@@ -29,7 +29,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                 {
                     RelativeSizeAxes = Axes.Both,
                 },
-                cover = new DelayedLoadUnloadWrapper(() => createCover(onlineInfo), 500, 500)
+                cover = new DelayedLoadUnloadWrapper(() => createCover(onlineInfo), keepLoaded ? 0 : 500, keepLoaded ? double.MaxValue : 1000)
                 {
                     RelativeSizeAxes = Axes.Both,
                     Colour = Colour4.Transparent
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtra.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtra.cs
index 9428984115..75fdc7d7e8 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtra.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardExtra.cs
@@ -46,6 +46,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             : base(beatmapSet, allowExpansion)
         {
             content = new BeatmapCardContent(height);
+
+            Action = DefaultAction;
         }
 
         [BackgroundDependencyLoader(true)]
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNano.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNano.cs
index 62108fe6f5..c23a03aabe 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNano.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNano.cs
@@ -54,6 +54,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             : base(beatmapSet, false)
         {
             content = new BeatmapCardContent(height);
+
+            Action = DefaultAction;
         }
 
         [BackgroundDependencyLoader]
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNormal.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNormal.cs
index 505a6fcdae..ac9ee94f56 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNormal.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardNormal.cs
@@ -47,6 +47,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             : base(beatmapSet, allowExpansion)
         {
             content = new BeatmapCardContent(HEIGHT);
+
+            Action = DefaultAction;
         }
 
         [BackgroundDependencyLoader]
diff --git a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardThumbnail.cs b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardThumbnail.cs
index 1f6f638618..4a7054588e 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardThumbnail.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/BeatmapCardThumbnail.cs
@@ -35,11 +35,11 @@ namespace osu.Game.Beatmaps.Drawables.Cards
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
-        public BeatmapCardThumbnail(IBeatmapSetInfo beatmapSetInfo, IBeatmapSetOnlineInfo onlineInfo)
+        public BeatmapCardThumbnail(IBeatmapSetInfo beatmapSetInfo, IBeatmapSetOnlineInfo onlineInfo, bool keepLoaded = false)
         {
             InternalChildren = new Drawable[]
             {
-                new UpdateableOnlineBeatmapSetCover(BeatmapSetCoverType.List)
+                new UpdateableOnlineBeatmapSetCover(BeatmapSetCoverType.List, keepLoaded ? 0 : 500, keepLoaded ? double.MaxValue : 1000)
                 {
                     RelativeSizeAxes = Axes.Both,
                     OnlineInfo = onlineInfo
diff --git a/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs b/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs
index d2c077d010..3d732b6683 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/Buttons/GoToBeatmapButton.cs
@@ -16,10 +16,12 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
         private readonly Bindable<DownloadState> state = new Bindable<DownloadState>();
 
         private readonly APIBeatmapSet beatmapSet;
+        private readonly bool allowNavigationToBeatmap;
 
-        public GoToBeatmapButton(APIBeatmapSet beatmapSet)
+        public GoToBeatmapButton(APIBeatmapSet beatmapSet, bool allowNavigationToBeatmap)
         {
             this.beatmapSet = beatmapSet;
+            this.allowNavigationToBeatmap = allowNavigationToBeatmap;
         }
 
         [BackgroundDependencyLoader(true)]
@@ -27,7 +29,6 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
         {
             Action = () => game?.PresentBeatmap(beatmapSet);
             Icon.Icon = FontAwesome.Solid.AngleDoubleRight;
-            TooltipText = "Go to beatmap";
         }
 
         protected override void LoadComplete()
@@ -40,8 +41,31 @@ namespace osu.Game.Beatmaps.Drawables.Cards.Buttons
 
         private void updateState()
         {
-            Enabled.Value = state.Value == DownloadState.LocallyAvailable;
-            this.FadeTo(Enabled.Value ? 1 : 0, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
+            bool available = state.Value == DownloadState.LocallyAvailable;
+            Enabled.Value = allowNavigationToBeatmap && available;
+
+            float alpha;
+
+            if (available && allowNavigationToBeatmap)
+            {
+                TooltipText = "Go to beatmap";
+                Enabled.Value = true;
+                alpha = 1f;
+            }
+            else if (available)
+            {
+                TooltipText = string.Empty;
+                Enabled.Value = false;
+                alpha = 0.3f;
+            }
+            else
+            {
+                TooltipText = string.Empty;
+                Enabled.Value = false;
+                alpha = 0;
+            }
+
+            this.FadeTo(alpha, BeatmapCard.TRANSITION_DURATION, Easing.OutQuint);
         }
     }
 }
diff --git a/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs b/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs
index 56d405ce3c..8262e787d8 100644
--- a/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs
+++ b/osu.Game/Beatmaps/Drawables/Cards/CollapsibleButtonContainer.cs
@@ -30,7 +30,6 @@ namespace osu.Game.Beatmaps.Drawables.Cards
             set
             {
                 buttonsExpandedWidth = value;
-                buttonArea.Width = value;
                 if (IsLoaded)
                     updateState();
             }
@@ -67,7 +66,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
 
-        public CollapsibleButtonContainer(APIBeatmapSet beatmapSet)
+        public CollapsibleButtonContainer(APIBeatmapSet beatmapSet, bool allowNavigationToBeatmap = true, bool keepBackgroundLoaded = false)
         {
             downloadTracker = new BeatmapDownloadTracker(beatmapSet);
 
@@ -116,14 +115,6 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                                 RelativeSizeAxes = Axes.Both,
                                 Height = 0.5f,
                             },
-                            new GoToBeatmapButton(beatmapSet)
-                            {
-                                Anchor = Anchor.BottomCentre,
-                                Origin = Anchor.BottomCentre,
-                                State = { BindTarget = downloadTracker.State },
-                                RelativeSizeAxes = Axes.Both,
-                                Height = 0.5f,
-                            }
                         }
                     }
                 },
@@ -135,7 +126,7 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                     Masking = true,
                     Children = new Drawable[]
                     {
-                        new BeatmapCardContentBackground(beatmapSet)
+                        new BeatmapCardContentBackground(beatmapSet, keepBackgroundLoaded)
                         {
                             RelativeSizeAxes = Axes.Both,
                             Dimmed = { BindTarget = ShowDetails }
@@ -152,6 +143,15 @@ namespace osu.Game.Beatmaps.Drawables.Cards
                     }
                 }
             };
+
+            buttons.Add(new GoToBeatmapButton(beatmapSet, allowNavigationToBeatmap)
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+                State = { BindTarget = downloadTracker.State },
+                RelativeSizeAxes = Axes.Both,
+                Height = 0.5f,
+            });
         }
 
         protected override void LoadComplete()
@@ -165,6 +165,8 @@ namespace osu.Game.Beatmaps.Drawables.Cards
 
         private void updateState()
         {
+            buttonArea.Width = buttonsExpandedWidth;
+
             float buttonAreaWidth = ShowDetails.Value ? ButtonsExpandedWidth : ButtonsCollapsedWidth;
             float mainAreaWidth = Width - buttonAreaWidth;
 
diff --git a/osu.Game/Beatmaps/FramedBeatmapClock.cs b/osu.Game/Beatmaps/FramedBeatmapClock.cs
index af7be235fc..8ce0db6e7b 100644
--- a/osu.Game/Beatmaps/FramedBeatmapClock.cs
+++ b/osu.Game/Beatmaps/FramedBeatmapClock.cs
@@ -59,7 +59,10 @@ namespace osu.Game.Beatmaps
 
             // An interpolating clock is used to ensure precise time values even when the host audio subsystem is not reporting
             // high precision times (on windows there's generally only 5-10ms reporting intervals, as an example).
-            interpolatedTrack = new InterpolatingFramedClock(decoupledTrack);
+            interpolatedTrack = new InterpolatingFramedClock(decoupledTrack)
+            {
+                DriftRecoveryHalfLife = 80,
+            };
 
             if (applyOffsets)
             {
diff --git a/osu.Game/Beatmaps/WorkingBeatmapCache.cs b/osu.Game/Beatmaps/WorkingBeatmapCache.cs
index 30bbbbc1fe..9957935977 100644
--- a/osu.Game/Beatmaps/WorkingBeatmapCache.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmapCache.cs
@@ -20,6 +20,7 @@ using osu.Framework.Platform;
 using osu.Framework.Statistics;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Database;
+using osu.Game.Extensions;
 using osu.Game.IO;
 using osu.Game.Skinning;
 using osu.Game.Storyboards;
@@ -341,27 +342,10 @@ namespace osu.Game.Beatmaps
             {
                 // Matches stable implementation, because it's probably simpler than trying to do anything else.
                 // This may need to be reconsidered after we begin storing storyboards in the new editor.
-                return windowsFilenameStrip(
-                    (metadata.Artist.Length > 0 ? metadata.Artist + @" - " + metadata.Title : Path.GetFileNameWithoutExtension(metadata.AudioFile))
-                    + (metadata.Author.Username.Length > 0 ? @" (" + metadata.Author.Username + @")" : string.Empty)
-                    + @".osb");
-
-                string windowsFilenameStrip(string entry)
-                {
-                    // Inlined from Path.GetInvalidFilenameChars() to ensure the windows characters are used (to match stable).
-                    char[] invalidCharacters =
-                    {
-                        '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
-                        '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D', '\x0E', '\x0F', '\x10', '\x11', '\x12',
-                        '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1A', '\x1B', '\x1C', '\x1D',
-                        '\x1E', '\x1F', '\x22', '\x3C', '\x3E', '\x7C', ':', '*', '?', '\\', '/'
-                    };
-
-                    foreach (char c in invalidCharacters)
-                        entry = entry.Replace(c.ToString(), string.Empty);
-
-                    return entry;
-                }
+                string baseFilename = (metadata.Artist.Length > 0 ? metadata.Artist + @" - " + metadata.Title : Path.GetFileNameWithoutExtension(metadata.AudioFile))
+                                      + (metadata.Author.Username.Length > 0 ? @" (" + metadata.Author.Username + @")" : string.Empty)
+                                      + @".osb";
+                return baseFilename.GetValidFilename();
             }
         }
     }
diff --git a/osu.Game/Database/RealmArchiveModelImporter.cs b/osu.Game/Database/RealmArchiveModelImporter.cs
index a3cdc2dc77..aefb628422 100644
--- a/osu.Game/Database/RealmArchiveModelImporter.cs
+++ b/osu.Game/Database/RealmArchiveModelImporter.cs
@@ -208,7 +208,18 @@ namespace osu.Game.Database
             foreach (var realmFile in model.Files)
             {
                 string sourcePath = Files.Storage.GetFullPath(realmFile.File.GetStoragePath());
-                string destinationPath = Path.Join(mountedPath, realmFile.Filename);
+                // there are edge cases where externalising an imported model to the filesystem could fail due to invalid filenames.
+                // one scenario where this happens goes something like this:
+                // - stable user exports an archive, which contains filenames that get mangled by stable's default zip encoding codepage (Shift-JIS)
+                // - said archive is imported to lazer, but the invalid filename is not actually an issue due to lazer file store structure
+                //   (the file is stored under a filename correspondent to its SHA instead, and its real filename is only stored in realm)
+                // - however attempts to externally edit the model fail as the external edit attempts and fails to produce the file's "real" filename in the mounted path
+                // to prevent this bricking external edit, strip invalid characters on external edit.
+                // the presumption here is that whatever produced the mangled archive is primarily at fault here, and we're just trying to trudge on locally as best as possible.
+                // if there are further troubles related to similar issues, reevaluate moving this sort of check to the import side instead (sanitising filenames on import from archive).
+                string destinationPath = mountedPath;
+                foreach (string piece in realmFile.Filename.Split('/').Select(f => f.GetValidFilename()))
+                    destinationPath = Path.Combine(destinationPath, piece);
 
                 Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
 
diff --git a/osu.Game/Extensions/ModelExtensions.cs b/osu.Game/Extensions/ModelExtensions.cs
index 18c991297a..7c9d929999 100644
--- a/osu.Game/Extensions/ModelExtensions.cs
+++ b/osu.Game/Extensions/ModelExtensions.cs
@@ -175,6 +175,7 @@ namespace osu.Game.Extensions
         /// DO NOT CHANGE THE SEMANTICS OF THIS METHOD unless you know well what you are doing.
         /// </para>
         /// </remarks>
+        /// <seealso href="https://github.com/peppy/osu-stable-reference/blob/67795dba3c308e7d0493b296149dcb073ca47ecb/osu!common/Helpers/GeneralHelper.cs#L41-L46"/>
         public static string GetValidFilename(this string filename)
         {
             foreach (char c in invalid_filename_chars)
diff --git a/osu.Game/Extensions/NumberFormattingExtensions.cs b/osu.Game/Extensions/NumberFormattingExtensions.cs
index 33252448fc..ff35dbc2a0 100644
--- a/osu.Game/Extensions/NumberFormattingExtensions.cs
+++ b/osu.Game/Extensions/NumberFormattingExtensions.cs
@@ -36,7 +36,7 @@ namespace osu.Game.Extensions
 
             string negativeSign = Math.Round(floatValue, significantDigits) < 0 ? "-" : string.Empty;
 
-            return FormattableString.Invariant($"{negativeSign}{Math.Abs(floatValue).ToString($"N{significantDigits}")}");
+            return $"{negativeSign}{Math.Abs(floatValue).ToString($"N{significantDigits}", CultureInfo.InvariantCulture)}";
         }
 
         /// <summary>
diff --git a/osu.Game/Graphics/Carousel/Carousel_ScrollContainer.cs b/osu.Game/Graphics/Carousel/Carousel.ScrollContainer.cs
similarity index 100%
rename from osu.Game/Graphics/Carousel/Carousel_ScrollContainer.cs
rename to osu.Game/Graphics/Carousel/Carousel.ScrollContainer.cs
diff --git a/osu.Game/Graphics/Carousel/Carousel.cs b/osu.Game/Graphics/Carousel/Carousel.cs
index 7b5aea08b6..b605efc69d 100644
--- a/osu.Game/Graphics/Carousel/Carousel.cs
+++ b/osu.Game/Graphics/Carousel/Carousel.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
@@ -79,7 +80,7 @@ namespace osu.Game.Graphics.Carousel
         /// <summary>
         /// The number of times filter operations have been triggered.
         /// </summary>
-        internal int FilterCount { get; private set; }
+        public int FilterCount { get; private set; }
 
         /// <summary>
         /// The number of displayable items currently being tracked (before filtering).
@@ -106,7 +107,7 @@ namespace osu.Game.Graphics.Carousel
         /// The selection is never reset due to not existing. It can be set to anything.
         /// If no matching carousel item exists, there will be no visually selected item while waiting for potential new item which matches.
         /// </remarks>
-        public object? CurrentSelection
+        protected object? CurrentSelection
         {
             get => currentSelection.Model;
             set
@@ -210,6 +211,12 @@ namespace osu.Game.Graphics.Carousel
             return filterTask;
         }
 
+        /// <summary>
+        /// Called when <see cref="Items"/> changes in any way.
+        /// </summary>
+        /// <returns>Whether a re-filter is required.</returns>
+        protected virtual bool HandleItemsChanged(NotifyCollectionChangedEventArgs args) => true;
+
         /// <summary>
         /// Fired after a filter operation completed.
         /// </summary>
@@ -301,7 +308,11 @@ namespace osu.Game.Graphics.Carousel
                 RelativeSizeAxes = Axes.Both,
             };
 
-            Items.BindCollectionChanged((_, _) => filterAfterItemsChanged.Invalidate());
+            Items.BindCollectionChanged((_, args) =>
+            {
+                if (HandleItemsChanged(args))
+                    filterAfterItemsChanged.Invalidate();
+            });
         }
 
         [BackgroundDependencyLoader]
@@ -442,8 +453,7 @@ namespace osu.Game.Graphics.Carousel
                 // matching with exact modifier consideration (so Ctrl+Enter would be ignored).
                 case Key.Enter:
                 case Key.KeypadEnter:
-                    activateSelection();
-                    return true;
+                    return activateSelection();
             }
 
             return base.OnKeyDown(e);
@@ -454,8 +464,7 @@ namespace osu.Game.Graphics.Carousel
             switch (e.Action)
             {
                 case GlobalAction.Select:
-                    activateSelection();
-                    return true;
+                    return activateSelection();
 
                 // the selection traversal handlers below are scheduled to avoid an issue
                 // wherein if the update frame rate is low, keeping one of the actions below pressed leads to selection moving back to the start / end.
@@ -549,10 +558,15 @@ namespace osu.Game.Graphics.Carousel
         {
         }
 
-        private void activateSelection()
+        private bool activateSelection()
         {
             if (currentKeyboardSelection.CarouselItem != null)
+            {
                 Activate(currentKeyboardSelection.CarouselItem);
+                return true;
+            }
+
+            return false;
         }
 
         private void traverseKeyboardSelection(int direction)
@@ -750,10 +764,10 @@ namespace osu.Game.Graphics.Carousel
                 updateItemYPosition(item, ref lastVisible, ref yPos);
 
                 if (CheckModelEquality(item.Model, currentKeyboardSelection.Model!))
-                    currentKeyboardSelection = new Selection(currentKeyboardSelection.Model, item, item.CarouselYPosition, i);
+                    currentKeyboardSelection = new Selection(currentKeyboardSelection.Model, item, item.CarouselYPosition + item.DrawHeight / 2, i);
 
                 if (CheckModelEquality(item.Model, currentSelection.Model!))
-                    currentSelection = new Selection(currentSelection.Model, item, item.CarouselYPosition, i);
+                    currentSelection = new Selection(currentSelection.Model, item, item.CarouselYPosition + item.DrawHeight / 2, i);
             }
 
             // Update the total height of all items (to make the scroll container scrollable through the full height even though
diff --git a/osu.Game/Graphics/Containers/OsuClickableContainer.cs b/osu.Game/Graphics/Containers/OsuClickableContainer.cs
index fceee90d06..dbc354ae07 100644
--- a/osu.Game/Graphics/Containers/OsuClickableContainer.cs
+++ b/osu.Game/Graphics/Containers/OsuClickableContainer.cs
@@ -18,6 +18,8 @@ namespace osu.Game.Graphics.Containers
 
         private readonly Container content = new Container { RelativeSizeAxes = Axes.Both };
 
+        private HoverSounds samples = null!;
+
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) =>
             // base call is checked for cases when `OsuClickableContainer` has masking applied to it directly (ie. externally in object initialisation).
             base.ReceivePositionalInputAt(screenSpacePos)
@@ -33,6 +35,14 @@ namespace osu.Game.Graphics.Containers
             this.sampleSet = sampleSet;
         }
 
+        public void TriggerClickWithSound()
+        {
+            TriggerClick();
+
+            // TriggerClick doesn't recursively fire the event so we need to manually do this.
+            (samples as HoverClickSounds)?.PlayClickSample();
+        }
+
         public virtual LocalisableString TooltipText { get; set; }
 
         [BackgroundDependencyLoader]
@@ -46,7 +56,7 @@ namespace osu.Game.Graphics.Containers
 
             AddRangeInternal(new Drawable[]
             {
-                CreateHoverSounds(sampleSet),
+                samples = CreateHoverSounds(sampleSet),
                 content,
             });
         }
diff --git a/osu.Game/Graphics/DrawableDate.cs b/osu.Game/Graphics/DrawableDate.cs
index 0e5bcc8019..7af4df2d25 100644
--- a/osu.Game/Graphics/DrawableDate.cs
+++ b/osu.Game/Graphics/DrawableDate.cs
@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
+using osu.Framework.Localisation;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Utils;
 
@@ -71,12 +72,32 @@ namespace osu.Game.Graphics
             Scheduler.AddDelayed(updateTimeWithReschedule, timeUntilNextUpdate);
         }
 
-        protected virtual string Format() => HumanizerUtils.Humanize(Date);
+        protected virtual LocalisableString Format() => new LocalisableString(new HumanisedDate(Date));
 
         private void updateTime() => Text = Format();
 
         public ITooltip<DateTimeOffset> GetCustomTooltip() => new DateTooltip();
 
         public DateTimeOffset TooltipContent => Date;
+
+        private class HumanisedDate : IEquatable<HumanisedDate>, ILocalisableStringData
+        {
+            public readonly DateTimeOffset Date;
+
+            public HumanisedDate(DateTimeOffset date)
+            {
+                Date = date;
+            }
+
+            public bool Equals(HumanisedDate? other)
+                => other?.Date != null && Date.Equals(other.Date);
+
+            public bool Equals(ILocalisableStringData? other)
+                => other is HumanisedDate otherDate && Equals(otherDate);
+
+            public string GetLocalised(LocalisationParameters parameters) => HumanizerUtils.Humanize(Date);
+
+            public override string ToString() => GetLocalised(LocalisationParameters.DEFAULT);
+        }
     }
 }
diff --git a/osu.Game/Graphics/OsuIcon.cs b/osu.Game/Graphics/OsuIcon.cs
index 3a8dfac826..0cf2acadda 100644
--- a/osu.Game/Graphics/OsuIcon.cs
+++ b/osu.Game/Graphics/OsuIcon.cs
@@ -16,77 +16,19 @@ namespace osu.Game.Graphics
 {
     public static class OsuIcon
     {
-        #region Legacy spritesheet-based icons
-
-        private static IconUsage get(int icon) => new IconUsage((char)icon, @"osuFont");
-
-        // ruleset icons in circles
-        public static IconUsage RulesetOsu => get(0xe000);
-        public static IconUsage RulesetMania => get(0xe001);
-        public static IconUsage RulesetCatch => get(0xe002);
-        public static IconUsage RulesetTaiko => get(0xe003);
-
-        // ruleset icons without circles
-        public static IconUsage FilledCircle => get(0xe004);
-        public static IconUsage Logo => get(0xe006);
-        public static IconUsage ChevronDownCircle => get(0xe007);
-        public static IconUsage EditCircle => get(0xe033);
-        public static IconUsage LeftCircle => get(0xe034);
-        public static IconUsage RightCircle => get(0xe035);
-        public static IconUsage Charts => get(0xe036);
-        public static IconUsage Solo => get(0xe037);
-        public static IconUsage Multi => get(0xe038);
-        public static IconUsage Gear => get(0xe039);
-
-        // misc icons
-        public static IconUsage Bat => get(0xe008);
-        public static IconUsage Bubble => get(0xe009);
-        public static IconUsage BubblePop => get(0xe02e);
-        public static IconUsage Dice => get(0xe011);
-        public static IconUsage HeartBreak => get(0xe030);
-        public static IconUsage Hot => get(0xe031);
-        public static IconUsage ListSearch => get(0xe032);
-
-        //osu! playstyles
-        public static IconUsage PlayStyleTablet => get(0xe02a);
-        public static IconUsage PlayStyleMouse => get(0xe029);
-        public static IconUsage PlayStyleKeyboard => get(0xe02b);
-        public static IconUsage PlayStyleTouch => get(0xe02c);
-
-        // osu! difficulties
-        public static IconUsage EasyOsu => get(0xe015);
-        public static IconUsage NormalOsu => get(0xe016);
-        public static IconUsage HardOsu => get(0xe017);
-        public static IconUsage InsaneOsu => get(0xe018);
-        public static IconUsage ExpertOsu => get(0xe019);
-
-        // taiko difficulties
-        public static IconUsage EasyTaiko => get(0xe01a);
-        public static IconUsage NormalTaiko => get(0xe01b);
-        public static IconUsage HardTaiko => get(0xe01c);
-        public static IconUsage InsaneTaiko => get(0xe01d);
-        public static IconUsage ExpertTaiko => get(0xe01e);
-
-        // fruits difficulties
-        public static IconUsage EasyFruits => get(0xe01f);
-        public static IconUsage NormalFruits => get(0xe020);
-        public static IconUsage HardFruits => get(0xe021);
-        public static IconUsage InsaneFruits => get(0xe022);
-        public static IconUsage ExpertFruits => get(0xe023);
-
-        // mania difficulties
-        public static IconUsage EasyMania => get(0xe024);
-        public static IconUsage NormalMania => get(0xe025);
-        public static IconUsage HardMania => get(0xe026);
-        public static IconUsage InsaneMania => get(0xe027);
-        public static IconUsage ExpertMania => get(0xe028);
-
-        #endregion
-
-        #region New single-file-based icons
-
         public const string FONT_NAME = @"Icons";
 
+        // ruleset icons
+        public static IconUsage RulesetOsu => get(OsuIconMapping.RulesetOsu);
+        public static IconUsage RulesetMania => get(OsuIconMapping.RulesetMania);
+        public static IconUsage RulesetCatch => get(OsuIconMapping.RulesetCatch);
+        public static IconUsage RulesetTaiko => get(OsuIconMapping.RulesetTaiko);
+
+        public static IconUsage Logo => get(OsuIconMapping.Logo);
+        public static IconUsage EditCircle => get(OsuIconMapping.EditCircle);
+        public static IconUsage LeftCircle => get(OsuIconMapping.LeftCircle);
+        public static IconUsage RightCircle => get(OsuIconMapping.RightCircle);
+
         public static IconUsage Audio => get(OsuIconMapping.Audio);
         public static IconUsage Beatmap => get(OsuIconMapping.Beatmap);
         public static IconUsage Calendar => get(OsuIconMapping.Calendar);
@@ -246,6 +188,30 @@ namespace osu.Game.Graphics
 
         private enum OsuIconMapping
         {
+            [Description(@"Logo")]
+            Logo,
+
+            [Description(@"RulesetOsu")]
+            RulesetOsu,
+
+            [Description(@"RulesetMania")]
+            RulesetMania,
+
+            [Description(@"RulesetCatch")]
+            RulesetCatch,
+
+            [Description(@"RulesetTaiko")]
+            RulesetTaiko,
+
+            [Description(@"EditCircle")]
+            EditCircle,
+
+            [Description(@"LeftCircle")]
+            LeftCircle,
+
+            [Description(@"RightCircle")]
+            RightCircle,
+
             [Description(@"audio")]
             Audio,
 
@@ -737,7 +703,5 @@ namespace osu.Game.Graphics
                 textures.Dispose();
             }
         }
-
-        #endregion
     }
 }
diff --git a/osu.Game/Graphics/UserInterface/HoverClickSounds.cs b/osu.Game/Graphics/UserInterface/HoverClickSounds.cs
index 884834ebe8..fea33bfa9d 100644
--- a/osu.Game/Graphics/UserInterface/HoverClickSounds.cs
+++ b/osu.Game/Graphics/UserInterface/HoverClickSounds.cs
@@ -42,18 +42,20 @@ namespace osu.Game.Graphics.UserInterface
             this.buttons = buttons ?? new[] { MouseButton.Left };
         }
 
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            sampleClick = audio.Samples.Get($@"UI/{SampleSet.GetDescription()}-select")
+                          ?? audio.Samples.Get($@"UI/{HoverSampleSet.Default.GetDescription()}-select");
+
+            sampleClickDisabled = audio.Samples.Get($@"UI/{SampleSet.GetDescription()}-select-disabled")
+                                  ?? audio.Samples.Get($@"UI/{HoverSampleSet.Default.GetDescription()}-select-disabled");
+        }
+
         protected override bool OnClick(ClickEvent e)
         {
             if (buttons.Contains(e.Button))
-            {
-                var channel = Enabled.Value ? sampleClick?.GetChannel() : sampleClickDisabled?.GetChannel();
-
-                if (channel != null)
-                {
-                    channel.Frequency.Value = 0.99 + RNG.NextDouble(0.02);
-                    channel.Play();
-                }
-            }
+                PlayClickSample();
 
             return base.OnClick(e);
         }
@@ -66,14 +68,15 @@ namespace osu.Game.Graphics.UserInterface
             base.PlayHoverSample();
         }
 
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        public void PlayClickSample()
         {
-            sampleClick = audio.Samples.Get($@"UI/{SampleSet.GetDescription()}-select")
-                          ?? audio.Samples.Get($@"UI/{HoverSampleSet.Default.GetDescription()}-select");
+            var channel = Enabled.Value ? sampleClick?.GetChannel() : sampleClickDisabled?.GetChannel();
 
-            sampleClickDisabled = audio.Samples.Get($@"UI/{SampleSet.GetDescription()}-select-disabled")
-                                  ?? audio.Samples.Get($@"UI/{HoverSampleSet.Default.GetDescription()}-select-disabled");
+            if (channel != null)
+            {
+                channel.Frequency.Value = 0.99 + RNG.NextDouble(0.02);
+                channel.Play();
+            }
         }
     }
 }
diff --git a/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs b/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs
index e365e20ad5..af69aefaaf 100644
--- a/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/ShearedDropdown.cs
@@ -34,8 +34,6 @@ namespace osu.Game.Graphics.UserInterfaceV2
                 osuHeader.Dropdown = this;
                 osuHeader.LeftSideLabel = label;
             }
-
-            AddInternal(new HoverClickSounds());
         }
 
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
@@ -192,6 +190,8 @@ namespace osu.Game.Graphics.UserInterfaceV2
                         }
                     },
                 };
+
+                AddInternal(new HoverClickSounds());
             }
 
             [BackgroundDependencyLoader]
diff --git a/osu.Game/Localisation/MenuTipStrings.cs b/osu.Game/Localisation/MenuTipStrings.cs
index 4d1f2ceaa6..ebab9f4d02 100644
--- a/osu.Game/Localisation/MenuTipStrings.cs
+++ b/osu.Game/Localisation/MenuTipStrings.cs
@@ -154,6 +154,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString RightMouseAbsoluteScroll => new TranslatableString(getKey(@"right_mouse_absolute_scroll"), @"Try holding your right mouse button near the beatmap carousel to quickly scroll to an absolute position!");
 
+        /// <summary>
+        /// "Shift-click on a beatmap panel in the beatmap listing overlay to quickly download or view the beatmap in song select!"
+        /// </summary>
+        public static LocalisableString ShiftClickInBeatmapOverlay => new TranslatableString(getKey(@"shift_click_in_beatmap_overlay"), @"Shift-click on a beatmap panel in the beatmap listing overlay to quickly download or view the beatmap in song select!");
+
         /// <summary>
         /// "a tip for you:"
         /// </summary>
diff --git a/osu.Game/Online/API/APIAccess.cs b/osu.Game/Online/API/APIAccess.cs
index 54eed58c13..58171a2f8a 100644
--- a/osu.Game/Online/API/APIAccess.cs
+++ b/osu.Game/Online/API/APIAccess.cs
@@ -15,6 +15,7 @@ using System.Threading.Tasks;
 using Newtonsoft.Json.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Development;
+using osu.Framework.Extensions;
 using osu.Framework.Extensions.ExceptionExtensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
@@ -52,6 +53,8 @@ namespace osu.Game.Online.API
 
         public string ProvidedUsername { get; private set; }
 
+        public SessionVerificationMethod? SessionVerificationMethod { get; set; }
+
         public string SecondFactorCode { get; private set; }
 
         private string password;
@@ -292,7 +295,17 @@ namespace osu.Game.Online.API
                     verificationRequest.Failure += ex =>
                     {
                         state.Value = APIState.RequiresSecondFactorAuth;
-                        LastLoginError = ex;
+
+                        if (verificationRequest.RequiredVerificationMethod != null)
+                        {
+                            SessionVerificationMethod = verificationRequest.RequiredVerificationMethod;
+                            LastLoginError = new APIException($"Must use {SessionVerificationMethod.GetDescription().ToLowerInvariant()} to complete verification.", ex);
+                        }
+                        else
+                        {
+                            LastLoginError = ex;
+                        }
+
                         SecondFactorCode = null;
                     };
 
@@ -337,7 +350,8 @@ namespace osu.Game.Online.API
 
                         localUser.Value = me;
                         configSupporter.Value = me.IsSupporter;
-                        state.Value = me.SessionVerified ? APIState.Online : APIState.RequiresSecondFactorAuth;
+                        SessionVerificationMethod = me.SessionVerificationMethod;
+                        state.Value = SessionVerificationMethod == null ? APIState.Online : APIState.RequiresSecondFactorAuth;
                         failureCount = 0;
                     };
 
diff --git a/osu.Game/Online/API/DummyAPIAccess.cs b/osu.Game/Online/API/DummyAPIAccess.cs
index 74e0ca2873..9750fccb74 100644
--- a/osu.Game/Online/API/DummyAPIAccess.cs
+++ b/osu.Game/Online/API/DummyAPIAccess.cs
@@ -5,6 +5,7 @@ using System;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Game.Localisation;
 using osu.Game.Online.API.Requests;
@@ -62,7 +63,8 @@ namespace osu.Game.Online.API
 
         private bool shouldFailNextLogin;
         private bool stayConnectingNextLogin;
-        private bool requiredSecondFactorAuth = true;
+
+        public SessionVerificationMethod? SessionVerificationMethod { get; set; } = Requests.Responses.SessionVerificationMethod.EmailMessage;
 
         /// <summary>
         /// The current connectivity state of the API.
@@ -130,14 +132,14 @@ namespace osu.Game.Online.API
                 Id = DUMMY_USER_ID,
             };
 
-            if (requiredSecondFactorAuth)
+            if (SessionVerificationMethod != null)
             {
                 state.Value = APIState.RequiresSecondFactorAuth;
             }
             else
             {
                 onSuccessfulLogin();
-                requiredSecondFactorAuth = true;
+                SessionVerificationMethod = null;
             }
         }
 
@@ -147,7 +149,16 @@ namespace osu.Game.Online.API
             request.Failure += e =>
             {
                 state.Value = APIState.RequiresSecondFactorAuth;
-                LastLoginError = e;
+
+                if (request.RequiredVerificationMethod != null)
+                {
+                    SessionVerificationMethod = request.RequiredVerificationMethod;
+                    LastLoginError = new APIException($"Must use {SessionVerificationMethod.GetDescription().ToLowerInvariant()} to complete verification.", e);
+                }
+                else
+                {
+                    LastLoginError = e;
+                }
             };
 
             state.Value = APIState.Connecting;
@@ -204,7 +215,7 @@ namespace osu.Game.Online.API
         /// <summary>
         /// Skip 2FA requirement for next login.
         /// </summary>
-        public void SkipSecondFactor() => requiredSecondFactorAuth = false;
+        public void SkipSecondFactor() => SessionVerificationMethod = null;
 
         /// <summary>
         /// During the next simulated login, the process will fail immediately.
diff --git a/osu.Game/Online/API/IAPIProvider.cs b/osu.Game/Online/API/IAPIProvider.cs
index 2634ea137f..f3ced9b1ce 100644
--- a/osu.Game/Online/API/IAPIProvider.cs
+++ b/osu.Game/Online/API/IAPIProvider.cs
@@ -107,10 +107,15 @@ namespace osu.Game.Online.API
         /// <param name="password">The user's password.</param>
         void Login(string username, string password);
 
+        /// <summary>
+        /// The <see cref="SessionVerificationMethod"/> requested by the server to complete verification.
+        /// </summary>
+        SessionVerificationMethod? SessionVerificationMethod { get; }
+
         /// <summary>
         /// Provide a second-factor authentication code for authentication.
         /// </summary>
-        /// <param name="code">The 2FA code.</param>
+        /// <paramref name="code">The 2FA code.</paramref>
         void AuthenticateSecondFactor(string code);
 
         /// <summary>
diff --git a/osu.Game/Online/API/Requests/Responses/APIMe.cs b/osu.Game/Online/API/Requests/Responses/APIMe.cs
index 3cbddbe5e7..f1fa9d5f2b 100644
--- a/osu.Game/Online/API/Requests/Responses/APIMe.cs
+++ b/osu.Game/Online/API/Requests/Responses/APIMe.cs
@@ -1,13 +1,26 @@
 // 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 System.Runtime.Serialization;
 using Newtonsoft.Json;
 
 namespace osu.Game.Online.API.Requests.Responses
 {
     public class APIMe : APIUser
     {
-        [JsonProperty("session_verified")]
-        public bool SessionVerified { get; set; }
+        [JsonProperty("session_verification_method")]
+        public SessionVerificationMethod? SessionVerificationMethod { get; set; }
+    }
+
+    public enum SessionVerificationMethod
+    {
+        [Description("Timed one-time password")]
+        [EnumMember(Value = "totp")]
+        TimedOneTimePassword,
+
+        [Description("E-mail")]
+        [EnumMember(Value = "mail")]
+        EmailMessage,
     }
 }
diff --git a/osu.Game/Online/API/Requests/VerificationMailFallbackRequest.cs b/osu.Game/Online/API/Requests/VerificationMailFallbackRequest.cs
new file mode 100644
index 0000000000..6ea652d647
--- /dev/null
+++ b/osu.Game/Online/API/Requests/VerificationMailFallbackRequest.cs
@@ -0,0 +1,20 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Net.Http;
+using osu.Framework.IO.Network;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class VerificationMailFallbackRequest : APIRequest
+    {
+        protected override string Target => @"session/verify/mail-fallback";
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+            req.Method = HttpMethod.Post;
+            return req;
+        }
+    }
+}
diff --git a/osu.Game/Online/API/Requests/VerifySessionRequest.cs b/osu.Game/Online/API/Requests/VerifySessionRequest.cs
index b39ec5b79a..d8f622348b 100644
--- a/osu.Game/Online/API/Requests/VerifySessionRequest.cs
+++ b/osu.Game/Online/API/Requests/VerifySessionRequest.cs
@@ -2,7 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Net.Http;
+using Newtonsoft.Json;
 using osu.Framework.IO.Network;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Online.API.Requests
 {
@@ -13,6 +15,16 @@ namespace osu.Game.Online.API.Requests
         public VerifySessionRequest(string verificationKey)
         {
             VerificationKey = verificationKey;
+
+            Failure += _ =>
+            {
+                string? response = WebRequest?.GetResponseString();
+                if (string.IsNullOrEmpty(response))
+                    return;
+
+                var responseObject = JsonConvert.DeserializeObject<VerificationFailureResponse>(response);
+                RequiredVerificationMethod = responseObject?.RequiredSessionVerificationMethod;
+            };
         }
 
         protected override WebRequest CreateWebRequest()
@@ -26,5 +38,13 @@ namespace osu.Game.Online.API.Requests
         }
 
         protected override string Target => @"session/verify";
+
+        public SessionVerificationMethod? RequiredVerificationMethod { get; internal set; }
+
+        private class VerificationFailureResponse
+        {
+            [JsonProperty("method")]
+            public SessionVerificationMethod RequiredSessionVerificationMethod { get; set; }
+        }
     }
 }
diff --git a/osu.Game/Online/Leaderboards/DrawableRank.cs b/osu.Game/Online/Leaderboards/DrawableRank.cs
index 3bc80c8b37..f4f4165c7f 100644
--- a/osu.Game/Online/Leaderboards/DrawableRank.cs
+++ b/osu.Game/Online/Leaderboards/DrawableRank.cs
@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Extensions;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -53,9 +52,9 @@ namespace osu.Game.Online.Leaderboards
                             Origin = Anchor.Centre,
                             Spacing = new Vector2(-3, 0),
                             Padding = new MarginPadding { Top = 5 },
-                            Colour = GetRankNameColour(rank),
+                            Colour = GetRankLetterColour(rank),
                             Font = OsuFont.Numeric.With(size: 25),
-                            Text = GetRankName(rank),
+                            Text = GetRankLetter(rank),
                             ShadowColour = Color4.Black.Opacity(0.3f),
                             ShadowOffset = new Vector2(0, 0.08f),
                             Shadow = true,
@@ -65,12 +64,29 @@ namespace osu.Game.Online.Leaderboards
             };
         }
 
-        public static string GetRankName(ScoreRank rank) => rank.GetDescription().TrimEnd('+');
+        /// <summary>
+        /// Returns letters to be shown in places where ranks are shown on a badge or similar to the user.
+        /// </summary>
+        public static string GetRankLetter(ScoreRank rank)
+        {
+            switch (rank)
+            {
+                case ScoreRank.SH:
+                    return @"S";
+
+                case ScoreRank.X:
+                case ScoreRank.XH:
+                    return @"SS";
+
+                default:
+                    return rank.ToString();
+            }
+        }
 
         /// <summary>
         ///  Retrieves the grade text colour.
         /// </summary>
-        public static ColourInfo GetRankNameColour(ScoreRank rank)
+        public static ColourInfo GetRankLetterColour(ScoreRank rank)
         {
             switch (rank)
             {
diff --git a/osu.Game/Online/Leaderboards/LeaderboardScore.cs b/osu.Game/Online/Leaderboards/LeaderboardScore.cs
index 8a30c4315b..0f29163e39 100644
--- a/osu.Game/Online/Leaderboards/LeaderboardScore.cs
+++ b/osu.Game/Online/Leaderboards/LeaderboardScore.cs
@@ -429,7 +429,7 @@ namespace osu.Game.Online.Leaderboards
                 Font = OsuFont.GetFont(size: 16, weight: FontWeight.Bold);
             }
 
-            protected override string Format() => Date.ToShortRelativeTime(TimeSpan.FromSeconds(30));
+            protected override LocalisableString Format() => Date.ToShortRelativeTime(TimeSpan.FromSeconds(30));
         }
 
         public class LeaderboardScoreStatistic
diff --git a/osu.Game/Online/Matchmaking/Events/MatchmakingAvatarAction.cs b/osu.Game/Online/Matchmaking/Events/MatchmakingAvatarAction.cs
new file mode 100644
index 0000000000..cab007327c
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/Events/MatchmakingAvatarAction.cs
@@ -0,0 +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.
+
+namespace osu.Game.Online.Matchmaking.Events
+{
+    /// <summary>
+    /// An action performed on a user's avatar in a matchmaking room.
+    /// </summary>
+    public enum MatchmakingAvatarAction
+    {
+        Jump
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/Events/MatchmakingAvatarActionEvent.cs b/osu.Game/Online/Matchmaking/Events/MatchmakingAvatarActionEvent.cs
new file mode 100644
index 0000000000..187d234855
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/Events/MatchmakingAvatarActionEvent.cs
@@ -0,0 +1,29 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using MessagePack;
+using osu.Game.Online.Multiplayer;
+
+namespace osu.Game.Online.Matchmaking.Events
+{
+    /// <summary>
+    /// An action performed by a user in a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingAvatarActionEvent : MatchServerEvent
+    {
+        /// <summary>
+        /// The user performing the action.
+        /// </summary>
+        [Key(0)]
+        public int UserId { get; set; }
+
+        /// <summary>
+        /// The action.
+        /// </summary>
+        [Key(1)]
+        public MatchmakingAvatarAction Action { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/Events/MatchmakingAvatarActionRequest.cs b/osu.Game/Online/Matchmaking/Events/MatchmakingAvatarActionRequest.cs
new file mode 100644
index 0000000000..abee95f0e2
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/Events/MatchmakingAvatarActionRequest.cs
@@ -0,0 +1,23 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using MessagePack;
+using osu.Game.Online.Multiplayer;
+
+namespace osu.Game.Online.Matchmaking.Events
+{
+    /// <summary>
+    /// Requests to perform an action on a user's avatar in a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingAvatarActionRequest : MatchUserRequest
+    {
+        /// <summary>
+        /// The action.
+        /// </summary>
+        [Key(0)]
+        public MatchmakingAvatarAction Action { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/IMatchmakingClient.cs b/osu.Game/Online/Matchmaking/IMatchmakingClient.cs
new file mode 100644
index 0000000000..70e1ce0b5d
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/IMatchmakingClient.cs
@@ -0,0 +1,53 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Threading.Tasks;
+
+namespace osu.Game.Online.Matchmaking
+{
+    public interface IMatchmakingClient : IStatefulUserHubClient
+    {
+        /// <summary>
+        /// Signals that the local user was placed in the matchmaking queue.
+        /// </summary>
+        Task MatchmakingQueueJoined();
+
+        /// <summary>
+        /// Signals that the local user was removed from the matchmaking queue.
+        /// </summary>
+        Task MatchmakingQueueLeft();
+
+        /// <summary>
+        /// Signals that a match has been found and the local user is invited to it.
+        /// The invitation may be <see cref="IMatchmakingServer.MatchmakingAcceptInvitation">accepted</see>,
+        /// <see cref="IMatchmakingServer.MatchmakingDeclineInvitation">declined</see>,
+        /// or ignored - in which case it will automatically be declined after a short timeout period.
+        /// </summary>
+        Task MatchmakingRoomInvited();
+
+        /// <summary>
+        /// Signals that the matchmaking room is ready to be opened.
+        /// </summary>
+        Task MatchmakingRoomReady(long roomId, string password);
+
+        /// <summary>
+        /// The matchmaking lobby status has changed.
+        /// </summary>
+        Task MatchmakingLobbyStatusChanged(MatchmakingLobbyStatus status);
+
+        /// <summary>
+        /// The matchmaking status of the current user has changed.
+        /// </summary>
+        Task MatchmakingQueueStatusChanged(MatchmakingQueueStatus status);
+
+        /// <summary>
+        /// The user has raised a candidate playlist item to be played.
+        /// </summary>
+        Task MatchmakingItemSelected(int userId, long playlistItemId);
+
+        /// <summary>
+        /// The user has removed a candidate playlist item.
+        /// </summary>
+        Task MatchmakingItemDeselected(int userId, long playlistItemId);
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/IMatchmakingServer.cs b/osu.Game/Online/Matchmaking/IMatchmakingServer.cs
new file mode 100644
index 0000000000..66fd8c36da
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/IMatchmakingServer.cs
@@ -0,0 +1,56 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Threading.Tasks;
+
+namespace osu.Game.Online.Matchmaking
+{
+    public interface IMatchmakingServer
+    {
+        /// <summary>
+        /// Retrieves all active matchmaking pools.
+        /// </summary>
+        Task<MatchmakingPool[]> GetMatchmakingPools();
+
+        /// <summary>
+        /// Joins the matchmaking lobby, allowing the local user to receive status updates.
+        /// </summary>
+        Task MatchmakingJoinLobby();
+
+        /// <summary>
+        /// Leaves the matchmaking lobby.
+        /// </summary>
+        Task MatchmakingLeaveLobby();
+
+        /// <summary>
+        /// Joins the matchmaking queue, allowing the local user to get matched up with others.
+        /// </summary>
+        Task MatchmakingJoinQueue(int poolId);
+
+        /// <summary>
+        /// Leaves the matchmaking queue.
+        /// </summary>
+        Task MatchmakingLeaveQueue();
+
+        /// <summary>
+        /// Accepts a matchmaking room invitation.
+        /// </summary>
+        Task MatchmakingAcceptInvitation();
+
+        /// <summary>
+        /// Declines a matchmaking room invitation.
+        /// </summary>
+        Task MatchmakingDeclineInvitation();
+
+        /// <summary>
+        /// Raise a candidate playlist item to be played in the current round.
+        /// </summary>
+        /// <param name="playlistItemId">The playlist item.</param>
+        Task MatchmakingToggleSelection(long playlistItemId);
+
+        /// <summary>
+        /// Debug only - skips to the next stage of the matchmaking room.
+        /// </summary>
+        Task MatchmakingSkipToNextStage();
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/MatchmakingLobbyStatus.cs b/osu.Game/Online/Matchmaking/MatchmakingLobbyStatus.cs
new file mode 100644
index 0000000000..9a1e083b84
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/MatchmakingLobbyStatus.cs
@@ -0,0 +1,16 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using MessagePack;
+
+namespace osu.Game.Online.Matchmaking
+{
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingLobbyStatus
+    {
+        [Key(0)]
+        public int[] UsersInQueue { get; set; } = [];
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/MatchmakingPool.cs b/osu.Game/Online/Matchmaking/MatchmakingPool.cs
new file mode 100644
index 0000000000..3f256d5251
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/MatchmakingPool.cs
@@ -0,0 +1,39 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using MessagePack;
+
+namespace osu.Game.Online.Matchmaking
+{
+    [MessagePackObject]
+    [Serializable]
+    public class MatchmakingPool : IEquatable<MatchmakingPool>
+    {
+        [Key(0)]
+        public int Id { get; set; }
+
+        [Key(1)]
+        public int RulesetId { get; set; }
+
+        [Key(2)]
+        public int Variant { get; set; }
+
+        [Key(3)]
+        public string Name { get; set; } = string.Empty;
+
+        public bool Equals(MatchmakingPool? other)
+            => other != null
+               && Id == other.Id
+               && RulesetId == other.RulesetId
+               && Variant == other.Variant
+               && Name == other.Name;
+
+        public override bool Equals(object? obj)
+            => obj is MatchmakingPool other && Equals(other);
+
+        [SuppressMessage("ReSharper", "NonReadonlyMemberInGetHashCode")]
+        public override int GetHashCode() => HashCode.Combine(Id, RulesetId, Variant, Name);
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/MatchmakingQueueStatus.cs b/osu.Game/Online/Matchmaking/MatchmakingQueueStatus.cs
new file mode 100644
index 0000000000..a57e04bd10
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/MatchmakingQueueStatus.cs
@@ -0,0 +1,34 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using MessagePack;
+
+namespace osu.Game.Online.Matchmaking
+{
+    [Serializable]
+    [MessagePackObject]
+    [Union(0, typeof(Searching))] // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
+    [Union(1, typeof(MatchFound))]
+    [Union(2, typeof(JoiningMatch))]
+    public abstract class MatchmakingQueueStatus
+    {
+        [Serializable]
+        [MessagePackObject]
+        public class Searching : MatchmakingQueueStatus
+        {
+        }
+
+        [Serializable]
+        [MessagePackObject]
+        public class MatchFound : MatchmakingQueueStatus
+        {
+        }
+
+        [Serializable]
+        [MessagePackObject]
+        public class JoiningMatch : MatchmakingQueueStatus
+        {
+        }
+    }
+}
diff --git a/osu.Game/Online/Matchmaking/MatchmakingStageCountdown.cs b/osu.Game/Online/Matchmaking/MatchmakingStageCountdown.cs
new file mode 100644
index 0000000000..8df1bb000a
--- /dev/null
+++ b/osu.Game/Online/Matchmaking/MatchmakingStageCountdown.cs
@@ -0,0 +1,16 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using MessagePack;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+
+namespace osu.Game.Online.Matchmaking
+{
+    [MessagePackObject]
+    public class MatchmakingStageCountdown : MultiplayerCountdown
+    {
+        [Key(2)]
+        public MatchmakingStage Stage { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchRoomState.cs b/osu.Game/Online/Multiplayer/MatchRoomState.cs
index cae3aaf7d0..25de8c7fab 100644
--- a/osu.Game/Online/Multiplayer/MatchRoomState.cs
+++ b/osu.Game/Online/Multiplayer/MatchRoomState.cs
@@ -3,6 +3,7 @@
 
 using System;
 using MessagePack;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 
 namespace osu.Game.Online.Multiplayer
@@ -14,6 +15,7 @@ namespace osu.Game.Online.Multiplayer
     [Serializable]
     [MessagePackObject]
     [Union(0, typeof(TeamVersusRoomState))] // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
+    [Union(1, typeof(MatchmakingRoomState))]
     public abstract class MatchRoomState
     {
     }
diff --git a/osu.Game/Online/Multiplayer/MatchServerEvent.cs b/osu.Game/Online/Multiplayer/MatchServerEvent.cs
index 376ff4d261..529a299438 100644
--- a/osu.Game/Online/Multiplayer/MatchServerEvent.cs
+++ b/osu.Game/Online/Multiplayer/MatchServerEvent.cs
@@ -3,6 +3,7 @@
 
 using System;
 using MessagePack;
+using osu.Game.Online.Matchmaking.Events;
 using osu.Game.Online.Multiplayer.Countdown;
 
 namespace osu.Game.Online.Multiplayer
@@ -15,6 +16,7 @@ namespace osu.Game.Online.Multiplayer
     // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
     [Union(0, typeof(CountdownStartedEvent))]
     [Union(1, typeof(CountdownStoppedEvent))]
+    [Union(2, typeof(MatchmakingAvatarActionEvent))]
     public abstract class MatchServerEvent
     {
     }
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoomState.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoomState.cs
new file mode 100644
index 0000000000..9e1953fc59
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoomState.cs
@@ -0,0 +1,101 @@
+// 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 MessagePack;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes the state of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingRoomState : MatchRoomState
+    {
+        /// <summary>
+        /// The current room status.
+        /// </summary>
+        [Key(0)]
+        public MatchmakingStage Stage { get; set; }
+
+        /// <summary>
+        /// The current round number (1-based).
+        /// </summary>
+        [Key(1)]
+        public int CurrentRound { get; set; }
+
+        /// <summary>
+        /// The playlist items that were picked as gameplay candidates.
+        /// </summary>
+        [Key(2)]
+        public long[] CandidateItems { get; set; } = [];
+
+        /// <summary>
+        /// The final gameplay candidate.
+        /// </summary>
+        [Key(3)]
+        public long CandidateItem { get; set; }
+
+        /// <summary>
+        /// The users in the room.
+        /// </summary>
+        [Key(4)]
+        public MatchmakingUserList Users { get; set; } = new MatchmakingUserList();
+
+        /// <summary>
+        /// Advances to the next round.
+        /// </summary>
+        public void AdvanceRound()
+        {
+            CurrentRound++;
+        }
+
+        /// <summary>
+        /// Sets scores for the current round, applying points and adjusting user placements.
+        /// </summary>
+        /// <remarks>
+        /// When applying points:
+        /// <list type="bullet">
+        ///   <item>Matching scores are considered to be placed in the lower-equal (e.g. two equal top scores are considered "equal-second").</item>
+        ///   <item>Failed scores are considered to have passed the map.</item>
+        ///   <item>Missing scores are not considered.</item>
+        /// </list>
+        /// </remarks>
+        /// <param name="scores">The scores to apply.</param>
+        /// <param name="placementPoints">The number of points to award for each placement position (0-indexed). Must be at least of equal length to <paramref name="scores"/>.</param>
+        public void RecordScores(SoloScoreInfo[] scores, int[] placementPoints)
+        {
+            if (placementPoints.Length < scores.Length)
+                throw new ArgumentException($"{nameof(placementPoints)} must be at least of equal length to {nameof(scores)}.");
+
+            SoloScoreInfo[] orderedScores = scores.OrderByDescending(s => s.TotalScore).ToArray();
+
+            int placement = 0;
+
+            foreach (var scoreGroup in orderedScores.GroupBy(s => s.TotalScore))
+            {
+                placement += scoreGroup.Count();
+
+                foreach (var score in scoreGroup)
+                {
+                    MatchmakingUser mmUser = Users[score.UserID];
+                    mmUser.Points += placementPoints[placement - 1];
+
+                    MatchmakingRound mmRound = mmUser.Rounds[CurrentRound];
+                    mmRound.Placement = placement;
+                    mmRound.TotalScore = score.TotalScore;
+                    mmRound.Accuracy = score.Accuracy;
+                    mmRound.MaxCombo = score.MaxCombo;
+                    mmRound.Statistics = score.Statistics;
+                }
+            }
+
+            int i = 1;
+            foreach (var user in Users.Order(new MatchmakingUserComparer(CurrentRound)))
+                user.Placement = i++;
+        }
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRound.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRound.cs
new file mode 100644
index 0000000000..6a9d595ab5
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRound.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 System;
+using System.Collections.Generic;
+using MessagePack;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes a user's score for a round of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingRound
+    {
+        /// <summary>
+        /// The round.
+        /// </summary>
+        [Key(0)]
+        public required int Round { get; set; }
+
+        /// <summary>
+        /// The user's placement in this round (1-based).
+        /// </summary>
+        [Key(1)]
+        public int Placement { get; set; }
+
+        /// <summary>
+        /// The achieved total score.
+        /// </summary>
+        [Key(2)]
+        public long TotalScore { get; set; }
+
+        /// <summary>
+        /// The achieved accuracy.
+        /// </summary>
+        [Key(3)]
+        public double Accuracy { get; set; }
+
+        /// <summary>
+        /// The achieved maximum combo.
+        /// </summary>
+        [Key(4)]
+        public int MaxCombo { get; set; }
+
+        /// <summary>
+        /// The achieved score statistics.
+        /// </summary>
+        [Key(5)]
+        public IDictionary<HitResult, int> Statistics { get; set; } = new Dictionary<HitResult, int>();
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoundList.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoundList.cs
new file mode 100644
index 0000000000..c34d1771f8
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingRoundList.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 System;
+using System.Collections;
+using System.Collections.Generic;
+using MessagePack;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes the per-round scores of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingRoundList : IEnumerable<MatchmakingRound>
+    {
+        /// <summary>
+        /// A key-value-pair mapping of rounds to scores.
+        /// </summary>
+        [Key(0)]
+        public IDictionary<int, MatchmakingRound> RoundsDictionary { get; set; } = new Dictionary<int, MatchmakingRound>();
+
+        /// <summary>
+        /// Creates or retrieves the score for the given round.
+        /// </summary>
+        /// <param name="round">The round.</param>
+        public MatchmakingRound this[int round]
+        {
+            get
+            {
+                if (RoundsDictionary.TryGetValue(round, out MatchmakingRound? score))
+                    return score;
+
+                return RoundsDictionary[round] = new MatchmakingRound { Round = round };
+            }
+        }
+
+        /// <summary>
+        /// The total number of rounds.
+        /// </summary>
+        [IgnoreMember]
+        public int Count => RoundsDictionary.Count;
+
+        public IEnumerator<MatchmakingRound> GetEnumerator() => RoundsDictionary.Values.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingStage.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingStage.cs
new file mode 100644
index 0000000000..edffa4ec23
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingStage.cs
@@ -0,0 +1,59 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes the current status of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    public enum MatchmakingStage
+    {
+        /// <summary>
+        /// The initial state of a room. Users are still joining.
+        /// </summary>
+        WaitingForClientsJoin,
+
+        /// <summary>
+        /// A short delay before the round begins.
+        /// </summary>
+        RoundWarmupTime,
+
+        /// <summary>
+        /// Users are given a chance to lock in their beatmap picks.
+        /// </summary>
+        UserBeatmapSelect,
+
+        /// <summary>
+        /// Clients have sent their picks, and the server has responded with the finalised beatmap.
+        /// </summary>
+        ServerBeatmapFinalised,
+
+        /// <summary>
+        /// Clients are given an opportunity to download the beatmap.
+        /// </summary>
+        WaitingForClientsBeatmapDownload,
+
+        /// <summary>
+        /// A short delay before gameplay starts.
+        /// </summary>
+        GameplayWarmupTime,
+
+        /// <summary>
+        /// Gameplay is ongoing.
+        /// </summary>
+        Gameplay,
+
+        /// <summary>
+        /// Gameplay has finished, results are being displayed.
+        /// </summary>
+        ResultsDisplaying,
+
+        /// <summary>
+        /// All rounds have completed. Users may still be chatting.
+        /// </summary>
+        Ended
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUser.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUser.cs
new file mode 100644
index 0000000000..f596f2473e
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUser.cs
@@ -0,0 +1,40 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using MessagePack;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes a user of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingUser
+    {
+        /// <summary>
+        /// The user's ID.
+        /// </summary>
+        [Key(0)]
+        public required int UserId { get; set; }
+
+        /// <summary>
+        /// The aggregate room placement (1-based).
+        /// </summary>
+        [Key(1)]
+        public int Placement { get; set; }
+
+        /// <summary>
+        /// The aggregate points.
+        /// </summary>
+        [Key(2)]
+        public int Points { get; set; }
+
+        /// <summary>
+        /// The scores set.
+        /// </summary>
+        [Key(3)]
+        public MatchmakingRoundList Rounds { get; set; } = new MatchmakingRoundList();
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserComparer.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserComparer.cs
new file mode 100644
index 0000000000..74da6a9b2a
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserComparer.cs
@@ -0,0 +1,65 @@
+// 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;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Orders <see cref="MatchmakingUser"/> in order of placement.
+    /// </summary>
+    public class MatchmakingUserComparer : Comparer<MatchmakingUser>
+    {
+        private readonly int rounds;
+
+        public MatchmakingUserComparer(int rounds)
+        {
+            this.rounds = rounds;
+        }
+
+        public override int Compare(MatchmakingUser? x, MatchmakingUser? y)
+        {
+            ArgumentNullException.ThrowIfNull(x);
+            ArgumentNullException.ThrowIfNull(y);
+
+            // X appears earlier in the list if it has more points.
+            if (x.Points > y.Points)
+                return -1;
+
+            // Y appears earlier in the list if it has more points.
+            if (y.Points > x.Points)
+                return 1;
+
+            // Tiebreaker 1 (likely): From each user's point-of-view, their earliest and best placement.
+            for (int r = 1; r <= rounds; r++)
+            {
+                MatchmakingRound? xRound;
+                x.Rounds.RoundsDictionary.TryGetValue(r, out xRound);
+
+                MatchmakingRound? yRound;
+                y.Rounds.RoundsDictionary.TryGetValue(r, out yRound);
+
+                // Nothing to do if both players haven't played this round.
+                if (xRound == null && yRound == null)
+                    continue;
+
+                // X appears later in the list if it hasn't played this round.
+                if (xRound == null)
+                    return 1;
+
+                // Y appears later in the list if it hasn't played this round.
+                if (yRound == null)
+                    return -1;
+
+                // X appears earlier in the list if it has a better placement in the round.
+                int compare = xRound.Placement.CompareTo(yRound.Placement);
+                if (compare != 0)
+                    return compare;
+            }
+
+            // Tiebreaker 2 (unlikely): User ID.
+            return x.UserId.CompareTo(y.UserId);
+        }
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserList.cs b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserList.cs
new file mode 100644
index 0000000000..600134de4e
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchTypes/Matchmaking/MatchmakingUserList.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 System;
+using System.Collections;
+using System.Collections.Generic;
+using MessagePack;
+
+namespace osu.Game.Online.Multiplayer.MatchTypes.Matchmaking
+{
+    /// <summary>
+    /// Describes the users of a matchmaking room.
+    /// </summary>
+    [Serializable]
+    [MessagePackObject]
+    public class MatchmakingUserList : IEnumerable<MatchmakingUser>
+    {
+        /// <summary>
+        /// A key-value-pair mapping of ids to users.
+        /// </summary>
+        [Key(0)]
+        public IDictionary<int, MatchmakingUser> UserDictionary { get; set; } = new Dictionary<int, MatchmakingUser>();
+
+        /// <summary>
+        /// Creates or retrieves the user for the given id.
+        /// </summary>
+        /// <param name="userId">The user id.</param>
+        public MatchmakingUser this[int userId]
+        {
+            get
+            {
+                if (UserDictionary.TryGetValue(userId, out MatchmakingUser? user))
+                    return user;
+
+                return UserDictionary[userId] = new MatchmakingUser { UserId = userId };
+            }
+        }
+
+        /// <summary>
+        /// The total number of users.
+        /// </summary>
+        [IgnoreMember]
+        public int Count => UserDictionary.Count;
+
+        public IEnumerator<MatchmakingUser> GetEnumerator() => UserDictionary.Values.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchUserRequest.cs b/osu.Game/Online/Multiplayer/MatchUserRequest.cs
index 8515256581..02704ea161 100644
--- a/osu.Game/Online/Multiplayer/MatchUserRequest.cs
+++ b/osu.Game/Online/Multiplayer/MatchUserRequest.cs
@@ -3,6 +3,7 @@
 
 using System;
 using MessagePack;
+using osu.Game.Online.Matchmaking.Events;
 using osu.Game.Online.Multiplayer.Countdown;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 
@@ -17,6 +18,7 @@ namespace osu.Game.Online.Multiplayer
     [Union(0, typeof(ChangeTeamRequest))]
     [Union(1, typeof(StartMatchCountdownRequest))]
     [Union(2, typeof(StopCountdownRequest))]
+    [Union(3, typeof(MatchmakingAvatarActionRequest))]
     public abstract class MatchUserRequest
     {
     }
diff --git a/osu.Game/Online/Multiplayer/MultiplayerClient.cs b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
index 986bc26716..a58d433e7d 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerClient.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
@@ -17,6 +17,7 @@ using osu.Game.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Matchmaking;
 using osu.Game.Online.Multiplayer.Countdown;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays.Notifications;
@@ -26,7 +27,7 @@ using osu.Game.Utils;
 
 namespace osu.Game.Online.Multiplayer
 {
-    public abstract partial class MultiplayerClient : Component, IMultiplayerClient, IMultiplayerRoomServer
+    public abstract partial class MultiplayerClient : Component, IMultiplayerClient, IMultiplayerRoomServer, IMatchmakingServer, IMatchmakingClient
     {
         public Action<Notification>? PostNotification { protected get; set; }
 
@@ -112,6 +113,24 @@ namespace osu.Game.Online.Multiplayer
         /// </summary>
         public event Action? Disconnecting;
 
+        public event Action<MultiplayerCountdown>? CountdownStarted;
+
+        public event Action<MultiplayerCountdown>? CountdownStopped;
+
+        public event Action<MatchServerEvent>? MatchEvent;
+
+        public event Action<MultiplayerRoomUser, MultiplayerUserState>? UserStateChanged;
+
+        public event Action? MatchmakingQueueJoined;
+        public event Action? MatchmakingQueueLeft;
+        public event Action? MatchmakingRoomInvited;
+        public event Action<long, string>? MatchmakingRoomReady;
+        public event Action<MatchmakingLobbyStatus>? MatchmakingLobbyStatusChanged;
+        public event Action<MatchmakingQueueStatus>? MatchmakingQueueStatusChanged;
+        public event Action<int, long>? MatchmakingItemSelected;
+        public event Action<int, long>? MatchmakingItemDeselected;
+        public event Action<MatchRoomState>? MatchRoomStateChanged;
+
         /// <summary>
         /// Whether the <see cref="MultiplayerClient"/> is currently connected.
         /// This is NOT thread safe and usage should be scheduled.
@@ -172,14 +191,20 @@ namespace osu.Game.Online.Multiplayer
 
         protected Room? APIRoom { get; private set; }
 
+        private readonly Queue<Action> pendingRequests = new Queue<Action>();
+
         [BackgroundDependencyLoader]
         private void load()
         {
             IsConnected.BindValueChanged(connected => Scheduler.Add(() =>
             {
-                // clean up local room state on server disconnect.
-                if (!connected.NewValue && Room != null)
-                    LeaveRoom();
+                if (!connected.NewValue)
+                {
+                    if (Room != null)
+                        LeaveRoom();
+
+                    MatchmakingQueueLeft?.Invoke();
+                }
             }));
         }
 
@@ -200,6 +225,7 @@ namespace osu.Game.Online.Multiplayer
 
             await joinOrLeaveTaskChain.Add(async () =>
             {
+                await runOnUpdateThreadAsync(() => pendingRequests.Clear(), cancellationSource.Token).ConfigureAwait(false);
                 var multiplayerRoom = await CreateRoomInternal(new MultiplayerRoom(room)).ConfigureAwait(false);
                 await setupJoinedRoom(room, multiplayerRoom, cancellationSource.Token).ConfigureAwait(false);
             }, cancellationSource.Token).ConfigureAwait(false);
@@ -223,6 +249,7 @@ namespace osu.Game.Online.Multiplayer
 
             await joinOrLeaveTaskChain.Add(async () =>
             {
+                await runOnUpdateThreadAsync(() => pendingRequests.Clear(), cancellationSource.Token).ConfigureAwait(false);
                 var multiplayerRoom = await JoinRoomInternal(room.RoomID.Value, password ?? room.Password).ConfigureAwait(false);
                 await setupJoinedRoom(room, multiplayerRoom, cancellationSource.Token).ConfigureAwait(false);
             }, cancellationSource.Token).ConfigureAwait(false);
@@ -250,6 +277,9 @@ namespace osu.Game.Online.Multiplayer
                 Room = joinedRoom;
                 APIRoom = apiRoom;
 
+                while (pendingRequests.TryDequeue(out Action? action))
+                    action();
+
                 APIRoom.RoomID = joinedRoom.RoomID;
                 APIRoom.ChannelId = joinedRoom.ChannelID;
                 APIRoom.Host = joinedRoom.Host?.User;
@@ -266,6 +296,9 @@ namespace osu.Game.Online.Multiplayer
 
                 updateLocalRoomSettings(joinedRoom.Settings);
 
+                while (pendingRequests.TryDequeue(out Action? action))
+                    action();
+
                 postServerShuttingDownNotification();
 
                 OnRoomJoined();
@@ -300,10 +333,23 @@ namespace osu.Game.Online.Multiplayer
                 RoomUpdated?.Invoke();
             });
 
-            return joinOrLeaveTaskChain.Add(async () =>
+            return Task.Run(async () =>
             {
-                await scheduledReset.ConfigureAwait(false);
-                await LeaveRoomInternal().ConfigureAwait(false);
+                try
+                {
+                    await joinOrLeaveTaskChain.Add(async () =>
+                    {
+                        await scheduledReset.ConfigureAwait(false);
+                        await LeaveRoomInternal().ConfigureAwait(false);
+                    }).ConfigureAwait(false);
+                }
+                finally
+                {
+                    await runOnUpdateThreadAsync(() =>
+                    {
+                        pendingRequests.Clear();
+                    }).ConfigureAwait(false);
+                }
             });
         }
 
@@ -449,11 +495,9 @@ namespace osu.Game.Online.Multiplayer
 
         Task IMultiplayerClient.RoomStateChanged(MultiplayerRoomState state)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 Room.State = state;
@@ -476,7 +520,7 @@ namespace osu.Game.Online.Multiplayer
                 }
 
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
@@ -485,10 +529,9 @@ namespace osu.Game.Online.Multiplayer
         {
             await PopulateUsers([user]).ConfigureAwait(false);
 
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
+                Debug.Assert(Room != null);
 
                 // for sanity, ensure that there can be no duplicate users in the room user list.
                 if (Room.Users.Any(existing => existing.UserID == user.UserID))
@@ -500,18 +543,18 @@ namespace osu.Game.Online.Multiplayer
 
                 UserJoined?.Invoke(user);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
         }
 
         Task IMultiplayerClient.UserLeft(MultiplayerRoomUser user)
         {
-            Scheduler.Add(() => handleUserLeft(user, UserLeft), false);
+            handleRoomRequest(() => handleUserLeft(user, UserLeft));
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.UserKicked(MultiplayerRoomUser user)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
                 if (LocalUser == null)
                     return;
@@ -520,7 +563,7 @@ namespace osu.Game.Online.Multiplayer
                     LeaveRoom();
 
                 handleUserLeft(user, UserKicked);
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
@@ -528,9 +571,7 @@ namespace osu.Game.Online.Multiplayer
         private void handleUserLeft(MultiplayerRoomUser user, Action<MultiplayerRoomUser>? callback)
         {
             Debug.Assert(ThreadSafety.IsUpdateThread);
-
-            if (Room == null)
-                return;
+            Debug.Assert(Room != null);
 
             Room.Users.Remove(user);
             PlayingUserIds.Remove(user.UserID);
@@ -587,11 +628,9 @@ namespace osu.Game.Online.Multiplayer
 
         Task IMultiplayerClient.HostChanged(int userId)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 var user = Room.Users.FirstOrDefault(u => u.UserID == userId);
@@ -601,22 +640,24 @@ namespace osu.Game.Online.Multiplayer
 
                 HostChanged?.Invoke(user);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.SettingsChanged(MultiplayerRoomSettings newSettings)
         {
-            Scheduler.Add(() => updateLocalRoomSettings(newSettings));
+            handleRoomRequest(() => updateLocalRoomSettings(newSettings));
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.UserStateChanged(int userId, MultiplayerUserState state)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // TODO: user should NEVER be null here, see https://github.com/ppy/osu/issues/17713.
                 if (user == null)
@@ -625,17 +666,20 @@ namespace osu.Game.Online.Multiplayer
                 user.State = state;
                 updateUserPlayingState(userId, state);
 
+                UserStateChanged?.Invoke(user, state);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.MatchUserStateChanged(int userId, MatchUserState state)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // TODO: user should NEVER be null here, see https://github.com/ppy/osu/issues/17713.
                 if (user == null)
@@ -643,36 +687,36 @@ namespace osu.Game.Online.Multiplayer
 
                 user.MatchState = state;
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.MatchRoomStateChanged(MatchRoomState state)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
+                Debug.Assert(Room != null);
 
                 Room.MatchState = state;
+                MatchRoomStateChanged?.Invoke(state);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
-        public Task MatchEvent(MatchServerEvent e)
+        Task IMultiplayerClient.MatchEvent(MatchServerEvent e)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
+                Debug.Assert(Room != null);
 
                 switch (e)
                 {
                     case CountdownStartedEvent countdownStartedEvent:
                         Room.ActiveCountdowns.Add(countdownStartedEvent.Countdown);
+                        CountdownStarted?.Invoke(countdownStartedEvent.Countdown);
 
                         switch (countdownStartedEvent.Countdown)
                         {
@@ -685,13 +729,19 @@ namespace osu.Game.Online.Multiplayer
 
                     case CountdownStoppedEvent countdownStoppedEvent:
                         MultiplayerCountdown? countdown = Room.ActiveCountdowns.FirstOrDefault(countdown => countdown.ID == countdownStoppedEvent.ID);
+
                         if (countdown != null)
+                        {
                             Room.ActiveCountdowns.Remove(countdown);
+                            CountdownStopped?.Invoke(countdown);
+                        }
+
                         break;
                 }
 
+                MatchEvent?.Invoke(e);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
@@ -708,9 +758,11 @@ namespace osu.Game.Online.Multiplayer
 
         Task IMultiplayerClient.UserBeatmapAvailabilityChanged(int userId, BeatmapAvailability beatmapAvailability)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // errors here are not critical - beatmap availability state is mostly for display.
                 if (user == null)
@@ -719,16 +771,18 @@ namespace osu.Game.Online.Multiplayer
                 user.BeatmapAvailability = beatmapAvailability;
 
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.UserStyleChanged(int userId, int? beatmapId, int? rulesetId)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // errors here are not critical - user style is mostly for display.
                 if (user == null)
@@ -739,16 +793,18 @@ namespace osu.Game.Online.Multiplayer
 
                 UserStyleChanged?.Invoke(user);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.UserModsChanged(int userId, IEnumerable<APIMod> mods)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                var user = Room?.Users.SingleOrDefault(u => u.UserID == userId);
+                Debug.Assert(Room != null);
+
+                var user = Room.Users.SingleOrDefault(u => u.UserID == userId);
 
                 // errors here are not critical - user mods are mostly for display.
                 if (user == null)
@@ -758,70 +814,60 @@ namespace osu.Game.Online.Multiplayer
 
                 UserModsChanged?.Invoke(user);
                 RoomUpdated?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.LoadRequested()
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 LoadRequested?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.GameplayAborted(GameplayAbortReason reason)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 GameplayAborted?.Invoke(reason);
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.GameplayStarted()
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 GameplayStarted?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         Task IMultiplayerClient.ResultsReady()
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 ResultsReady?.Invoke();
-            }, false);
+            });
 
             return Task.CompletedTask;
         }
 
         public Task PlaylistItemAdded(MultiplayerPlaylistItem item)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 Room.Playlist.Add(item);
@@ -836,11 +882,9 @@ namespace osu.Game.Online.Multiplayer
 
         public Task PlaylistItemRemoved(long playlistItemId)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 Room.Playlist.Remove(Room.Playlist.Single(existing => existing.ID == playlistItemId));
@@ -857,11 +901,9 @@ namespace osu.Game.Online.Multiplayer
 
         public Task PlaylistItemChanged(MultiplayerPlaylistItem item)
         {
-            Scheduler.Add(() =>
+            handleRoomRequest(() =>
             {
-                if (Room == null)
-                    return;
-
+                Debug.Assert(Room != null);
                 Debug.Assert(APIRoom != null);
 
                 Room.Playlist[Room.Playlist.IndexOf(Room.Playlist.Single(existing => existing.ID == item.ID))] = item;
@@ -908,9 +950,7 @@ namespace osu.Game.Online.Multiplayer
         /// <param name="settings">The new <see cref="MultiplayerRoomSettings"/> to update from.</param>
         private void updateLocalRoomSettings(MultiplayerRoomSettings settings)
         {
-            if (Room == null)
-                return;
-
+            Debug.Assert(Room != null);
             Debug.Assert(APIRoom != null);
 
             // Update a few properties of the room instantaneously.
@@ -972,6 +1012,20 @@ namespace osu.Game.Online.Multiplayer
             return tcs.Task;
         }
 
+        private void handleRoomRequest(Action request)
+        {
+            Scheduler.Add(() =>
+            {
+                if (Room == null)
+                {
+                    pendingRequests.Enqueue(request);
+                    return;
+                }
+
+                request();
+            });
+        }
+
         Task IStatefulUserHubClient.DisconnectRequested()
         {
             Schedule(() =>
@@ -982,6 +1036,82 @@ namespace osu.Game.Online.Multiplayer
             return Task.CompletedTask;
         }
 
+        Task IMatchmakingClient.MatchmakingQueueJoined()
+        {
+            Scheduler.Add(() => MatchmakingQueueJoined?.Invoke());
+            return Task.CompletedTask;
+        }
+
+        Task IMatchmakingClient.MatchmakingQueueLeft()
+        {
+            Scheduler.Add(() => MatchmakingQueueLeft?.Invoke());
+            return Task.CompletedTask;
+        }
+
+        Task IMatchmakingClient.MatchmakingRoomInvited()
+        {
+            Scheduler.Add(() => MatchmakingRoomInvited?.Invoke());
+            return Task.CompletedTask;
+        }
+
+        Task IMatchmakingClient.MatchmakingRoomReady(long roomId, string password)
+        {
+            Scheduler.Add(() => MatchmakingRoomReady?.Invoke(roomId, password));
+            return Task.CompletedTask;
+        }
+
+        Task IMatchmakingClient.MatchmakingLobbyStatusChanged(MatchmakingLobbyStatus status)
+        {
+            Scheduler.Add(() => MatchmakingLobbyStatusChanged?.Invoke(status));
+            return Task.CompletedTask;
+        }
+
+        Task IMatchmakingClient.MatchmakingQueueStatusChanged(MatchmakingQueueStatus status)
+        {
+            Scheduler.Add(() => MatchmakingQueueStatusChanged?.Invoke(status));
+            return Task.CompletedTask;
+        }
+
+        Task IMatchmakingClient.MatchmakingItemSelected(int userId, long playlistItemId)
+        {
+            Scheduler.Add(() =>
+            {
+                MatchmakingItemSelected?.Invoke(userId, playlistItemId);
+                RoomUpdated?.Invoke();
+            });
+
+            return Task.CompletedTask;
+        }
+
+        Task IMatchmakingClient.MatchmakingItemDeselected(int userId, long playlistItemId)
+        {
+            Scheduler.Add(() =>
+            {
+                MatchmakingItemDeselected?.Invoke(userId, playlistItemId);
+                RoomUpdated?.Invoke();
+            });
+
+            return Task.CompletedTask;
+        }
+
+        public abstract Task<MatchmakingPool[]> GetMatchmakingPools();
+
+        public abstract Task MatchmakingJoinLobby();
+
+        public abstract Task MatchmakingLeaveLobby();
+
+        public abstract Task MatchmakingJoinQueue(int poolId);
+
+        public abstract Task MatchmakingLeaveQueue();
+
+        public abstract Task MatchmakingAcceptInvitation();
+
+        public abstract Task MatchmakingDeclineInvitation();
+
+        public abstract Task MatchmakingToggleSelection(long playlistItemId);
+
+        public abstract Task MatchmakingSkipToNextStage();
+
         private partial class MultiplayerInvitationNotification : UserAvatarNotification
         {
             protected override IconUsage CloseButtonIcon => FontAwesome.Solid.Times;
diff --git a/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs b/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs
index c59f5937b0..bc2536848b 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs
@@ -3,6 +3,7 @@
 
 using System;
 using MessagePack;
+using osu.Game.Online.Matchmaking;
 using osu.Game.Online.Multiplayer.Countdown;
 
 namespace osu.Game.Online.Multiplayer
@@ -14,6 +15,7 @@ namespace osu.Game.Online.Multiplayer
     [Union(0, typeof(MatchStartCountdown))] // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
     [Union(1, typeof(ForceGameplayStartCountdown))]
     [Union(2, typeof(ServerShuttingDownCountdown))]
+    [Union(3, typeof(MatchmakingStageCountdown))]
     public abstract class MultiplayerCountdown
     {
         /// <summary>
diff --git a/osu.Game/Online/Multiplayer/OnlineMultiplayerClient.cs b/osu.Game/Online/Multiplayer/OnlineMultiplayerClient.cs
index 02e9cd4ee8..0decff7ab3 100644
--- a/osu.Game/Online/Multiplayer/OnlineMultiplayerClient.cs
+++ b/osu.Game/Online/Multiplayer/OnlineMultiplayerClient.cs
@@ -14,6 +14,7 @@ using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Localisation;
+using osu.Game.Online.Matchmaking;
 
 namespace osu.Game.Online.Multiplayer
 {
@@ -70,6 +71,15 @@ namespace osu.Game.Online.Multiplayer
                     connection.On<long>(nameof(IMultiplayerClient.PlaylistItemRemoved), ((IMultiplayerClient)this).PlaylistItemRemoved);
                     connection.On<MultiplayerPlaylistItem>(nameof(IMultiplayerClient.PlaylistItemChanged), ((IMultiplayerClient)this).PlaylistItemChanged);
                     connection.On(nameof(IStatefulUserHubClient.DisconnectRequested), ((IMultiplayerClient)this).DisconnectRequested);
+
+                    connection.On(nameof(IMatchmakingClient.MatchmakingQueueJoined), ((IMatchmakingClient)this).MatchmakingQueueJoined);
+                    connection.On(nameof(IMatchmakingClient.MatchmakingQueueLeft), ((IMatchmakingClient)this).MatchmakingQueueLeft);
+                    connection.On(nameof(IMatchmakingClient.MatchmakingRoomInvited), ((IMatchmakingClient)this).MatchmakingRoomInvited);
+                    connection.On<long, string>(nameof(IMatchmakingClient.MatchmakingRoomReady), ((IMatchmakingClient)this).MatchmakingRoomReady);
+                    connection.On<MatchmakingLobbyStatus>(nameof(IMatchmakingClient.MatchmakingLobbyStatusChanged), ((IMatchmakingClient)this).MatchmakingLobbyStatusChanged);
+                    connection.On<MatchmakingQueueStatus>(nameof(IMatchmakingClient.MatchmakingQueueStatusChanged), ((IMatchmakingClient)this).MatchmakingQueueStatusChanged);
+                    connection.On<int, long>(nameof(IMatchmakingClient.MatchmakingItemSelected), ((IMatchmakingClient)this).MatchmakingItemSelected);
+                    connection.On<int, long>(nameof(IMatchmakingClient.MatchmakingItemDeselected), ((IMatchmakingClient)this).MatchmakingItemDeselected);
                 };
 
                 IsConnected.BindTo(connector.IsConnected);
@@ -310,6 +320,87 @@ namespace osu.Game.Online.Multiplayer
             return connector.Disconnect();
         }
 
+        public override Task<MatchmakingPool[]> GetMatchmakingPools()
+        {
+            if (!IsConnected.Value)
+                return Task.FromResult(Array.Empty<MatchmakingPool>());
+
+            Debug.Assert(connection != null);
+            return connection.InvokeAsync<MatchmakingPool[]>(nameof(IMatchmakingServer.GetMatchmakingPools));
+        }
+
+        public override Task MatchmakingJoinLobby()
+        {
+            if (!IsConnected.Value)
+                return Task.CompletedTask;
+
+            Debug.Assert(connection != null);
+            return connection.InvokeAsync(nameof(IMatchmakingServer.MatchmakingJoinLobby));
+        }
+
+        public override Task MatchmakingLeaveLobby()
+        {
+            if (!IsConnected.Value)
+                return Task.CompletedTask;
+
+            Debug.Assert(connection != null);
+            return connection.InvokeAsync(nameof(IMatchmakingServer.MatchmakingLeaveLobby));
+        }
+
+        public override Task MatchmakingJoinQueue(int poolId)
+        {
+            if (!IsConnected.Value)
+                return Task.CompletedTask;
+
+            Debug.Assert(connection != null);
+            return connection.InvokeAsync(nameof(IMatchmakingServer.MatchmakingJoinQueue), poolId);
+        }
+
+        public override Task MatchmakingLeaveQueue()
+        {
+            if (!IsConnected.Value)
+                return Task.CompletedTask;
+
+            Debug.Assert(connection != null);
+            return connection.InvokeAsync(nameof(IMatchmakingServer.MatchmakingLeaveQueue));
+        }
+
+        public override Task MatchmakingAcceptInvitation()
+        {
+            if (!IsConnected.Value)
+                return Task.CompletedTask;
+
+            Debug.Assert(connection != null);
+            return connection.InvokeAsync(nameof(IMatchmakingServer.MatchmakingAcceptInvitation));
+        }
+
+        public override Task MatchmakingDeclineInvitation()
+        {
+            if (!IsConnected.Value)
+                return Task.CompletedTask;
+
+            Debug.Assert(connection != null);
+            return connection.InvokeAsync(nameof(IMatchmakingServer.MatchmakingDeclineInvitation));
+        }
+
+        public override Task MatchmakingToggleSelection(long playlistItemId)
+        {
+            if (!IsConnected.Value)
+                return Task.CompletedTask;
+
+            Debug.Assert(connection != null);
+            return connection.InvokeAsync(nameof(IMatchmakingServer.MatchmakingToggleSelection), playlistItemId);
+        }
+
+        public override Task MatchmakingSkipToNextStage()
+        {
+            if (!IsConnected.Value)
+                return Task.CompletedTask;
+
+            Debug.Assert(connection != null);
+            return connection.InvokeAsync(nameof(IMatchmakingServer.MatchmakingSkipToNextStage));
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
diff --git a/osu.Game/Online/Rooms/MatchType.cs b/osu.Game/Online/Rooms/MatchType.cs
index ade28458e8..bbfe25c8fd 100644
--- a/osu.Game/Online/Rooms/MatchType.cs
+++ b/osu.Game/Online/Rooms/MatchType.cs
@@ -17,5 +17,7 @@ namespace osu.Game.Online.Rooms
 
         [LocalisableDescription(typeof(MatchesStrings), nameof(MatchesStrings.MatchTeamTypesTeamVersus))]
         TeamVersus,
+
+        Matchmaking
     }
 }
diff --git a/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs b/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
index d8ed20a3a8..3386b8654d 100644
--- a/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
+++ b/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using MessagePack;
 using osu.Game.Online.API;
@@ -13,7 +14,7 @@ namespace osu.Game.Online.Rooms
 {
     [Serializable]
     [MessagePackObject]
-    public class MultiplayerPlaylistItem
+    public class MultiplayerPlaylistItem : IEquatable<MultiplayerPlaylistItem>
     {
         [Key(0)]
         public long ID { get; set; }
@@ -118,5 +119,42 @@ namespace osu.Game.Online.Rooms
             clone.AllowedMods = AllowedMods.ToArray();
             return clone;
         }
+
+        public bool Equals(MultiplayerPlaylistItem? other)
+            => other != null
+               && ID == other.ID
+               && OwnerID == other.OwnerID
+               && BeatmapID == other.BeatmapID
+               && BeatmapChecksum == other.BeatmapChecksum
+               && RulesetID == other.RulesetID
+               && RequiredMods.SequenceEqual(other.RequiredMods)
+               && AllowedMods.SequenceEqual(other.AllowedMods)
+               && Expired == other.Expired
+               && PlaylistOrder == other.PlaylistOrder
+               && PlayedAt == other.PlayedAt
+               && StarRating == other.StarRating
+               && Freestyle == other.Freestyle;
+
+        public override bool Equals(object? obj)
+            => obj is MultiplayerPlaylistItem other && Equals(other);
+
+        [SuppressMessage("ReSharper", "NonReadonlyMemberInGetHashCode")]
+        public override int GetHashCode()
+        {
+            var hashCode = new HashCode();
+            hashCode.Add(ID);
+            hashCode.Add(OwnerID);
+            hashCode.Add(BeatmapID);
+            hashCode.Add(BeatmapChecksum);
+            hashCode.Add(RulesetID);
+            hashCode.Add(RequiredMods);
+            hashCode.Add(AllowedMods);
+            hashCode.Add(Expired);
+            hashCode.Add(PlaylistOrder);
+            hashCode.Add(PlayedAt);
+            hashCode.Add(StarRating);
+            hashCode.Add(Freestyle);
+            return hashCode.ToHashCode();
+        }
     }
 }
diff --git a/osu.Game/Online/Rooms/Room.cs b/osu.Game/Online/Rooms/Room.cs
index e965f9c187..dda069bba0 100644
--- a/osu.Game/Online/Rooms/Room.cs
+++ b/osu.Game/Online/Rooms/Room.cs
@@ -263,6 +263,12 @@ namespace osu.Game.Online.Rooms
             set => SetField(ref availability, value);
         }
 
+        public bool Pinned
+        {
+            get => pinned;
+            set => SetField(ref pinned, value);
+        }
+
         [JsonProperty("id")]
         private long? roomId;
 
@@ -339,6 +345,9 @@ namespace osu.Game.Online.Rooms
         [JsonConverter(typeof(SnakeCaseStringEnumConverter))]
         private RoomStatus status;
 
+        [JsonProperty("pinned")]
+        private bool pinned;
+
         // Not yet serialised (not implemented).
         private RoomAvailability availability;
 
@@ -349,6 +358,7 @@ namespace osu.Game.Online.Rooms
         public Room(MultiplayerRoom room)
         {
             RoomID = room.RoomID;
+            ChannelId = room.ChannelID;
             Name = room.Settings.Name;
             Password = room.Settings.Password;
             Type = room.Settings.MatchType;
diff --git a/osu.Game/Online/SignalRWorkaroundTypes.cs b/osu.Game/Online/SignalRWorkaroundTypes.cs
index 6ae178e04c..e509891486 100644
--- a/osu.Game/Online/SignalRWorkaroundTypes.cs
+++ b/osu.Game/Online/SignalRWorkaroundTypes.cs
@@ -3,8 +3,11 @@
 
 using System;
 using System.Collections.Generic;
+using osu.Game.Online.Matchmaking;
+using osu.Game.Online.Matchmaking.Events;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.Countdown;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Users;
 
@@ -45,6 +48,15 @@ namespace osu.Game.Online
             (typeof(UserActivity.TestingBeatmap), typeof(UserActivity)),
             (typeof(UserActivity.InDailyChallengeLobby), typeof(UserActivity)),
             (typeof(UserActivity.PlayingDailyChallenge), typeof(UserActivity)),
+
+            // matchmaking
+            (typeof(MatchmakingQueueStatus.Searching), typeof(MatchmakingQueueStatus)),
+            (typeof(MatchmakingQueueStatus.MatchFound), typeof(MatchmakingQueueStatus)),
+            (typeof(MatchmakingQueueStatus.JoiningMatch), typeof(MatchmakingQueueStatus)),
+            (typeof(MatchmakingRoomState), typeof(MatchRoomState)),
+            (typeof(MatchmakingStageCountdown), typeof(MultiplayerCountdown)),
+            (typeof(MatchmakingAvatarActionRequest), typeof(MatchUserRequest)),
+            (typeof(MatchmakingAvatarActionEvent), typeof(MatchServerEvent)),
         };
     }
 }
diff --git a/osu.Game/OsuGame.cs b/osu.Game/OsuGame.cs
index bf08023242..4dd42b7fd2 100644
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@@ -65,6 +65,7 @@ using osu.Game.Screens.Edit;
 using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.OnlinePlay.DailyChallenge;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Queue;
 using osu.Game.Screens.OnlinePlay.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Playlists;
 using osu.Game.Screens.Play;
@@ -79,6 +80,7 @@ using osu.Game.Utils;
 using osuTK;
 using osuTK.Graphics;
 using Sentry;
+using IntroScreen = osu.Game.Screens.Menu.IntroScreen;
 using MatchType = osu.Game.Online.Rooms.MatchType;
 
 namespace osu.Game
@@ -1270,6 +1272,7 @@ namespace osu.Game
 
             loadComponentSingleFile(new BackgroundDataStoreProcessor(), Add);
             loadComponentSingleFile<BeatmapStore>(detachedBeatmapStore = new RealmDetachedBeatmapStore(), Add, true);
+            loadComponentSingleFile(new QueueController(), Add, true);
 
             Add(externalLinkOpener = new ExternalLinkOpener());
             Add(new MusicKeyBindingHandler());
diff --git a/osu.Game/OsuGameBase_Importing.cs b/osu.Game/OsuGameBase.Importing.cs
similarity index 100%
rename from osu.Game/OsuGameBase_Importing.cs
rename to osu.Game/OsuGameBase.Importing.cs
diff --git a/osu.Game/OsuGameBase.cs b/osu.Game/OsuGameBase.cs
index df1eac4461..222427cb60 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -467,8 +467,6 @@ namespace osu.Game
 
         protected virtual void InitialiseFonts()
         {
-            AddFont(Resources, @"Fonts/osuFont");
-
             AddFont(Resources, @"Fonts/Torus/Torus-Regular");
             AddFont(Resources, @"Fonts/Torus/Torus-Light");
             AddFont(Resources, @"Fonts/Torus/Torus-SemiBold");
diff --git a/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs b/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs
index 59ba9cd449..9f7c5c848d 100644
--- a/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs
+++ b/osu.Game/Overlays/BeatmapSet/Scores/ScoreboardTime.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Localisation;
 using osu.Game.Extensions;
 using osu.Game.Graphics;
 
@@ -14,7 +15,7 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
         {
         }
 
-        protected override string Format()
+        protected override LocalisableString Format()
             => Date.ToShortRelativeTime(TimeSpan.FromHours(1));
     }
 }
diff --git a/osu.Game/Overlays/Login/SecondFactorAuthForm.cs b/osu.Game/Overlays/Login/SecondFactorAuthForm.cs
index 74db58e225..2cdc4bf6a6 100644
--- a/osu.Game/Overlays/Login/SecondFactorAuthForm.cs
+++ b/osu.Game/Overlays/Login/SecondFactorAuthForm.cs
@@ -13,6 +13,7 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.Settings;
 using osu.Game.Resources.Localisation.Web;
 using osuTK;
@@ -21,11 +22,11 @@ namespace osu.Game.Overlays.Login
 {
     public partial class SecondFactorAuthForm : Container
     {
-        private OsuTextBox codeTextBox = null!;
-        private LinkFlowContainer explainText = null!;
         private ErrorTextFlowContainer errorText = null!;
 
         private LoadingLayer loading = null!;
+        private FillFlowContainer contentFlow = null!;
+        private OsuTextBox codeTextBox = null!;
 
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
@@ -36,6 +37,8 @@ namespace osu.Game.Overlays.Login
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
 
+            Padding = new MarginPadding { Horizontal = SettingsPanel.CONTENT_MARGINS };
+
             Children = new Drawable[]
             {
                 new FillFlowContainer
@@ -46,46 +49,18 @@ namespace osu.Game.Overlays.Login
                     Spacing = new Vector2(0, SettingsSection.ITEM_SPACING),
                     Children = new Drawable[]
                     {
-                        new FillFlowContainer
+                        contentFlow = new FillFlowContainer
                         {
                             RelativeSizeAxes = Axes.X,
                             AutoSizeAxes = Axes.Y,
-                            Padding = new MarginPadding { Horizontal = SettingsPanel.CONTENT_MARGINS },
                             Direction = FillDirection.Vertical,
                             Spacing = new Vector2(0f, SettingsSection.ITEM_SPACING),
-                            Children = new Drawable[]
-                            {
-                                new OsuTextFlowContainer(s => s.Font = OsuFont.GetFont(weight: FontWeight.Regular))
-                                {
-                                    RelativeSizeAxes = Axes.X,
-                                    AutoSizeAxes = Axes.Y,
-                                    Text = "An email has been sent to you with a verification code. Enter the code.",
-                                },
-                                codeTextBox = new OsuTextBox
-                                {
-                                    InputProperties = new TextInputProperties(TextInputType.Code),
-                                    PlaceholderText = "Enter code",
-                                    RelativeSizeAxes = Axes.X,
-                                    TabbableContentContainer = this,
-                                },
-                                explainText = new LinkFlowContainer(s => s.Font = OsuFont.GetFont(weight: FontWeight.Regular))
-                                {
-                                    RelativeSizeAxes = Axes.X,
-                                    AutoSizeAxes = Axes.Y,
-                                },
-                                errorText = new ErrorTextFlowContainer
-                                {
-                                    RelativeSizeAxes = Axes.X,
-                                    AutoSizeAxes = Axes.Y,
-                                    Alpha = 0,
-                                },
-                            },
                         },
-                        new LinkFlowContainer
+                        errorText = new ErrorTextFlowContainer
                         {
-                            Padding = new MarginPadding { Horizontal = SettingsPanel.CONTENT_MARGINS },
                             RelativeSizeAxes = Axes.X,
                             AutoSizeAxes = Axes.Y,
+                            Alpha = 0,
                         },
                     }
                 },
@@ -95,6 +70,56 @@ namespace osu.Game.Overlays.Login
                 }
             };
 
+            if (api.LastLoginError?.Message is string error)
+            {
+                errorText.Alpha = 1;
+                errorText.AddErrors(new[] { error });
+            }
+
+            showContent(api.SessionVerificationMethod!.Value);
+        }
+
+        private void showContent(SessionVerificationMethod sessionVerificationMethod)
+        {
+            switch (sessionVerificationMethod)
+            {
+                case SessionVerificationMethod.EmailMessage:
+                    showEmailVerification();
+                    break;
+
+                case SessionVerificationMethod.TimedOneTimePassword:
+                    showTotpVerification();
+                    break;
+            }
+        }
+
+        private void showEmailVerification()
+        {
+            LinkFlowContainer explainText;
+
+            contentFlow.Clear();
+            contentFlow.AddRange(new Drawable[]
+            {
+                new OsuTextFlowContainer(s => s.Font = OsuFont.GetFont(weight: FontWeight.Regular))
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Text = "An email has been sent to you with a verification code. Enter the code.",
+                },
+                codeTextBox = new OsuTextBox
+                {
+                    InputProperties = new TextInputProperties(TextInputType.Code),
+                    PlaceholderText = "Enter code",
+                    RelativeSizeAxes = Axes.X,
+                    TabbableContentContainer = this,
+                },
+                explainText = new LinkFlowContainer(s => s.Font = OsuFont.GetFont(weight: FontWeight.Regular))
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                },
+            });
+
             explainText.AddParagraph(UserVerificationStrings.BoxInfoCheckSpam);
             // We can't support localisable strings with nested links yet. Not sure if we even can (probably need to allow markdown link formatting or something).
             explainText.AddParagraph("If you can't access your email or have forgotten what you used, please follow the ");
@@ -131,12 +156,58 @@ namespace osu.Game.Overlays.Login
                     codeTextBox.Current.Disabled = true;
                 }
             });
+        }
 
-            if (api.LastLoginError?.Message is string error)
+        private void showTotpVerification()
+        {
+            LinkFlowContainer explainText;
+
+            contentFlow.Clear();
+            contentFlow.AddRange(new Drawable[]
             {
-                errorText.Alpha = 1;
-                errorText.AddErrors(new[] { error });
-            }
+                new OsuTextFlowContainer(s => s.Font = OsuFont.GetFont(weight: FontWeight.Regular))
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Text = "Please enter the code from your authenticator app.",
+                },
+                codeTextBox = new OsuNumberBox
+                {
+                    InputProperties = new TextInputProperties(TextInputType.NumericalPassword),
+                    PlaceholderText = "Enter code",
+                    RelativeSizeAxes = Axes.X,
+                    TabbableContentContainer = this,
+                },
+                explainText = new LinkFlowContainer(s => s.Font = OsuFont.GetFont(weight: FontWeight.Regular))
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                },
+            });
+
+            // We can't support localisable strings with nested links yet. Not sure if we even can (probably need to allow markdown link formatting or something).
+            explainText.AddParagraph("If you can't access your app, ");
+            explainText.AddLink("you can verify using email instead", () =>
+            {
+                var fallbackRequest = new VerificationMailFallbackRequest();
+                fallbackRequest.Success += showEmailVerification;
+                fallbackRequest.Failure += ex => errorText.Text = ex.Message;
+                Task.Run(() => api.Perform(fallbackRequest));
+            });
+            explainText.AddText(". You can also ");
+            explainText.AddLink(UserVerificationStrings.BoxInfoLogoutLink, () => { api.Logout(); });
+            explainText.AddText(".");
+
+            codeTextBox.Current.BindValueChanged(code =>
+            {
+                string trimmedCode = code.NewValue.Trim();
+
+                if (trimmedCode.Length == 6)
+                {
+                    api.AuthenticateSecondFactor(trimmedCode);
+                    codeTextBox.Current.Disabled = true;
+                }
+            });
         }
 
         public override bool AcceptsFocus => true;
diff --git a/osu.Game/Overlays/NotificationOverlay.cs b/osu.Game/Overlays/NotificationOverlay.cs
index 18a487a312..f56e5e6ac3 100644
--- a/osu.Game/Overlays/NotificationOverlay.cs
+++ b/osu.Game/Overlays/NotificationOverlay.cs
@@ -180,7 +180,7 @@ namespace osu.Game.Overlays
             notification.Closed += () => notificationClosed(notification);
 
             if (notification is IHasCompletionTarget hasCompletionTarget)
-                hasCompletionTarget.CompletionTarget = Post;
+                hasCompletionTarget.CompletionTarget ??= Post;
 
             playDebouncedSample(notification.PopInSampleName);
 
diff --git a/osu.Game/Overlays/Profile/Header/Components/DrawableBadge.cs b/osu.Game/Overlays/Profile/Header/Components/DrawableBadge.cs
index 5f100bc882..7e4c747ce8 100644
--- a/osu.Game/Overlays/Profile/Header/Components/DrawableBadge.cs
+++ b/osu.Game/Overlays/Profile/Header/Components/DrawableBadge.cs
@@ -31,6 +31,8 @@ namespace osu.Game.Overlays.Profile.Header.Components
         {
             Child = new Sprite
             {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
                 FillMode = FillMode.Fit,
                 RelativeSizeAxes = Axes.Both,
                 Texture = textures.Get(badge.ImageUrl),
diff --git a/osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow_ConflictResolution.cs b/osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.ConflictResolution.cs
similarity index 100%
rename from osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow_ConflictResolution.cs
rename to osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.ConflictResolution.cs
diff --git a/osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow_KeyButton.cs b/osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.KeyButton.cs
similarity index 100%
rename from osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow_KeyButton.cs
rename to osu.Game/Overlays/Settings/Sections/Input/KeyBindingRow.KeyButton.cs
diff --git a/osu.Game/Overlays/Settings/Sections/SkinSection.cs b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
index 764f5fdfb6..2c24a5b277 100644
--- a/osu.Game/Overlays/Settings/Sections/SkinSection.cs
+++ b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
@@ -130,6 +130,7 @@ namespace osu.Game.Overlays.Settings.Sections
             dropdownItems.Add(sender.Single(s => s.ID == SkinInfo.ARGON_PRO_SKIN).ToLive(realm));
             dropdownItems.Add(sender.Single(s => s.ID == SkinInfo.TRIANGLES_SKIN).ToLive(realm));
             dropdownItems.Add(sender.Single(s => s.ID == SkinInfo.CLASSIC_SKIN).ToLive(realm));
+            dropdownItems.Add(sender.Single(s => s.ID == SkinInfo.RETRO_SKIN).ToLive(realm));
 
             dropdownItems.Add(random_skin_info);
 
diff --git a/osu.Game/Overlays/SkinEditor/SkinEditor.cs b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
index f4a1bb7562..823456dddd 100644
--- a/osu.Game/Overlays/SkinEditor/SkinEditor.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinEditor.cs
@@ -391,10 +391,10 @@ namespace osu.Game.Overlays.SkinEditor
                 return;
             }
 
-            if (skinComponentsContainer.IsLoaded)
+            if (skinComponentsContainer.ComponentsLoaded)
                 bindChangeHandler(skinComponentsContainer);
             else
-                skinComponentsContainer.OnLoadComplete += d => Schedule(() => bindChangeHandler((SkinnableContainer)d));
+                skinComponentsContainer.OnComponentsLoaded += onComponentsLoaded;
 
             content.Child = new SkinBlueprintContainer(skinComponentsContainer);
 
@@ -428,6 +428,13 @@ namespace osu.Game.Overlays.SkinEditor
                 RequestPlacement = requestPlacement
             });
 
+            void onComponentsLoaded(Drawable d)
+            {
+                SkinnableContainer container = (SkinnableContainer)d;
+                container.OnComponentsLoaded -= onComponentsLoaded;
+                Schedule(() => bindChangeHandler(container));
+            }
+
             void requestPlacement(Type type)
             {
                 if (!(Activator.CreateInstance(type) is ISerialisableDrawable component))
diff --git a/osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils_ErrorFunction.cs b/osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils.ErrorFunction.cs
similarity index 100%
rename from osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils_ErrorFunction.cs
rename to osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils.ErrorFunction.cs
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index b38b0291e8..c138808890 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -262,14 +262,6 @@ namespace osu.Game.Rulesets.Edit
                                       .Select(t => new HitObjectCompositionToolButton(t, () => toolSelected(t)))
                                       .ToList();
 
-            foreach (var item in toolboxCollection.Items)
-            {
-                item.Selected.DisabledChanged += isDisabled =>
-                {
-                    item.TooltipText = isDisabled ? "Add at least one timing point first!" : ((HitObjectCompositionToolButton)item).TooltipText;
-                };
-            }
-
             togglesCollection.AddRange(CreateTernaryButtons().ToArray());
 
             sampleBankTogglesCollection.AddRange(BlueprintContainer.SampleBankTernaryStates);
diff --git a/osu.Game/Rulesets/Edit/HitObjectCompositionToolButton.cs b/osu.Game/Rulesets/Edit/HitObjectCompositionToolButton.cs
index 641d60dbd3..65a0fb983a 100644
--- a/osu.Game/Rulesets/Edit/HitObjectCompositionToolButton.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectCompositionToolButton.cs
@@ -16,7 +16,10 @@ namespace osu.Game.Rulesets.Edit
         {
             Tool = tool;
 
-            TooltipText = tool.TooltipText;
+            Selected.BindDisabledChanged(isDisabled =>
+            {
+                TooltipText = isDisabled ? "Add at least one timing point first!" : Tool.TooltipText;
+            }, true);
         }
     }
 }
diff --git a/osu.Game/Rulesets/Mods/Mod.cs b/osu.Game/Rulesets/Mods/Mod.cs
index 727db913e2..477372b97d 100644
--- a/osu.Game/Rulesets/Mods/Mod.cs
+++ b/osu.Game/Rulesets/Mods/Mod.cs
@@ -56,6 +56,9 @@ namespace osu.Game.Rulesets.Mods
                 {
                     var bindable = (IBindable)property.GetValue(this)!;
 
+                    if (bindable.IsDefault)
+                        continue;
+
                     string valueText;
 
                     switch (bindable)
@@ -69,8 +72,7 @@ namespace osu.Game.Rulesets.Mods
                             break;
                     }
 
-                    if (!bindable.IsDefault)
-                        yield return (attr.Label, valueText);
+                    yield return (attr.Label, valueText);
                 }
             }
         }
diff --git a/osu.Game/Rulesets/Mods/ModBarrelRoll.cs b/osu.Game/Rulesets/Mods/ModBarrelRoll.cs
index 22d2f41b82..98a7999065 100644
--- a/osu.Game/Rulesets/Mods/ModBarrelRoll.cs
+++ b/osu.Game/Rulesets/Mods/ModBarrelRoll.cs
@@ -46,8 +46,10 @@ namespace osu.Game.Rulesets.Mods
         {
             get
             {
-                yield return ("Roll speed", $"{SpinSpeed.Value:N2} rpm");
-                yield return ("Direction", Direction.Value.GetDescription());
+                if (!SpinSpeed.IsDefault)
+                    yield return ("Roll speed", $"{SpinSpeed.Value:N2} rpm");
+                if (!Direction.IsDefault)
+                    yield return ("Direction", Direction.Value.GetDescription());
             }
         }
 
@@ -55,7 +57,8 @@ namespace osu.Game.Rulesets.Mods
 
         public virtual void Update(Playfield playfield)
         {
-            playfieldAdjustmentContainer.Rotation = CurrentRotation = (Direction.Value == RotationDirection.Counterclockwise ? -1 : 1) * 360 * (float)(playfield.Time.Current / 60000 * SpinSpeed.Value);
+            playfieldAdjustmentContainer.Rotation =
+                CurrentRotation = (Direction.Value == RotationDirection.Counterclockwise ? -1 : 1) * 360 * (float)(playfield.Time.Current / 60000 * SpinSpeed.Value);
         }
 
         public void ApplyToDrawableRuleset(DrawableRuleset<TObject> drawableRuleset)
diff --git a/osu.Game/Rulesets/Mods/ModRateAdjust.cs b/osu.Game/Rulesets/Mods/ModRateAdjust.cs
index d5fc1363bb..49bdd93bc6 100644
--- a/osu.Game/Rulesets/Mods/ModRateAdjust.cs
+++ b/osu.Game/Rulesets/Mods/ModRateAdjust.cs
@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Mods
             get
             {
                 if (!SpeedChange.IsDefault)
-                    yield return ("Speed change", $"{SpeedChange.Value:N2}x");
+                    yield return ("Speed change", FormattableString.Invariant($@"{SpeedChange.Value:N2}x"));
             }
         }
 
diff --git a/osu.Game/Rulesets/Mods/ModTimeRamp.cs b/osu.Game/Rulesets/Mods/ModTimeRamp.cs
index 8dfe8444e8..049b8f9b7f 100644
--- a/osu.Game/Rulesets/Mods/ModTimeRamp.cs
+++ b/osu.Game/Rulesets/Mods/ModTimeRamp.cs
@@ -41,7 +41,8 @@ namespace osu.Game.Rulesets.Mods
         {
             get
             {
-                yield return ("Speed change", $"{InitialRate.Value:N2}x to {FinalRate.Value:N2}x");
+                if (!InitialRate.IsDefault || !FinalRate.IsDefault)
+                    yield return ("Speed change", $"{InitialRate.Value:N2}x to {FinalRate.Value:N2}x");
 
                 if (!AdjustPitch.IsDefault)
                     yield return ("Adjust pitch", AdjustPitch.Value ? "On" : "Off");
diff --git a/osu.Game/Rulesets/Objects/Pooling/PooledDrawableWithLifetimeContainer.cs b/osu.Game/Rulesets/Objects/Pooling/PooledDrawableWithLifetimeContainer.cs
index efc10f26e1..e01df1428c 100644
--- a/osu.Game/Rulesets/Objects/Pooling/PooledDrawableWithLifetimeContainer.cs
+++ b/osu.Game/Rulesets/Objects/Pooling/PooledDrawableWithLifetimeContainer.cs
@@ -160,8 +160,8 @@ namespace osu.Game.Rulesets.Objects.Pooling
             if (!IsPresent)
                 return false;
 
-            bool aliveChanged = base.CheckChildrenLife();
-            aliveChanged |= lifetimeManager.Update(Time.Current - PastLifetimeExtension, Time.Current + FutureLifetimeExtension);
+            bool aliveChanged = lifetimeManager.Update(Time.Current - PastLifetimeExtension, Time.Current + FutureLifetimeExtension);
+            aliveChanged |= base.CheckChildrenLife();
             return aliveChanged;
         }
     }
diff --git a/osu.Game/Rulesets/UI/FrameStabilityContainer.cs b/osu.Game/Rulesets/UI/FrameStabilityContainer.cs
index 329a41ef28..990c1c839b 100644
--- a/osu.Game/Rulesets/UI/FrameStabilityContainer.cs
+++ b/osu.Game/Rulesets/UI/FrameStabilityContainer.cs
@@ -63,6 +63,9 @@ namespace osu.Game.Rulesets.UI
         /// </summary>
         private readonly FramedClock framedClock;
 
+        [Resolved]
+        private OsuGame? game { get; set; }
+
         private readonly Stopwatch stopwatch = new Stopwatch();
 
         /// <summary>
@@ -161,7 +164,9 @@ namespace osu.Game.Rulesets.UI
             //
             // In testing this triggers *very* rarely even when set to super low values (10 ms). The cases we're worried about involve multi-second jumps.
             // A difference of more than 500 ms seems like a sane number we should never exceed.
-            if (!allowReferenceClockSeeks && Math.Abs(proposedTime - referenceClock.CurrentTime) > 1500)
+            //
+            // Double-checking against the parent clock ensures we don't accidentally freeze time when the game stutters due to a long running frame.
+            if (!allowReferenceClockSeeks && Math.Abs(proposedTime - referenceClock.CurrentTime) > 500 && game?.Clock.ElapsedFrameTime <= 500)
             {
                 if (invalidBassTimeLogCount < 10)
                 {
diff --git a/osu.Game/Scoring/ScoreInfoExtensions.cs b/osu.Game/Scoring/ScoreInfoExtensions.cs
index dd08326742..2eec0399d6 100644
--- a/osu.Game/Scoring/ScoreInfoExtensions.cs
+++ b/osu.Game/Scoring/ScoreInfoExtensions.cs
@@ -5,8 +5,11 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Models;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select.Leaderboards;
+using Realms;
 
 namespace osu.Game.Scoring
 {
@@ -64,5 +67,23 @@ namespace osu.Game.Scoring
         /// <param name="score">The <see cref="ScoreInfo"/> to compute the maximum achievable combo for.</param>
         /// <returns>The maximum achievable combo.</returns>
         public static int GetMaximumAchievableCombo(this ScoreInfo score) => score.MaximumStatistics.Where(kvp => kvp.Key.AffectsCombo()).Sum(kvp => kvp.Value);
+
+        /// <summary>
+        /// Performs a realm filter that returns all scores that belong to the user with the given <paramref name="userId"/>.
+        /// <see langword="null"/> <paramref name="userId"/> (for guests) is supported.
+        /// </summary>
+        /// <remarks>
+        /// All guest scores (with user ID of <see cref="APIUser.SYSTEM_USER_ID"/>),
+        /// as well as scores of unknown provenance (with default user ID of 1, see <see cref="APIUser.OnlineID"/>),
+        /// will be treated as if they belong to the local user.
+        /// This may not be necessarily considered fully correct in some circumstances, but in most cases it is the desired effect.
+        /// </remarks>
+        public static IQueryable<ScoreInfo> GetAllLocalScoresForUser(this Realm realm, int? userId)
+        {
+            return realm.All<ScoreInfo>()
+                        .Filter($@"({nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} == $0 || {nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} <= 1)"
+                                + $@" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
+                                + $@" && {nameof(ScoreInfo.DeletePending)} == false", userId);
+        }
     }
 }
diff --git a/osu.Game/Scoring/ScoreRank.cs b/osu.Game/Scoring/ScoreRank.cs
index 957cfc9b95..7e44e46471 100644
--- a/osu.Game/Scoring/ScoreRank.cs
+++ b/osu.Game/Scoring/ScoreRank.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.ComponentModel;
 using osu.Framework.Localisation;
 using osu.Game.Resources.Localisation.Web;
 
@@ -10,40 +9,31 @@ namespace osu.Game.Scoring
     public enum ScoreRank
     {
         // TODO: Localisable?
-        [Description(@"F")]
         F = -1,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.RankD))]
-        [Description(@"D")]
         D,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.RankC))]
-        [Description(@"C")]
         C,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.RankB))]
-        [Description(@"B")]
         B,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.RankA))]
-        [Description(@"A")]
         A,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.RankS))]
-        [Description(@"S")]
         S,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.RankSH))]
-        [Description(@"S+")]
         // ReSharper disable once InconsistentNaming
         SH,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.RankX))]
-        [Description(@"SS")]
         X,
 
         [LocalisableDescription(typeof(BeatmapsStrings), nameof(BeatmapsStrings.RankXH))]
-        [Description(@"SS+")]
         // ReSharper disable once InconsistentNaming
         XH,
     }
diff --git a/osu.Game/Screens/Backgrounds/BackgroundScreenDefault.cs b/osu.Game/Screens/Backgrounds/BackgroundScreenDefault.cs
index 7be96718bd..82bfd23801 100644
--- a/osu.Game/Screens/Backgrounds/BackgroundScreenDefault.cs
+++ b/osu.Game/Screens/Backgrounds/BackgroundScreenDefault.cs
@@ -163,6 +163,7 @@ namespace osu.Game.Screens.Backgrounds
                             case TrianglesSkin:
                             case ArgonSkin:
                             case DefaultLegacySkin:
+                            case RetroSkin:
                                 // default skins should use the default background rotation, which won't be the case if a SkinBackground is created for them.
                                 break;
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
index 5e8637c1ac..cdd2f52dab 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
@@ -16,7 +16,6 @@ using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Utils;
 using osu.Game.Audio;
-using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
@@ -57,9 +56,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         protected virtual double GetTime() => HitObject is IHasRepeats r ? HitObject.StartTime + r.Duration / r.SpanCount() / 2 : HitObject.StartTime;
 
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load()
         {
-            HitObject.DefaultsApplied += _ => updateText();
             Label.AllowMultiline = false;
             LabelContainer.AutoSizeAxes = Axes.None;
             updateText();
@@ -74,6 +72,8 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         {
             base.LoadComplete();
 
+            HitObject.DefaultsApplied += onDefaultsApplied;
+
             if (timelineBlueprintContainer != null)
                 contracted.BindTo(timelineBlueprintContainer.SamplePointContracted);
 
@@ -96,12 +96,19 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             FinishTransforms();
         }
 
+        private void onDefaultsApplied(HitObject hitObject)
+        {
+            updateText();
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
 
             if (editor != null)
                 editor.ShowSampleEditPopoverRequested -= onShowSampleEditPopoverRequested;
+
+            HitObject.DefaultsApplied -= onDefaultsApplied;
         }
 
         private void onShowSampleEditPopoverRequested(double time)
diff --git a/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs b/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
index 02eb38ffa6..eedde8b7a4 100644
--- a/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
+++ b/osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs
@@ -55,12 +55,25 @@ namespace osu.Game.Screens.Edit.GameplayTest
             return masterGameplayClockContainer;
         }
 
+        protected override void LoadAsyncComplete()
+        {
+            base.LoadAsyncComplete();
+
+            if (!LoadedBeatmapSuccessfully)
+                return;
+
+            // This hack needs to be called to install its hooks before drawable hit objects get the chance to run update logic,
+            // because it will not work otherwise due to being too late (various effects of the objects getting missed will have already taken place).
+            preventMissOnPreviousHitObjects();
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
+            // this will notify components such as the skin's combo counter, which needs to happen on the update thread
+            // and therefore can't happen alongside `preventMissOnPreviousHitObjects()` in `LoadAsyncComplete()`
             markPreviousObjectsHit();
-            markVisibleDrawableObjectsHit();
 
             ScoreProcessor.HasCompleted.BindValueChanged(completed =>
             {
@@ -111,38 +124,45 @@ namespace osu.Game.Screens.Edit.GameplayTest
             }
         }
 
-        private void markVisibleDrawableObjectsHit()
+        private void preventMissOnPreviousHitObjects()
         {
-            if (!DrawableRuleset.Playfield.IsLoaded)
+            void preventMiss(HitObject hitObject)
             {
-                Schedule(markVisibleDrawableObjectsHit);
-                return;
+                var drawableObject = DrawableRuleset.Playfield.HitObjectContainer
+                                                    .AliveObjects
+                                                    .SingleOrDefault(it => it.HitObject == hitObject);
+
+                if (drawableObject != null)
+                    preventMissOnDrawable(drawableObject);
             }
 
-            foreach (var drawableObject in enumerateDrawableObjects(DrawableRuleset.Playfield.AllHitObjects, editorState.Time))
+            void preventMissOnDrawable(DrawableHitObject drawableObject)
             {
-                if (drawableObject.Entry == null)
-                    continue;
+                foreach (var nested in drawableObject.NestedHitObjects)
+                    preventMissOnDrawable(nested);
 
-                var result = drawableObject.CreateResult(drawableObject.HitObject.Judgement);
-                result.Type = result.Judgement.MaxResult;
-                drawableObject.Entry.Result = result;
-            }
-
-            static IEnumerable<DrawableHitObject> enumerateDrawableObjects(IEnumerable<DrawableHitObject> drawableObjects, double cutoffTime)
-            {
-                foreach (var drawableObject in drawableObjects)
+                if (drawableObject.Entry != null && drawableObject.HitObject.GetEndTime() < editorState.Time)
                 {
-                    foreach (var nested in enumerateDrawableObjects(drawableObject.NestedHitObjects, cutoffTime))
-                    {
-                        if (nested.HitObject.GetEndTime() < cutoffTime)
-                            yield return nested;
-                    }
-
-                    if (drawableObject.HitObject.GetEndTime() < cutoffTime)
-                        yield return drawableObject;
+                    var result = drawableObject.CreateResult(drawableObject.HitObject.Judgement);
+                    result.Type = result.Judgement.MaxResult;
+                    drawableObject.Entry.Result = result;
                 }
             }
+
+            void removeListener()
+            {
+                if (!DrawableRuleset.Playfield.IsLoaded)
+                {
+                    Schedule(removeListener);
+                    return;
+                }
+
+                DrawableRuleset.Playfield.HitObjectUsageBegan -= preventMiss;
+            }
+
+            DrawableRuleset.Playfield.HitObjectUsageBegan += preventMiss;
+
+            Schedule(removeListener);
         }
 
         protected override void PrepareReplay()
diff --git a/osu.Game/Screens/Edit/Submission/SubmissionStageProgress.cs b/osu.Game/Screens/Edit/Submission/SubmissionStageProgress.cs
index 8af4e3fe52..e7f8ff933d 100644
--- a/osu.Game/Screens/Edit/Submission/SubmissionStageProgress.cs
+++ b/osu.Game/Screens/Edit/Submission/SubmissionStageProgress.cs
@@ -263,6 +263,7 @@ namespace osu.Game.Screens.Edit.Submission
                     iconContainer.Colour = colours.Red1;
                     iconContainer.FlashColour(Colour4.White, 1000, Easing.OutQuint);
                     errorSample?.Play();
+                    progressSampleChannel?.Stop();
                     break;
 
                 case StageStatusType.Canceled:
@@ -274,6 +275,7 @@ namespace osu.Game.Screens.Edit.Submission
                     iconContainer.Colour = colours.Gray8;
                     iconContainer.FlashColour(Colour4.White, 1000, Easing.OutQuint);
                     cancelSample?.Play();
+                    progressSampleChannel?.Stop();
                     break;
             }
         }
diff --git a/osu.Game/Screens/Menu/ButtonSystem.cs b/osu.Game/Screens/Menu/ButtonSystem.cs
index 073a0d4021..46a98dd5da 100644
--- a/osu.Game/Screens/Menu/ButtonSystem.cs
+++ b/osu.Game/Screens/Menu/ButtonSystem.cs
@@ -13,6 +13,7 @@ using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Logging;
@@ -46,6 +47,7 @@ namespace osu.Game.Screens.Menu
         public Action? OnSolo;
         public Action? OnSettings;
         public Action? OnMultiplayer;
+        public Action? OnMatchmaking;
         public Action? OnPlaylists;
         public Action<Room>? OnDailyChallenge;
 
@@ -84,6 +86,7 @@ namespace osu.Game.Screens.Menu
 
         private readonly List<MainMenuButton> buttonsTopLevel = new List<MainMenuButton>();
         private readonly List<MainMenuButton> buttonsPlay = new List<MainMenuButton>();
+        private readonly List<MainMenuButton> buttonsMulti = new List<MainMenuButton>();
         private readonly List<MainMenuButton> buttonsEdit = new List<MainMenuButton>();
 
         private Sample? sampleBackToLogo;
@@ -109,7 +112,19 @@ namespace osu.Game.Screens.Menu
                 {
                     Padding = new MarginPadding { Right = WEDGE_WIDTH },
                 },
-                backButton = new MainMenuButton(ButtonSystemStrings.Back, @"back-to-top", OsuIcon.PrevCircle, new Color4(51, 58, 94, 255), (_, _) => State = ButtonSystemState.TopLevel)
+                backButton = new MainMenuButton(ButtonSystemStrings.Back, @"back-to-top", OsuIcon.PrevCircle, new Color4(51, 58, 94, 255), (_, _) =>
+                {
+                    switch (State)
+                    {
+                        case ButtonSystemState.Multi:
+                            State = ButtonSystemState.Play;
+                            break;
+
+                        default:
+                            State = ButtonSystemState.TopLevel;
+                            break;
+                    }
+                })
                 {
                     Padding = new MarginPadding { Right = WEDGE_WIDTH },
                     VisibleStateMin = ButtonSystemState.Play,
@@ -137,28 +152,39 @@ namespace osu.Game.Screens.Menu
             {
                 Padding = new MarginPadding { Left = WEDGE_WIDTH },
             });
-            buttonsPlay.Add(new MainMenuButton(ButtonSystemStrings.Multi, @"button-default-select", OsuIcon.Online, new Color4(94, 63, 186, 255), onMultiplayer, Key.M));
+            buttonsPlay.Add(new MainMenuButton(ButtonSystemStrings.Multi, @"button-default-select", OsuIcon.Online, new Color4(94, 63, 186, 255), (_, _) => State = ButtonSystemState.Multi, Key.M));
             buttonsPlay.Add(new MainMenuButton(ButtonSystemStrings.Playlists, @"button-default-select", OsuIcon.Tournament, new Color4(94, 63, 186, 255), onPlaylists, Key.L));
             buttonsPlay.Add(new DailyChallengeButton(@"button-daily-select", new Color4(94, 63, 186, 255), onDailyChallenge, Key.D));
             buttonsPlay.ForEach(b => b.VisibleState = ButtonSystemState.Play);
 
-            buttonsEdit.Add(new MainMenuButton(EditorStrings.BeatmapEditor.ToLower(), @"button-default-select", OsuIcon.Beatmap, new Color4(238, 170, 0, 255), (_, _) => OnEditBeatmap?.Invoke(), Key.B, Key.E)
+            buttonsMulti.Add(new MainMenuButton("lounge", @"button-default-select", FontAwesome.Solid.Couch, new Color4(94, 63, 186, 255), onMultiplayer, Key.L, Key.M)
+            {
+                Padding = new MarginPadding { Left = WEDGE_WIDTH }
+            });
+            buttonsMulti.Add(new MainMenuButton("quick play", @"button-default-select", FontAwesome.Solid.Bolt, new Color4(94, 63, 186, 255), onMatchmaking, Key.Q));
+            buttonsMulti.ForEach(b => b.VisibleState = ButtonSystemState.Multi);
+
+            buttonsEdit.Add(new MainMenuButton(EditorStrings.BeatmapEditor.ToLower(), @"button-default-select", OsuIcon.Beatmap, new Color4(238, 170, 0, 255), (_, _) => OnEditBeatmap?.Invoke(), Key.B,
+                Key.E)
             {
                 Padding = new MarginPadding { Left = WEDGE_WIDTH },
             });
             buttonsEdit.Add(new MainMenuButton(SkinEditorStrings.SkinEditor.ToLower(), @"button-default-select", OsuIcon.SkinB, new Color4(220, 160, 0, 255), (_, _) => OnEditSkin?.Invoke(), Key.S));
             buttonsEdit.ForEach(b => b.VisibleState = ButtonSystemState.Edit);
 
-            buttonsTopLevel.Add(new MainMenuButton(ButtonSystemStrings.Play, @"button-play-select", OsuIcon.Logo, new Color4(102, 68, 204, 255), (_, _) => State = ButtonSystemState.Play, Key.P, Key.M, Key.L)
+            buttonsTopLevel.Add(new MainMenuButton(ButtonSystemStrings.Play, @"button-play-select", OsuIcon.Logo, new Color4(102, 68, 204, 255), (_, _) => State = ButtonSystemState.Play, Key.P, Key.M,
+                Key.L)
             {
                 Padding = new MarginPadding { Left = WEDGE_WIDTH },
             });
             buttonsTopLevel.Add(new MainMenuButton(ButtonSystemStrings.Edit, @"button-play-select", OsuIcon.EditCircle, new Color4(238, 170, 0, 255), (_, _) => State = ButtonSystemState.Edit, Key.E));
-            buttonsTopLevel.Add(new MainMenuButton(ButtonSystemStrings.Browse, @"button-default-select", OsuIcon.Beatmap, new Color4(165, 204, 0, 255), (_, _) => OnBeatmapListing?.Invoke(), Key.B, Key.D));
+            buttonsTopLevel.Add(new MainMenuButton(ButtonSystemStrings.Browse, @"button-default-select", OsuIcon.Beatmap, new Color4(165, 204, 0, 255), (_, _) => OnBeatmapListing?.Invoke(), Key.B,
+                Key.D));
 
             if (host.CanExit)
                 buttonsTopLevel.Add(new MainMenuButton(ButtonSystemStrings.Exit, string.Empty, OsuIcon.CrossCircle, new Color4(238, 51, 153, 255), (_, e) => OnExit?.Invoke(e), Key.Q));
 
+            buttonArea.AddRange(buttonsMulti);
             buttonArea.AddRange(buttonsPlay);
             buttonArea.AddRange(buttonsEdit);
             buttonArea.AddRange(buttonsTopLevel);
@@ -191,6 +217,17 @@ namespace osu.Game.Screens.Menu
             OnMultiplayer?.Invoke();
         }
 
+        private void onMatchmaking(MainMenuButton mainMenuButton, UIEvent uiEvent)
+        {
+            if (api.State.Value != APIState.Online)
+            {
+                loginOverlay?.Show();
+                return;
+            }
+
+            OnMatchmaking?.Invoke();
+        }
+
         private void onPlaylists(MainMenuButton mainMenuButton, UIEvent uiEvent)
         {
             if (api.State.Value != APIState.Online)
@@ -315,6 +352,7 @@ namespace osu.Game.Screens.Menu
 
                 case ButtonSystemState.Edit:
                 case ButtonSystemState.Play:
+                case ButtonSystemState.Multi:
                     StopSamplePlayback();
                     backButton.TriggerClick();
                     return true;
@@ -327,6 +365,7 @@ namespace osu.Game.Screens.Menu
         public void StopSamplePlayback()
         {
             buttonsPlay.ForEach(button => button.StopSamplePlayback());
+            buttonsMulti.ForEach(button => button.StopSamplePlayback());
             buttonsTopLevel.ForEach(button => button.StopSamplePlayback());
             logo?.StopSamplePlayback();
         }
@@ -350,6 +389,10 @@ namespace osu.Game.Screens.Menu
                     buttonsPlay.First().TriggerClick();
                     return false;
 
+                case ButtonSystemState.Multi:
+                    buttonsPlay.First().TriggerClick();
+                    return false;
+
                 case ButtonSystemState.Edit:
                     buttonsEdit.First().TriggerClick();
                     return false;
@@ -471,6 +514,7 @@ namespace osu.Game.Screens.Menu
         Initial,
         TopLevel,
         Play,
+        Multi,
         Edit,
         EnteringMode,
     }
diff --git a/osu.Game/Screens/Menu/MainMenu.cs b/osu.Game/Screens/Menu/MainMenu.cs
index bc3bcbd800..c4ba3145b5 100644
--- a/osu.Game/Screens/Menu/MainMenu.cs
+++ b/osu.Game/Screens/Menu/MainMenu.cs
@@ -159,6 +159,7 @@ namespace osu.Game.Screens.Menu
                             },
                             OnSolo = loadSongSelect,
                             OnMultiplayer = () => this.Push(new Multiplayer()),
+                            OnMatchmaking = joinOrLeaveMatchmakingQueue,
                             OnPlaylists = () => this.Push(new Playlists()),
                             OnDailyChallenge = room =>
                             {
@@ -481,6 +482,8 @@ namespace osu.Game.Screens.Menu
 
         private void loadSongSelect() => this.Push(new SoloSongSelect());
 
+        private void joinOrLeaveMatchmakingQueue() => this.Push(new OnlinePlay.Matchmaking.Intro.IntroScreen());
+
         private partial class MobileDisclaimerDialog : PopupDialog
         {
             public MobileDisclaimerDialog(Action confirmed)
diff --git a/osu.Game/Screens/Menu/MenuTipDisplay.cs b/osu.Game/Screens/Menu/MenuTipDisplay.cs
index 7e538995b2..d9c90b069d 100644
--- a/osu.Game/Screens/Menu/MenuTipDisplay.cs
+++ b/osu.Game/Screens/Menu/MenuTipDisplay.cs
@@ -118,7 +118,7 @@ namespace osu.Game.Screens.Menu
                 .FadeOutFromOne(2000, Easing.OutQuint);
         }
 
-        private const int available_tips = 29;
+        private const int available_tips = 30;
 
         private LocalisableString getRandomTip()
         {
@@ -216,6 +216,9 @@ namespace osu.Game.Screens.Menu
 
                 case 28:
                     return MenuTipStrings.RightMouseAbsoluteScroll;
+
+                case 29:
+                    return MenuTipStrings.ShiftClickInBeatmapOverlay;
             }
 
             return string.Empty;
diff --git a/osu.Game/Screens/OnlinePlay/Header.cs b/osu.Game/Screens/OnlinePlay/Header.cs
index 860042fd37..825f809397 100644
--- a/osu.Game/Screens/OnlinePlay/Header.cs
+++ b/osu.Game/Screens/OnlinePlay/Header.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Screens.OnlinePlay
 {
     public partial class Header : Container
     {
-        public const float HEIGHT = 80;
+        public const float HEIGHT = 50;
 
         private readonly ScreenStack? stack;
         private readonly MultiHeaderTitle title;
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoomParticipantsList.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoomParticipantsList.cs
index 5bcc974c26..135b2b4db2 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoomParticipantsList.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/DrawableRoomParticipantsList.cs
@@ -23,10 +23,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 {
     public partial class DrawableRoomParticipantsList : CompositeDrawable
     {
-        public const float SHEAR_WIDTH = 12f;
-        private const float avatar_size = 36;
-        private const float height = 60f;
-        private static readonly Vector2 shear = new Vector2(SHEAR_WIDTH / height, 0);
+        private const float avatar_size = 30;
+        private const float height = 40f;
 
         private readonly Room room;
 
@@ -54,7 +52,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                     RelativeSizeAxes = Axes.Both,
                     Masking = true,
                     CornerRadius = 10,
-                    Shear = shear,
+                    Shear = OsuGame.SHEAR,
                     Child = new Box
                     {
                         RelativeSizeAxes = Axes.Both,
@@ -71,10 +69,10 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                         {
                             RelativeSizeAxes = Axes.Y,
                             AutoSizeAxes = Axes.X,
-                            Spacing = new Vector2(8),
+                            Spacing = new Vector2(4),
                             Padding = new MarginPadding
                             {
-                                Left = 8,
+                                Left = 4,
                                 Right = 16
                             },
                             Children = new Drawable[]
@@ -84,7 +82,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
                                 },
-                                hostText = new LinkFlowContainer
+                                hostText = new LinkFlowContainer(s => s.Font = OsuFont.Style.Caption2)
                                 {
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
@@ -103,7 +101,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                     RelativeSizeAxes = Axes.Both,
                                     Masking = true,
                                     CornerRadius = 10,
-                                    Shear = shear,
+                                    Shear = OsuGame.SHEAR,
                                     Child = new Box
                                     {
                                         RelativeSizeAxes = Axes.Both,
@@ -128,12 +126,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                         {
                                             Anchor = Anchor.CentreLeft,
                                             Origin = Anchor.CentreLeft,
-                                            Size = new Vector2(16),
+                                            Size = new Vector2(12),
                                             Icon = FontAwesome.Solid.User,
                                         },
                                         totalCount = new OsuSpriteText
                                         {
-                                            Font = OsuFont.Default.With(weight: FontWeight.Bold),
+                                            Font = OsuFont.Style.Caption2.With(weight: FontWeight.Bold),
                                             Anchor = Anchor.CentreLeft,
                                             Origin = Anchor.CentreLeft,
                                         },
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/EndDateInfo.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/EndDateInfo.cs
index 3b03ce61f1..4a98efb225 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/EndDateInfo.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/EndDateInfo.cs
@@ -6,6 +6,7 @@ using System.ComponentModel;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Localisation;
 using osu.Game.Graphics;
 using osu.Game.Online.Rooms;
 
@@ -62,7 +63,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 Date = room.EndDate ?? DateTimeOffset.Now.AddYears(1);
             }
 
-            protected override string Format()
+            protected override LocalisableString Format()
             {
                 if (room.EndDate == null)
                     return string.Empty;
@@ -70,7 +71,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 var diffToNow = Date.Subtract(DateTimeOffset.Now);
 
                 if (diffToNow.TotalSeconds < -5)
-                    return $"Closed {base.Format()}";
+                    return LocalisableString.Interpolate($"Closed {base.Format()}");
 
                 if (diffToNow.TotalSeconds < 0)
                     return "Closed";
@@ -78,7 +79,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 if (diffToNow.TotalSeconds < 5)
                     return "Closing soon";
 
-                return $"Closing {base.Format()}";
+                return LocalisableString.Interpolate($"Closing {base.Format()}");
             }
 
             protected override void Dispose(bool isDisposing)
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
index 14edd13ec5..f04de97f9b 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
@@ -45,8 +45,6 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         private readonly ScrollContainer<Drawable> scroll;
         private readonly FillFlowContainer<LoungeRoomPanel> roomFlow;
 
-        private const float display_scale = 0.8f;
-
         // handle deselection
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
@@ -58,7 +56,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 RelativeSizeAxes = Axes.Both,
                 Anchor = Anchor.TopCentre,
                 Origin = Anchor.TopCentre,
-                Width = display_scale,
+                Width = 0.8f,
                 ScrollbarOverlapsContent = false,
                 Padding = new MarginPadding { Right = 5 },
                 Child = new OsuContextMenuContainer
@@ -188,14 +186,11 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                     SelectedRoom = selectedRoom,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Scale = new Vector2(display_scale),
-                    Width = 1 / display_scale,
                 };
 
                 roomFlow.Add(drawableRoom);
 
-                // Always show spotlight playlists at the top of the listing.
-                roomFlow.SetLayoutPosition(drawableRoom, room.Category > RoomCategory.Normal ? float.MinValue : -(room.RoomID ?? 0));
+                roomFlow.SetLayoutPosition(drawableRoom, room.Pinned ? float.MinValue : -(room.RoomID ?? 0));
             }
 
             applyFilterCriteria(Filter.Value);
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
index 3610995b2c..fe03fca4b8 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomPanel.cs
@@ -31,7 +31,6 @@ using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.Components;
 using osuTK;
-using osuTK.Graphics;
 using Container = osu.Framework.Graphics.Containers.Container;
 
 namespace osu.Game.Screens.OnlinePlay.Lounge.Components
@@ -39,7 +38,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
     public abstract partial class RoomPanel : CompositeDrawable, IHasContextMenu
     {
         protected const float CORNER_RADIUS = 10;
-        private const float height = 100;
+        private const float height = 80;
 
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
@@ -59,7 +58,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
         private DrawableRoomParticipantsList? drawableRoomParticipantsList;
         private RoomSpecialCategoryPill? specialCategoryPill;
-        private PasswordProtectedIcon? passwordIcon;
+        private CornerIcon? passwordIcon;
+        private CornerIcon? pinnedIcon;
         private EndDateInfo? endDateInfo;
         private RoomNameLine? roomName;
         private DelayedLoadWrapper wrapper = null!;
@@ -79,16 +79,10 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
             Masking = true;
             CornerRadius = CORNER_RADIUS;
-            EdgeEffect = new EdgeEffectParameters
-            {
-                Type = EdgeEffectType.Shadow,
-                Colour = Color4.Black.Opacity(40),
-                Radius = 5,
-            };
         }
 
         [BackgroundDependencyLoader]
-        private void load(OverlayColourProvider colours)
+        private void load(OverlayColourProvider colourProvider, OsuColour colours)
         {
             ButtonsContainer = new Container
             {
@@ -98,13 +92,20 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 AutoSizeAxes = Axes.X
             };
 
+            EdgeEffect = new EdgeEffectParameters
+            {
+                Type = EdgeEffectType.Shadow,
+                Colour = colourProvider.Background6.Opacity(0.4f),
+                Radius = 4,
+            };
+
             InternalChildren = new Drawable[]
             {
                 // This resolves internal 1px gaps due to applying the (parenting) corner radius and masking across multiple filling background sprites.
                 new Box
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Colour = colours.Background5,
+                    Colour = colourProvider.Background5,
                 },
                 CreateBackground().With(d =>
                 {
@@ -117,7 +118,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                         Name = @"Room content",
                         RelativeSizeAxes = Axes.Both,
                         // This negative padding resolves 1px gaps between this background and the background above.
-                        Padding = new MarginPadding { Left = 20, Vertical = -0.5f },
+                        Padding = new MarginPadding { Left = 10, Vertical = -0.5f },
                         Child = new Container
                         {
                             RelativeSizeAxes = Axes.Both,
@@ -128,7 +129,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                 new Box
                                 {
                                     RelativeSizeAxes = Axes.Both,
-                                    Colour = colours.Background5,
+                                    Colour = colourProvider.Background5,
                                     Width = 0.2f,
                                 },
                                 new Box
@@ -136,7 +137,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                     Anchor = Anchor.TopRight,
                                     Origin = Anchor.TopRight,
                                     RelativeSizeAxes = Axes.Both,
-                                    Colour = ColourInfo.GradientHorizontal(colours.Background5, colours.Background5.Opacity(0.3f)),
+                                    Colour = ColourInfo.GradientHorizontal(colourProvider.Background5, colourProvider.Background5.Opacity(0.3f)),
                                     Width = 0.8f,
                                 },
                                 new GridContainer
@@ -157,8 +158,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                                 RelativeSizeAxes = Axes.Both,
                                                 Padding = new MarginPadding
                                                 {
-                                                    Left = 20,
-                                                    Right = DrawableRoomParticipantsList.SHEAR_WIDTH,
+                                                    Left = 10,
+                                                    Right = 10,
                                                     Vertical = 5
                                                 },
                                                 Children = new Drawable[]
@@ -254,7 +255,28 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                                         }
                                     }
                                 },
-                                passwordIcon = new PasswordProtectedIcon { Alpha = 0 }
+                                passwordIcon = new CornerIcon
+                                {
+                                    Alpha = 0,
+                                    Background = { Colour = colours.Gray8, },
+                                    Icon =
+                                    {
+                                        Icon = FontAwesome.Solid.Lock,
+                                        Colour = colours.Gray3,
+                                        Rotation = 45,
+                                    },
+                                },
+                                pinnedIcon = new CornerIcon
+                                {
+                                    Alpha = 0,
+                                    Background = { Colour = colours.Orange2 },
+                                    Icon =
+                                    {
+                                        Icon = FontAwesome.Solid.Thumbtack,
+                                        Colour = colours.Gray3,
+                                        Rotation = 45,
+                                    },
+                                }
                             },
                         },
                     }, 0)
@@ -283,6 +305,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 updateRoomCategory();
                 updateRoomType();
                 updateRoomHasPassword();
+                updateRoomPinned();
             };
 
             SelectedItem.BindValueChanged(onSelectedItemChanged, true);
@@ -311,6 +334,10 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 case nameof(Room.HasPassword):
                     updateRoomHasPassword();
                     break;
+
+                case nameof(Room.Pinned):
+                    updateRoomPinned();
+                    break;
             }
         }
 
@@ -371,6 +398,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 passwordIcon.Alpha = Room.HasPassword ? 1 : 0;
         }
 
+        private void updateRoomPinned()
+        {
+            if (pinnedIcon != null)
+                pinnedIcon.Alpha = Room.Pinned ? 1 : 0;
+        }
+
         private int numberOfAvatars = 7;
 
         public int NumberOfAvatars
@@ -483,12 +516,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                         {
                             statusText = new OsuSpriteText
                             {
-                                Font = OsuFont.Default.With(size: 16),
+                                Font = OsuFont.Style.Caption2,
                                 Colour = colours.Lime1
                             },
                             beatmapText = new LinkFlowContainer(s =>
                             {
-                                s.Font = OsuFont.Default.With(size: 16);
+                                s.Font = OsuFont.Style.Caption2;
                                 s.Colour = colours.Lime1;
                             })
                             {
@@ -534,10 +567,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             }
         }
 
-        public partial class PasswordProtectedIcon : CompositeDrawable
+        public partial class CornerIcon : CompositeDrawable
         {
-            [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
+            public SpriteIcon Icon { get; }
+            public Box Background { get; }
+
+            public CornerIcon()
             {
                 Anchor = Anchor.TopRight;
                 Origin = Anchor.TopRight;
@@ -546,20 +581,19 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
                 InternalChildren = new Drawable[]
                 {
-                    new Box
+                    Background = new Box
                     {
                         Anchor = Anchor.TopRight,
                         Origin = Anchor.TopCentre,
-                        Colour = colours.Gray5,
                         Rotation = 45,
                         RelativeSizeAxes = Axes.Both,
                         Width = 2,
                     },
-                    new SpriteIcon
+                    Icon = new SpriteIcon
                     {
-                        Icon = FontAwesome.Solid.Lock,
                         Anchor = Anchor.TopRight,
-                        Origin = Anchor.TopRight,
+                        Origin = Anchor.Centre,
+                        Position = new Vector2(-13, 13),
                         Margin = new MarginPadding(6),
                         Size = new Vector2(14),
                     }
@@ -602,7 +636,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                     {
                         Anchor = Anchor.BottomLeft,
                         Origin = Anchor.BottomLeft,
-                        Font = OsuFont.GetFont(size: 28),
+                        Font = OsuFont.Style.Heading2,
                     },
                     linkButton = new ExternalLinkButton
                     {
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
index a4e808ff76..b4b039501f 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
@@ -173,7 +173,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
                                         {
                                             d.Anchor = Anchor.BottomLeft;
                                             d.Origin = Anchor.BottomLeft;
-                                            d.Size = new Vector2(150, 37.5f);
+                                            d.Size = new Vector2(150, 30f);
                                             d.Action = () => Open();
                                         })),
                                         new FillFlowContainer
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Intro/ScreenIntro.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Intro/ScreenIntro.cs
new file mode 100644
index 0000000000..b3fff7dc00
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Intro/ScreenIntro.cs
@@ -0,0 +1,266 @@
+// 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.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Extensions.Color4Extensions;
+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.Sprites;
+using osu.Game.Overlays;
+using osu.Game.Screens.OnlinePlay.Match;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Queue;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Intro
+{
+    /// <summary>
+    /// A brief intro animation that introduces matchmaking to the user.
+    /// </summary>
+    public partial class IntroScreen : OsuScreen
+    {
+        public override bool DisallowExternalBeatmapRulesetChanges => false;
+
+        public override bool? ApplyModTrackAdjustments => true;
+
+        public override bool ShowFooter => true;
+
+        private Container introContent = null!;
+
+        private Container titleContainer = null!;
+
+        private bool animationBegan;
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
+
+        [Resolved]
+        private MusicController musicController { get; set; } = null!;
+
+        private Sample? dateWindupSample;
+        private Sample? dateImpactSample;
+        private Sample? beatmapWindupSample;
+        private Sample? beatmapImpactSample;
+
+        private SampleChannel? dateWindupChannel;
+        private SampleChannel? dateImpactChannel;
+        private SampleChannel? beatmapWindupChannel;
+        private SampleChannel? beatmapImpactChannel;
+
+        private IDisposable? duckOperation;
+
+        protected override BackgroundScreen CreateBackground() => new MatchmakingIntroBackgroundScreen(colourProvider);
+
+        public IntroScreen()
+        {
+            ValidForResume = false;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            InternalChildren = new Drawable[]
+            {
+                introContent = new Container
+                {
+                    Alpha = 0f,
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Shear = OsuGame.SHEAR,
+                    Children = new Drawable[]
+                    {
+                        titleContainer = new Container
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Children = new Drawable[]
+                            {
+                                new Container
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    AutoSizeAxes = Axes.Both,
+                                    CornerRadius = 10f,
+                                    Masking = true,
+                                    X = 10,
+                                    Children = new Drawable[]
+                                    {
+                                        new Box
+                                        {
+                                            Colour = colourProvider.Background3,
+                                            RelativeSizeAxes = Axes.Both,
+                                        },
+                                        new OsuSpriteText
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Text = "Quick Play",
+                                            Margin = new MarginPadding { Horizontal = 10f, Vertical = 5f },
+                                            Shear = -OsuGame.SHEAR,
+                                            Font = OsuFont.GetFont(size: 32, weight: FontWeight.Light, typeface: Typeface.TorusAlternate),
+                                        },
+                                    }
+                                },
+                            }
+                        },
+                    }
+                }
+            };
+
+            dateWindupSample = audio.Samples.Get(@"DailyChallenge/date-windup");
+            dateImpactSample = audio.Samples.Get(@"DailyChallenge/date-impact");
+            beatmapWindupSample = audio.Samples.Get(@"DailyChallenge/beatmap-windup");
+            beatmapImpactSample = audio.Samples.Get(@"DailyChallenge/beatmap-impact");
+        }
+
+        public override void OnEntering(ScreenTransitionEvent e)
+        {
+            base.OnEntering(e);
+
+            this.FadeInFromZero(400, Easing.OutQuint);
+
+            updateAnimationState();
+            playDateWindupSample();
+        }
+
+        public override void OnSuspending(ScreenTransitionEvent e)
+        {
+            duckOperation?.Dispose();
+
+            this.FadeOut(800, Easing.OutQuint);
+            base.OnSuspending(e);
+        }
+
+        public override bool OnExiting(ScreenExitEvent e)
+        {
+            if (base.OnExiting(e))
+                return true;
+
+            duckOperation?.Dispose();
+            return false;
+        }
+
+        private void updateAnimationState()
+        {
+            if (animationBegan)
+                return;
+
+            beginAnimation();
+            animationBegan = true;
+        }
+
+        private void beginAnimation()
+        {
+            using (BeginDelayedSequence(200))
+            {
+                introContent.Show();
+
+                titleContainer
+                    .ScaleTo(2)
+                    .Then()
+                    .ScaleTo(1, 400, Easing.In);
+
+                using (BeginDelayedSequence(150))
+                {
+                    Schedule(() =>
+                    {
+                        playDateImpactSample();
+                        playBeatmapWindupSample();
+
+                        duckOperation?.Dispose();
+                        duckOperation = musicController.Duck(new DuckParameters
+                        {
+                            RestoreDuration = 1500f,
+                        });
+                    });
+                }
+
+                using (BeginDelayedSequence(1000))
+                {
+                    using (BeginDelayedSequence(100))
+                    {
+                        titleContainer
+                            .ScaleTo(0.4f, 400, Easing.In)
+                            .FadeOut(500, Easing.OutQuint);
+                    }
+
+                    using (BeginDelayedSequence(240))
+                    {
+                        Schedule(() =>
+                        {
+                            if (this.IsCurrentScreen())
+                                this.Push(new ScreenQueue());
+                        });
+                    }
+                }
+            }
+        }
+
+        private void playDateWindupSample()
+        {
+            dateWindupChannel = dateWindupSample?.GetChannel();
+            dateWindupChannel?.Play();
+        }
+
+        private void playDateImpactSample()
+        {
+            dateImpactChannel = dateImpactSample?.GetChannel();
+            dateImpactChannel?.Play();
+        }
+
+        private void playBeatmapWindupSample()
+        {
+            beatmapWindupChannel = beatmapWindupSample?.GetChannel();
+            beatmapWindupChannel?.Play();
+        }
+
+        private void playBeatmapImpactSample()
+        {
+            beatmapImpactChannel = beatmapImpactSample?.GetChannel();
+            beatmapImpactChannel?.Play();
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            resetAudio();
+            base.Dispose(isDisposing);
+        }
+
+        private void resetAudio()
+        {
+            dateWindupChannel?.Stop();
+            dateImpactChannel?.Stop();
+            beatmapWindupChannel?.Stop();
+            beatmapImpactChannel?.Stop();
+            duckOperation?.Dispose();
+        }
+
+        private partial class MatchmakingIntroBackgroundScreen : RoomBackgroundScreen
+        {
+            private readonly OverlayColourProvider colourProvider;
+
+            public MatchmakingIntroBackgroundScreen(OverlayColourProvider colourProvider)
+                : base(null)
+            {
+                this.colourProvider = colourProvider;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AddInternal(new Box
+                {
+                    Depth = float.MinValue,
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colourProvider.Background5.Opacity(0.6f),
+                });
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/BeatmapCardMatchmaking.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/BeatmapCardMatchmaking.cs
new file mode 100644
index 0000000000..8fbf8491d6
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/BeatmapCardMatchmaking.cs
@@ -0,0 +1,354 @@
+// 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.Extensions.Color4Extensions;
+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.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Beatmaps.Drawables.Cards;
+using osu.Game.Beatmaps.Drawables.Cards.Statistics;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+using osu.Game.Overlays.BeatmapSet;
+using osu.Game.Resources.Localisation.Web;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect
+{
+    public partial class BeatmapCardMatchmaking : BeatmapCard
+    {
+        private readonly APIBeatmap beatmap;
+
+        protected override Drawable IdleContent => idleBottomContent;
+        protected override Drawable DownloadInProgressContent => downloadProgressBar;
+
+        public const float HEIGHT = 80;
+
+        [Cached]
+        private readonly BeatmapCardContent content;
+
+        private BeatmapCardThumbnail thumbnail = null!;
+        private CollapsibleButtonContainer buttonContainer = null!;
+
+        private FillFlowContainer<BeatmapCardStatistic> statisticsContainer = null!;
+
+        private FillFlowContainer idleBottomContent = null!;
+        private BeatmapCardDownloadProgressBar downloadProgressBar = null!;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        public BeatmapCardMatchmaking(APIBeatmap beatmap)
+            : base(beatmap.BeatmapSet!, false)
+        {
+            this.beatmap = beatmap;
+            content = new BeatmapCardContent(HEIGHT);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Width = WIDTH;
+            Height = HEIGHT;
+
+            FillFlowContainer leftIconArea = null!;
+            FillFlowContainer titleBadgeArea = null!;
+            GridContainer artistContainer = null!;
+
+            Child = content.With(c =>
+            {
+                c.MainContent = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        thumbnail = new BeatmapCardThumbnail(BeatmapSet, BeatmapSet, keepLoaded: true)
+                        {
+                            Name = @"Left (icon) area",
+                            Size = new Vector2(HEIGHT),
+                            Padding = new MarginPadding { Right = CORNER_RADIUS },
+                            Child = leftIconArea = new FillFlowContainer
+                            {
+                                Margin = new MarginPadding(4),
+                                AutoSizeAxes = Axes.Both,
+                                Direction = FillDirection.Horizontal,
+                                Spacing = new Vector2(1)
+                            }
+                        },
+                        buttonContainer = new CollapsibleButtonContainer(BeatmapSet, allowNavigationToBeatmap: false, keepBackgroundLoaded: true)
+                        {
+                            X = HEIGHT - CORNER_RADIUS,
+                            Width = WIDTH - HEIGHT + CORNER_RADIUS,
+                            FavouriteState = { BindTarget = FavouriteState },
+                            ButtonsCollapsedWidth = 0,
+                            ButtonsExpandedWidth = 24,
+                            Children = new Drawable[]
+                            {
+                                new FillFlowContainer
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Direction = FillDirection.Vertical,
+                                    Children = new Drawable[]
+                                    {
+                                        new GridContainer
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+                                            AutoSizeAxes = Axes.Y,
+                                            ColumnDimensions = new[]
+                                            {
+                                                new Dimension(),
+                                                new Dimension(GridSizeMode.AutoSize),
+                                            },
+                                            RowDimensions = new[]
+                                            {
+                                                new Dimension(GridSizeMode.AutoSize)
+                                            },
+                                            Content = new[]
+                                            {
+                                                new Drawable[]
+                                                {
+                                                    new TruncatingSpriteText
+                                                    {
+                                                        Text = new RomanisableString(BeatmapSet.TitleUnicode, BeatmapSet.Title),
+                                                        Font = OsuFont.Default.With(size: 18f, weight: FontWeight.SemiBold),
+                                                        RelativeSizeAxes = Axes.X,
+                                                    },
+                                                    titleBadgeArea = new FillFlowContainer
+                                                    {
+                                                        Anchor = Anchor.BottomRight,
+                                                        Origin = Anchor.BottomRight,
+                                                        AutoSizeAxes = Axes.Both,
+                                                        Direction = FillDirection.Horizontal,
+                                                    }
+                                                }
+                                            }
+                                        },
+                                        artistContainer = new GridContainer
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+                                            AutoSizeAxes = Axes.Y,
+                                            ColumnDimensions = new[]
+                                            {
+                                                new Dimension(),
+                                                new Dimension(GridSizeMode.AutoSize)
+                                            },
+                                            RowDimensions = new[]
+                                            {
+                                                new Dimension(GridSizeMode.AutoSize)
+                                            },
+                                            Content = new[]
+                                            {
+                                                new[]
+                                                {
+                                                    new TruncatingSpriteText
+                                                    {
+                                                        Text = createArtistText(),
+                                                        Font = OsuFont.Default.With(size: 14f, weight: FontWeight.SemiBold),
+                                                        RelativeSizeAxes = Axes.X,
+                                                    },
+                                                    Empty()
+                                                },
+                                            }
+                                        },
+                                        new LinkFlowContainer(s =>
+                                        {
+                                            s.Shadow = false;
+                                            s.Font = OsuFont.GetFont(size: 11f, weight: FontWeight.SemiBold);
+                                        }).With(d =>
+                                        {
+                                            d.AutoSizeAxes = Axes.Both;
+                                            d.Margin = new MarginPadding { Top = 1 };
+                                            d.AddText("mapped by ", t => t.Colour = colourProvider.Content2);
+                                            d.AddUserLink(BeatmapSet.Author);
+                                        }),
+                                    }
+                                },
+                                new Container
+                                {
+                                    Name = @"Bottom content",
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Anchor = Anchor.BottomLeft,
+                                    Origin = Anchor.BottomLeft,
+                                    Children = new Drawable[]
+                                    {
+                                        idleBottomContent = new FillFlowContainer
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+                                            AutoSizeAxes = Axes.Y,
+                                            Direction = FillDirection.Vertical,
+                                            Spacing = new Vector2(0, 2),
+                                            AlwaysPresent = true,
+                                            Children = new Drawable[]
+                                            {
+                                                statisticsContainer = new FillFlowContainer<BeatmapCardStatistic>
+                                                {
+                                                    RelativeSizeAxes = Axes.X,
+                                                    AutoSizeAxes = Axes.Y,
+                                                    Direction = FillDirection.Horizontal,
+                                                    Spacing = new Vector2(8, 0),
+                                                    Alpha = 0,
+                                                    AlwaysPresent = true,
+                                                    ChildrenEnumerable = createStatistics()
+                                                },
+                                                new Container
+                                                {
+                                                    Masking = true,
+                                                    CornerRadius = CORNER_RADIUS,
+                                                    RelativeSizeAxes = Axes.X,
+                                                    AutoSizeAxes = Axes.Y,
+                                                    Children = new Drawable[]
+                                                    {
+                                                        new Box
+                                                        {
+                                                            Colour = colours.ForStarDifficulty(beatmap.StarRating).Darken(0.8f),
+                                                            RelativeSizeAxes = Axes.Both,
+                                                        },
+                                                        new FillFlowContainer
+                                                        {
+                                                            Padding = new MarginPadding(2),
+                                                            RelativeSizeAxes = Axes.X,
+                                                            AutoSizeAxes = Axes.Y,
+                                                            Direction = FillDirection.Horizontal,
+                                                            Spacing = new Vector2(4, 0),
+                                                            Children = new Drawable[]
+                                                            {
+                                                                new StarRatingDisplay(new StarDifficulty(beatmap.StarRating, 0), StarRatingDisplaySize.Small, animated: true)
+                                                                {
+                                                                    Origin = Anchor.CentreLeft,
+                                                                    Anchor = Anchor.CentreLeft,
+                                                                    Scale = new Vector2(0.875f),
+                                                                },
+                                                                new TruncatingSpriteText
+                                                                {
+                                                                    Text = beatmap.DifficultyName,
+                                                                    Font = OsuFont.Style.Caption2.With(weight: FontWeight.Bold),
+                                                                    Anchor = Anchor.CentreLeft,
+                                                                    Origin = Anchor.CentreLeft,
+                                                                }
+                                                            }
+                                                        },
+                                                    }
+                                                },
+                                            }
+                                        },
+                                        downloadProgressBar = new BeatmapCardDownloadProgressBar
+                                        {
+                                            RelativeSizeAxes = Axes.X,
+                                            Height = 5,
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            State = { BindTarget = DownloadTracker.State },
+                                            Progress = { BindTarget = DownloadTracker.Progress }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
+                c.Expanded.BindTarget = Expanded;
+            });
+
+            if (BeatmapSet.HasVideo)
+                leftIconArea.Add(new VideoIconPill { IconSize = new Vector2(16) });
+
+            if (BeatmapSet.HasStoryboard)
+                leftIconArea.Add(new StoryboardIconPill { IconSize = new Vector2(16) });
+
+            if (BeatmapSet.FeaturedInSpotlight)
+            {
+                titleBadgeArea.Add(new SpotlightBeatmapBadge
+                {
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.BottomRight,
+                    Margin = new MarginPadding { Left = 4 }
+                });
+            }
+
+            if (BeatmapSet.HasExplicitContent)
+            {
+                titleBadgeArea.Add(new ExplicitContentBeatmapBadge
+                {
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.BottomRight,
+                    Margin = new MarginPadding { Left = 4 }
+                });
+            }
+
+            if (BeatmapSet.TrackId != null)
+            {
+                artistContainer.Content[0][1] = new FeaturedArtistBeatmapBadge
+                {
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.BottomRight,
+                    Margin = new MarginPadding { Left = 4 }
+                };
+            }
+        }
+
+        private LocalisableString createArtistText()
+        {
+            var romanisableArtist = new RomanisableString(BeatmapSet.ArtistUnicode, BeatmapSet.Artist);
+            return BeatmapsetsStrings.ShowDetailsByArtist(romanisableArtist);
+        }
+
+        private IEnumerable<BeatmapCardStatistic> createStatistics()
+        {
+            var hypesStatistic = HypesStatistic.CreateFor(BeatmapSet);
+            if (hypesStatistic != null)
+                yield return hypesStatistic;
+
+            var nominationsStatistic = NominationsStatistic.CreateFor(BeatmapSet);
+            if (nominationsStatistic != null)
+                yield return nominationsStatistic;
+
+            yield return new FavouritesStatistic(BeatmapSet) { Current = FavouriteState };
+            yield return new PlayCountStatistic(BeatmapSet);
+
+            var dateStatistic = BeatmapCardDateStatistic.CreateFor(BeatmapSet);
+            if (dateStatistic != null)
+                yield return dateStatistic;
+        }
+
+        protected override void UpdateState()
+        {
+            base.UpdateState();
+
+            bool showDetails = IsHovered;
+
+            buttonContainer.ShowDetails.Value = showDetails;
+            thumbnail.Dimmed.Value = showDetails;
+
+            statisticsContainer.FadeTo(showDetails ? 1 : 0, TRANSITION_DURATION, Easing.OutQuint);
+        }
+
+        public override MenuItem[] ContextMenuItems
+        {
+            get
+            {
+                var items = base.ContextMenuItems.ToList();
+
+                foreach (var button in buttonContainer.Buttons)
+                {
+                    if (button.Enabled.Value)
+                        items.Add(new OsuMenuItem(button.TooltipText.ToSentence(), MenuItemType.Standard, () => button.TriggerClick()));
+                }
+
+                return items.ToArray();
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/BeatmapSelectGrid.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/BeatmapSelectGrid.cs
new file mode 100644
index 0000000000..4d19890993
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/BeatmapSelectGrid.cs
@@ -0,0 +1,377 @@
+// 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.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
+using Microsoft.Toolkit.HighPerformance;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Transforms;
+using osu.Framework.Utils;
+using osu.Game.Graphics.Containers;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Rooms;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect
+{
+    public partial class BeatmapSelectGrid : CompositeDrawable
+    {
+        public const double ARRANGE_DELAY = 200;
+
+        private const double hide_duration = 800;
+        private const double arrange_duration = 1000;
+        private const double roll_duration = 4000;
+        private const double present_beatmap_delay = 1200;
+        private const float panel_spacing = 4;
+
+        public event Action<MultiplayerPlaylistItem>? ItemSelected;
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        private readonly Dictionary<long, BeatmapSelectPanel> panelLookup = new Dictionary<long, BeatmapSelectPanel>();
+
+        private readonly PanelGridContainer panelGridContainer;
+        private readonly Container<BeatmapSelectPanel> rollContainer;
+        private readonly OsuScrollContainer scroll;
+
+        private bool allowSelection = true;
+
+        private readonly Sample?[] spinSamples = new Sample?[5];
+        private static readonly int[] spin_sample_sequence = [0, 1, 2, 3, 4, 2, 3, 4];
+        private Sample? resultSample;
+        private Sample? swooshSample;
+        private double? lastSamplePlayback;
+
+        public BeatmapSelectGrid()
+        {
+            InternalChildren = new Drawable[]
+            {
+                scroll = new OsuScrollContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    ScrollbarVisible = false,
+                    Child = panelGridContainer = new PanelGridContainer
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Padding = new MarginPadding(20),
+                        Spacing = new Vector2(panel_spacing)
+                    },
+                },
+                rollContainer = new Container<BeatmapSelectPanel>
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            for (int i = 0; i < spinSamples.Length; i++)
+                spinSamples[i] = audio.Samples.Get($@"Multiplayer/Matchmaking/Selection/roulette-{i}");
+
+            resultSample = audio.Samples.Get(@"Multiplayer/Matchmaking/Selection/roulette-result");
+            swooshSample = audio.Samples.Get(@"SongSelect/options-pop-out");
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            const double enter_duration = 500;
+
+            // the scroll container has a 1 frame delay until it receives the correct height for the scrollable area which leads to the scrollbar resizing awkwardly
+            // if we wait until the panels have entered we get to avoid having to see that and the scrollbar it will appear synchronized with the rest of the content as a bonus
+            Scheduler.AddDelayed(() => scroll.ScrollbarVisible = true, enter_duration);
+
+            SchedulerAfterChildren.Add(() =>
+            {
+                foreach (var panel in panelGridContainer)
+                {
+                    double delay = panel.Y / 3;
+
+                    panel.FadeInAndEnterFromBelow(duration: enter_duration, delay: delay);
+                }
+            });
+        }
+
+        public void AddItem(MultiplayerPlaylistItem item)
+        {
+            var panel = panelLookup[item.ID] = new BeatmapSelectPanel(item)
+            {
+                AllowSelection = allowSelection,
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre,
+                Action = ItemSelected,
+            };
+
+            panelGridContainer.Add(panel);
+            panelGridContainer.SetLayoutPosition(panel, (float)item.StarRating);
+        }
+
+        public void RemoveItem(long id)
+        {
+            if (!panelLookup.Remove(id, out var panel))
+                return;
+
+            panel.Expire();
+        }
+
+        public void SetUserSelection(APIUser user, long itemId, bool selected)
+        {
+            if (!panelLookup.TryGetValue(itemId, out var panel))
+                return;
+
+            if (selected)
+                panel.AddUser(user, user.Equals(api.LocalUser.Value));
+            else
+                panel.RemoveUser(user);
+        }
+
+        public void RollAndDisplayFinalBeatmap(long[] candidateItemIds, long finalItemId)
+        {
+            Debug.Assert(candidateItemIds.Length >= 1);
+            Debug.Assert(candidateItemIds.Contains(finalItemId));
+            Debug.Assert(panelLookup.ContainsKey(finalItemId));
+            Debug.Assert(candidateItemIds.All(id => panelLookup.ContainsKey(id)));
+
+            allowSelection = false;
+
+            TransferCandidatePanelsToRollContainer(candidateItemIds);
+
+            if (candidateItemIds.Length == 1)
+            {
+                this.Delay(ARRANGE_DELAY)
+                    .Schedule(() => ArrangeItemsForRollAnimation())
+                    .Delay(arrange_duration + present_beatmap_delay)
+                    .Schedule(() => PresentUnanimouslyChosenBeatmap(finalItemId));
+            }
+            else
+            {
+                this.Delay(ARRANGE_DELAY)
+                    .Schedule(() => ArrangeItemsForRollAnimation())
+                    .Delay(arrange_duration)
+                    .Schedule(() => PlayRollAnimation(finalItemId, roll_duration))
+                    .Delay(roll_duration + present_beatmap_delay)
+                    .Schedule(() => PresentRolledBeatmap(finalItemId));
+            }
+        }
+
+        internal void TransferCandidatePanelsToRollContainer(long[] candidateItemIds, double duration = hide_duration)
+        {
+            scroll.ScrollbarVisible = false;
+            panelGridContainer.LayoutDisabled = true;
+
+            var rng = new Random();
+
+            var remainingPanels = new List<BeatmapSelectPanel>();
+
+            foreach (var panel in panelGridContainer.Children.ToArray())
+            {
+                panel.AllowSelection = false;
+
+                if (!candidateItemIds.Contains(panel.Item.ID))
+                {
+                    panel.PopOutAndExpire(duration: duration / 2, delay: rng.NextDouble() * duration / 2);
+                    continue;
+                }
+
+                remainingPanels.Add(panel);
+            }
+
+            rng.Shuffle(remainingPanels.AsSpan());
+
+            foreach (var panel in remainingPanels)
+            {
+                var position = panel.ScreenSpaceDrawQuad.Centre;
+
+                panelGridContainer.Remove(panel, false);
+
+                panel.Anchor = panel.Origin = Anchor.Centre;
+                panel.Position = rollContainer.ToLocalSpace(position) - rollContainer.ChildSize / 2;
+
+                rollContainer.Add(panel);
+            }
+        }
+
+        internal void ArrangeItemsForRollAnimation(double duration = arrange_duration, double stagger = 30)
+        {
+            var positions = calculateLayoutPositionsForRollAnimation(rollContainer.Children.Count);
+
+            Debug.Assert(positions.Length == rollContainer.Children.Count);
+
+            for (int i = 0; i < positions.Length; i++)
+            {
+                var panel = rollContainer.Children[i];
+
+                var position = positions[i] * (BeatmapSelectPanel.SIZE + new Vector2(panel_spacing));
+
+                panel.MoveTo(position, duration + stagger * i, new SplitEasingFunction(Easing.InCubic, Easing.OutExpo, 0.3f));
+
+                Scheduler.AddDelayed(() =>
+                {
+                    var chan = swooshSample?.GetChannel();
+                    if (chan == null) return;
+
+                    chan.Frequency.Value = 1.25f - RNG.NextDouble(0.5f);
+                    chan.Play();
+                }, stagger * i);
+            }
+        }
+
+        private static Vector2[] calculateLayoutPositionsForRollAnimation(int panelCount)
+        {
+            if (panelCount == 1)
+                return new[] { Vector2.Zero };
+
+            // goal is to get the positions arranged in clockwise order, with the top-left position being the first one
+            // to keep things simple the positions are first inserted in the order: right row, optional bottom center panel, left row backwards
+            // then the positions get shifted by 1 to move the top-left position into the first spot
+
+            bool hasCenterPanel = panelCount % 2 == 1;
+            int rowCount = (panelCount + 1) / 2;
+            int outerRowCount = hasCenterPanel ? rowCount - 1 : rowCount;
+
+            float yOffset = -(rowCount - 1f) / 2;
+
+            var positions = new Vector2[panelCount];
+
+            for (int row = 0; row < outerRowCount; row++)
+            {
+                positions[row] = new Vector2(0.5f, row + yOffset);
+            }
+
+            if (hasCenterPanel)
+            {
+                int centerIndex = panelCount / 2;
+
+                positions[centerIndex] = new Vector2(0, outerRowCount + yOffset);
+            }
+
+            for (int row = 0; row < outerRowCount; row++)
+            {
+                int index = positions.Length - 1 - row;
+
+                positions[index] = new Vector2(-0.5f, row + yOffset);
+            }
+
+            return positions.TakeLast(1).Concat(positions.SkipLast(1)).ToArray();
+        }
+
+        internal void PlayRollAnimation(long finalItem, double duration = roll_duration)
+        {
+            const int minimum_steps = 20;
+
+            int finalItemIndex = rollContainer.Children
+                                              .Select(it => it.Item.ID)
+                                              .ToImmutableList()
+                                              .IndexOf(finalItem);
+
+            Debug.Assert(finalItemIndex >= 0);
+
+            int numSteps = minimum_steps;
+            while ((numSteps - 1) % rollContainer.Children.Count != finalItemIndex)
+                numSteps++;
+
+            BeatmapSelectPanel? lastPanel = null;
+
+            for (int i = 0; i < numSteps; i++)
+            {
+                float progress = ((float)i) / (numSteps - 1);
+
+                double delay = Math.Pow(progress, 2.5) * duration;
+                var panel = rollContainer.Children[i % rollContainer.Children.Count];
+
+                int ii = i;
+                Scheduler.AddDelayed(() =>
+                {
+                    lastPanel?.HideBorder();
+                    panel.ShowBorder();
+
+                    if (lastSamplePlayback == null || Time.Current - lastSamplePlayback > OsuGameBase.SAMPLE_DEBOUNCE_TIME)
+                    {
+                        int sequenceIdx = ii % spin_sample_sequence.Length;
+                        spinSamples[spin_sample_sequence[sequenceIdx]]?.Play();
+                        lastSamplePlayback = Time.Current;
+                    }
+
+                    lastPanel = panel;
+                }, delay);
+            }
+        }
+
+        internal void PresentRolledBeatmap(long finalItem)
+        {
+            Debug.Assert(rollContainer.Children.Any(it => it.Item.ID == finalItem));
+
+            foreach (var panel in rollContainer.Children)
+            {
+                if (panel.Item.ID != finalItem)
+                {
+                    panel.FadeOut(200);
+                    panel.PopOutAndExpire(easing: Easing.InQuad);
+                    continue;
+                }
+
+                // if we changed child depth without scheduling we'd change the order of the panels while iterating
+                Schedule(() =>
+                {
+                    rollContainer.ChangeChildDepth(panel, float.MinValue);
+
+                    panel.ShowChosenBorder();
+                    panel.MoveTo(Vector2.Zero, 1000, Easing.OutExpo)
+                         .ScaleTo(1.5f, 1000, Easing.OutExpo);
+
+                    resultSample?.Play();
+                });
+            }
+        }
+
+        internal void PresentUnanimouslyChosenBeatmap(long finalItem)
+        {
+            // TODO: display special animation in this case
+
+            PresentRolledBeatmap(finalItem);
+        }
+
+        private partial class PanelGridContainer : FillFlowContainer<BeatmapSelectPanel>
+        {
+            public bool LayoutDisabled;
+
+            protected override IEnumerable<Vector2> ComputeLayoutPositions()
+            {
+                if (LayoutDisabled)
+                    return FlowingChildren.Select(c => c.Position);
+
+                return base.ComputeLayoutPositions();
+            }
+        }
+
+        private readonly struct SplitEasingFunction(DefaultEasingFunction easeIn, DefaultEasingFunction easeOut, float ratio) : IEasingFunction
+        {
+            public SplitEasingFunction(Easing easeIn, Easing easeOut, float ratio = 0.5f)
+                : this(new DefaultEasingFunction(easeIn), new DefaultEasingFunction(easeOut), ratio)
+            {
+            }
+
+            public double ApplyEasing(double time)
+            {
+                if (time < ratio)
+                    return easeIn.ApplyEasing(time / ratio) * ratio;
+
+                return double.Lerp(ratio, 1, easeOut.ApplyEasing((time - ratio) / (1 - ratio)));
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/BeatmapSelectPanel.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/BeatmapSelectPanel.cs
new file mode 100644
index 0000000000..3266e39905
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/BeatmapSelectPanel.cs
@@ -0,0 +1,341 @@
+// 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.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Game.Beatmaps.Drawables.Cards;
+using osu.Game.Database;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect
+{
+    public partial class BeatmapSelectPanel : Container
+    {
+        public static readonly Vector2 SIZE = new Vector2(BeatmapCard.WIDTH, BeatmapCardNormal.HEIGHT);
+
+        public bool AllowSelection { get; set; }
+
+        public readonly MultiplayerPlaylistItem Item;
+
+        public Action<MultiplayerPlaylistItem>? Action { private get; init; }
+
+        private const float border_width = 3;
+
+        private Container scaleContainer = null!;
+        private AvatarOverlay selectionOverlay = null!;
+        private Drawable lighting = null!;
+
+        private Container border = null!;
+        private Container mainContent = null!;
+
+        public override bool PropagatePositionalInputSubTree => AllowSelection;
+
+        public BeatmapSelectPanel(MultiplayerPlaylistItem item)
+        {
+            Item = item;
+            Size = SIZE;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(BeatmapLookupCache lookupCache, OverlayColourProvider colourProvider)
+        {
+            InternalChild = scaleContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Children = new[]
+                {
+                    mainContent = new Container
+                    {
+                        Masking = true,
+                        CornerRadius = BeatmapCard.CORNER_RADIUS,
+                        CornerExponent = 10,
+                        RelativeSizeAxes = Axes.Both,
+                        Children = new[]
+                        {
+                            lighting = new Box
+                            {
+                                Blending = BlendingParameters.Additive,
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0,
+                            },
+                            selectionOverlay = new AvatarOverlay
+                            {
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.TopRight,
+                            }
+                        }
+                    },
+                    border = new Container
+                    {
+                        Alpha = 0,
+                        Masking = true,
+                        CornerRadius = BeatmapCard.CORNER_RADIUS,
+                        CornerExponent = 10,
+                        Blending = BlendingParameters.Additive,
+                        RelativeSizeAxes = Axes.Both,
+                        BorderThickness = border_width,
+                        BorderColour = colourProvider.Light1,
+                        EdgeEffect = new EdgeEffectParameters
+                        {
+                            Type = EdgeEffectType.Glow,
+                            Radius = 40,
+                            Roundness = 300,
+                            Colour = colourProvider.Light3.Opacity(0.1f),
+                        },
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                AlwaysPresent = true,
+                                Alpha = 0,
+                                Colour = Color4.Black,
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                        }
+                    },
+                }
+            };
+            lookupCache.GetBeatmapAsync(Item.BeatmapID).ContinueWith(b => Schedule(() =>
+            {
+                var beatmap = b.GetResultSafely()!;
+                beatmap.StarRating = Item.StarRating;
+
+                mainContent.Add(new BeatmapCardMatchmaking(beatmap)
+                {
+                    Depth = float.MaxValue,
+                    Action = () => Action?.Invoke(Item),
+                });
+            }));
+        }
+
+        public bool AddUser(APIUser user, bool isOwnUser = false) => selectionOverlay.AddUser(user, isOwnUser);
+        public bool RemoveUser(APIUser user) => selectionOverlay.RemoveUser(user.Id);
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            lighting.FadeTo(0.2f, 50)
+                    .Then()
+                    .FadeTo(0.1f, 300);
+
+            return true;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            base.OnHoverLost(e);
+
+            lighting.FadeOut(200);
+        }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            if (e.Button == MouseButton.Left)
+            {
+                scaleContainer.ScaleTo(0.95f, 400, Easing.OutExpo);
+                return true;
+            }
+
+            return base.OnMouseDown(e);
+        }
+
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            base.OnMouseUp(e);
+
+            if (e.Button == MouseButton.Left)
+            {
+                scaleContainer.ScaleTo(1f, 500, Easing.OutElasticHalf);
+            }
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            lighting.FadeTo(0.5f, 50)
+                    .Then()
+                    .FadeTo(0.1f, 400);
+
+            // pass through to let the beatmap card handle actual click.
+            return false;
+        }
+
+        public void ShowChosenBorder()
+        {
+            border.FadeTo(1, 1000, Easing.OutQuint);
+        }
+
+        public void ShowBorder()
+        {
+            border.FadeTo(1, 80, Easing.OutQuint)
+                  .Then()
+                  .FadeTo(0.7f, 800, Easing.OutQuint);
+        }
+
+        public void HideBorder()
+        {
+            border.FadeOut(500, Easing.OutQuint);
+        }
+
+        public void FadeInAndEnterFromBelow(double duration = 500, double delay = 0, float distance = 200)
+        {
+            scaleContainer
+                .FadeOut()
+                .MoveToY(distance)
+                .Delay(delay)
+                .FadeIn(duration / 2)
+                .MoveToY(0, duration, Easing.OutExpo);
+        }
+
+        public void PopOutAndExpire(double duration = 400, double delay = 0, Easing easing = Easing.InCubic)
+        {
+            AllowSelection = false;
+
+            scaleContainer.Delay(delay)
+                          .ScaleTo(0, duration, easing)
+                          .FadeOut(duration);
+
+            this.Delay(delay + duration).FadeOut().Expire();
+        }
+
+        private partial class AvatarOverlay : CompositeDrawable
+        {
+            private readonly Container<SelectionAvatar> avatars;
+
+            private Sample? userAddedSample;
+            private double? lastSamplePlayback;
+
+            public AvatarOverlay()
+            {
+                AutoSizeAxes = Axes.Both;
+
+                InternalChild = avatars = new Container<SelectionAvatar>
+                {
+                    AutoSizeAxes = Axes.X,
+                    Height = SelectionAvatar.AVATAR_SIZE,
+                };
+
+                Padding = new MarginPadding(5);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(AudioManager audio)
+            {
+                userAddedSample = audio.Samples.Get(@"Multiplayer/player-ready");
+            }
+
+            public bool AddUser(APIUser user, bool isOwnUser)
+            {
+                if (avatars.Any(a => a.User.Id == user.Id))
+                    return false;
+
+                var avatar = new SelectionAvatar(user, isOwnUser);
+
+                avatars.Add(avatar);
+
+                if (lastSamplePlayback == null || Time.Current - lastSamplePlayback > OsuGameBase.SAMPLE_DEBOUNCE_TIME)
+                {
+                    userAddedSample?.Play();
+                    lastSamplePlayback = Time.Current;
+                }
+
+                updateAvatarLayout();
+
+                avatar.FinishTransforms();
+
+                return true;
+            }
+
+            public bool RemoveUser(int id)
+            {
+                if (avatars.SingleOrDefault(a => a.User.Id == id) is not SelectionAvatar avatar)
+                    return false;
+
+                avatar.PopOutAndExpire();
+                avatars.ChangeChildDepth(avatar, float.MaxValue);
+
+                updateAvatarLayout();
+
+                return true;
+            }
+
+            private void updateAvatarLayout()
+            {
+                const double stagger = 30;
+                const float spacing = 4;
+
+                double delay = 0;
+                float x = 0;
+
+                for (int i = avatars.Count - 1; i >= 0; i--)
+                {
+                    var avatar = avatars[i];
+
+                    if (avatar.Expired)
+                        continue;
+
+                    avatar.Delay(delay).MoveToX(x, 500, Easing.OutElasticQuarter);
+
+                    x -= avatar.LayoutSize.X + spacing;
+
+                    delay += stagger;
+                }
+            }
+
+            public partial class SelectionAvatar : CompositeDrawable
+            {
+                public const float AVATAR_SIZE = 30;
+
+                public APIUser User { get; }
+
+                public bool Expired { get; private set; }
+
+                private readonly MatchmakingAvatar avatar;
+
+                public SelectionAvatar(APIUser user, bool isOwnUser)
+                {
+                    User = user;
+                    Size = new Vector2(AVATAR_SIZE);
+
+                    InternalChild = avatar = new MatchmakingAvatar(user, isOwnUser)
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    };
+                }
+
+                protected override void LoadComplete()
+                {
+                    base.LoadComplete();
+
+                    avatar.ScaleTo(0)
+                          .ScaleTo(1, 500, Easing.OutElasticHalf)
+                          .FadeIn(200);
+                }
+
+                public void PopOutAndExpire()
+                {
+                    avatar.ScaleTo(0, 400, Easing.OutExpo);
+
+                    this.FadeOut(100).Expire();
+                    Expired = true;
+                }
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/SubScreenBeatmapSelect.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/SubScreenBeatmapSelect.cs
new file mode 100644
index 0000000000..4b34125517
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/BeatmapSelect/SubScreenBeatmapSelect.cs
@@ -0,0 +1,97 @@
+// 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;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect
+{
+    public partial class SubScreenBeatmapSelect : MatchmakingSubScreen
+    {
+        public override PanelDisplayStyle PlayersDisplayStyle => PanelDisplayStyle.Split;
+        public override Drawable PlayersDisplayArea { get; }
+
+        private readonly BeatmapSelectGrid beatmapSelectGrid;
+
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        public SubScreenBeatmapSelect()
+        {
+            InternalChildren = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Horizontal = 200 },
+                    Child = beatmapSelectGrid = new BeatmapSelectGrid
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = PlayersDisplayArea = new Container().With(d =>
+                    {
+                        d.RelativeSizeAxes = Axes.Both;
+                    })
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            client.ItemAdded += onItemAdded;
+
+            foreach (var item in client.Room!.Playlist)
+                onItemAdded(item);
+
+            beatmapSelectGrid.ItemSelected += item => client.MatchmakingToggleSelection(item.ID);
+
+            client.MatchmakingItemSelected += onItemSelected;
+            client.MatchmakingItemDeselected += onItemDeselected;
+        }
+
+        private void onItemAdded(MultiplayerPlaylistItem item) => Scheduler.Add(() =>
+        {
+            if (item.Expired)
+                return;
+
+            beatmapSelectGrid.AddItem(item);
+        });
+
+        private void onItemSelected(int userId, long itemId)
+        {
+            var user = client.Room!.Users.First(it => it.UserID == userId).User!;
+            beatmapSelectGrid.SetUserSelection(user, itemId, true);
+        }
+
+        private void onItemDeselected(int userId, long itemId)
+        {
+            var user = client.Room!.Users.First(it => it.UserID == userId).User!;
+            beatmapSelectGrid.SetUserSelection(user, itemId, false);
+        }
+
+        public void RollFinalBeatmap(long[] candidateItems, long finalItem) => beatmapSelectGrid.RollAndDisplayFinalBeatmap(candidateItems, finalItem);
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+            {
+                client.ItemAdded -= onItemAdded;
+                client.MatchmakingItemSelected -= onItemSelected;
+                client.MatchmakingItemDeselected -= onItemDeselected;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Gameplay/ScreenGameplay.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Gameplay/ScreenGameplay.cs
new file mode 100644
index 0000000000..f6f324eb90
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Gameplay/ScreenGameplay.cs
@@ -0,0 +1,31 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Threading.Tasks;
+using osu.Framework.Screens;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Scoring;
+using osu.Game.Screens.OnlinePlay.Multiplayer;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.Gameplay
+{
+    public partial class ScreenGameplay : MultiplayerPlayer
+    {
+        public ScreenGameplay(Room room, PlaylistItem playlistItem, MultiplayerRoomUser[] users)
+            : base(room, playlistItem, users)
+        {
+        }
+
+        protected override async Task PrepareScoreForResultsAsync(Score score)
+        {
+            await base.PrepareScoreForResultsAsync(score).ConfigureAwait(false);
+
+            Scheduler.Add(() =>
+            {
+                if (this.IsCurrentScreen())
+                    this.Exit();
+            });
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/MatchmakingAvatar.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/MatchmakingAvatar.cs
new file mode 100644
index 0000000000..53db2114c7
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/MatchmakingAvatar.cs
@@ -0,0 +1,72 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Users.Drawables;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    /// <summary>
+    /// A circular player avatar used in matchmaking displays.
+    /// Is part of a <see cref="PlayerPanel"/> but can also be used in isolation for a more ambient/decorative user display.
+    /// </summary>
+    public partial class MatchmakingAvatar : CompositeDrawable
+    {
+        public static readonly Vector2 SIZE = new Vector2(30);
+
+        private readonly APIUser user;
+        private readonly bool isOwnUser;
+
+        public MatchmakingAvatar(APIUser user, bool isOwnUser = false)
+        {
+            this.user = user;
+            this.isOwnUser = isOwnUser;
+
+            Size = SIZE;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colour)
+        {
+            if (isOwnUser)
+            {
+                AddInternal(new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = float.MaxValue,
+                    Padding = new MarginPadding(-2),
+                    Child = new FastCircle
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = colour.Yellow,
+                    }
+                });
+            }
+
+            AddInternal(new CircularContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Masking = true,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.LightSlateGray,
+                    },
+                    new ClickableAvatar(user, true)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    }
+                }
+            });
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/MatchmakingChatDisplay.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/MatchmakingChatDisplay.cs
new file mode 100644
index 0000000000..4ff6a3cdf6
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/MatchmakingChatDisplay.cs
@@ -0,0 +1,70 @@
+// 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.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Game.Input;
+using osu.Game.Input.Bindings;
+using osu.Game.Online.Rooms;
+using osu.Game.Resources.Localisation.Web;
+using osu.Game.Screens.OnlinePlay.Match.Components;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    public partial class MatchmakingChatDisplay : MatchChatDisplay, IKeyBindingHandler<GlobalAction>
+    {
+        protected new ChatTextBox TextBox => base.TextBox!;
+
+        public MatchmakingChatDisplay(Room room, bool leaveChannelOnDispose = true)
+            : base(room, leaveChannelOnDispose)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(RealmKeyBindingStore keyBindingStore)
+        {
+            resetPlaceholderText();
+
+            TextBox.HoldFocus = false;
+            TextBox.ReleaseFocusOnCommit = true;
+            TextBox.Focus = () => TextBox.PlaceholderText = ChatStrings.InputPlaceholder;
+            TextBox.FocusLost = resetPlaceholderText;
+
+            void resetPlaceholderText() => TextBox.PlaceholderText = Localisation.ChatStrings.InGameInputPlaceholder(keyBindingStore.GetBindingsStringFor(GlobalAction.ToggleChatFocus));
+        }
+
+        public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+        {
+            switch (e.Action)
+            {
+                case GlobalAction.Back:
+                    if (TextBox.HasFocus)
+                    {
+                        Schedule(() => TextBox.KillFocus());
+                        return true;
+                    }
+
+                    break;
+
+                case GlobalAction.ToggleChatFocus:
+                    if (TextBox.HasFocus)
+                    {
+                        Schedule(() => TextBox.KillFocus());
+                    }
+                    else
+                    {
+                        Schedule(() => TextBox.TakeFocus());
+                    }
+
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+        {
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/MatchmakingSubScreen.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/MatchmakingSubScreen.cs
new file mode 100644
index 0000000000..0141c424bd
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/MatchmakingSubScreen.cs
@@ -0,0 +1,46 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    public abstract partial class MatchmakingSubScreen : Screen
+    {
+        public abstract PanelDisplayStyle PlayersDisplayStyle { get; }
+        public abstract Drawable? PlayersDisplayArea { get; }
+
+        protected MatchmakingSubScreen()
+        {
+            RelativePositionAxes = Axes.X;
+        }
+
+        public override void OnEntering(ScreenTransitionEvent e)
+        {
+            base.OnEntering(e);
+            this.FadeInFromZero(200);
+        }
+
+        public override void OnSuspending(ScreenTransitionEvent e)
+        {
+            base.OnSuspending(e);
+            this.FadeOutFromOne(200);
+        }
+
+        public override void OnResuming(ScreenTransitionEvent e)
+        {
+            base.OnResuming(e);
+            this.FadeInFromZero(200);
+        }
+
+        public override bool OnExiting(ScreenExitEvent e)
+        {
+            if (base.OnExiting(e))
+                return true;
+
+            this.FadeOutFromOne(200);
+            return false;
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/PlayerPanel.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/PlayerPanel.cs
new file mode 100644
index 0000000000..2f543d9950
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/PlayerPanel.cs
@@ -0,0 +1,256 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API;
+using osu.Game.Online.Matchmaking.Events;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    /// <summary>
+    /// A panel used throughout matchmaking to represent a user, including local information like their
+    /// rank and high level statistics in the matchmaking system.
+    /// </summary>
+    public partial class PlayerPanel : UserPanel
+    {
+        public static readonly Vector2 SIZE_HORIZONTAL = new Vector2(250, 100);
+        public static readonly Vector2 SIZE_VERTICAL = new Vector2(150, 200);
+        private static readonly Vector2 avatar_size = new Vector2(80);
+
+        public readonly MultiplayerRoomUser RoomUser;
+
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        private OsuSpriteText rankText = null!;
+        private OsuSpriteText scoreText = null!;
+
+        private Drawable avatarPositionTarget = null!;
+        private Drawable avatarJumpTarget = null!;
+        private MatchmakingAvatar avatar = null!;
+        private OsuSpriteText username = null!;
+
+        private Container scaleContainer = null!;
+        private Container mainContent = null!;
+
+        public bool Horizontal
+        {
+            get => horizontal;
+            set
+            {
+                horizontal = value;
+                if (IsLoaded)
+                    updateLayout(false);
+            }
+        }
+
+        private bool horizontal;
+
+        public PlayerPanel(MultiplayerRoomUser user)
+            : base(user.User!)
+        {
+            RoomUser = user;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Masking = true;
+            CornerRadius = 10;
+            CornerExponent = 10;
+
+            Add(scaleContainer = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                Child = mainContent = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new[]
+                    {
+                        avatarPositionTarget = new Container
+                        {
+                            Origin = Anchor.Centre,
+                            Size = avatar_size,
+                            Child = avatarJumpTarget = new Container
+                            {
+                                Anchor = Anchor.BottomCentre,
+                                Origin = Anchor.BottomCentre,
+                                RelativeSizeAxes = Axes.Both,
+                                Child = avatar = new MatchmakingAvatar(User, isOwnUser: User.Id == api.LocalUser.Value.Id)
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Size = Vector2.One
+                                }
+                            }
+                        },
+                        rankText = new OsuSpriteText
+                        {
+                            Anchor = Anchor.BottomRight,
+                            Origin = Anchor.BottomCentre,
+                            Blending = BlendingParameters.Additive,
+                            Margin = new MarginPadding(4),
+                            Font = OsuFont.Style.Title.With(size: 70),
+                        },
+                        username = new OsuSpriteText
+                        {
+                            Anchor = Anchor.BottomCentre,
+                            Origin = Anchor.BottomCentre,
+                            Text = User.Username,
+                            Font = OsuFont.Style.Heading1,
+                        },
+                        scoreText = new OsuSpriteText
+                        {
+                            Margin = new MarginPadding(10),
+                            Anchor = Anchor.BottomCentre,
+                            Origin = Anchor.BottomCentre,
+                            Font = OsuFont.Style.Heading2,
+                            Text = "0 pts"
+                        }
+                    }
+                }
+            });
+        }
+
+        protected override Drawable CreateLayout() => Empty();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            updateLayout(true);
+
+            client.MatchRoomStateChanged += onRoomStateChanged;
+            client.MatchEvent += onMatchEvent;
+
+            onRoomStateChanged(client.Room!.MatchState);
+
+            avatar.ScaleTo(0)
+                  .ScaleTo(1, 500, Easing.OutElasticHalf)
+                  .FadeIn(200);
+
+            rankText.Hide();
+            scoreText.Hide();
+            username.Hide();
+
+            using (BeginDelayedSequence(100))
+            {
+                username.FadeInFromZero(600);
+
+                using (BeginDelayedSequence(100))
+                {
+                    scoreText.FadeInFromZero(600);
+
+                    using (BeginDelayedSequence(100))
+                    {
+                        rankText.FadeTo(0.6f, 600);
+                    }
+                }
+            }
+        }
+
+        private Vector2 avatarPosition => horizontal ? new Vector2(50) : new Vector2(75, 50);
+
+        private void updateLayout(bool instant)
+        {
+            double duration = instant ? 0 : 1000;
+
+            avatarPositionTarget.MoveTo(avatarPosition, duration, Easing.OutPow10);
+            this.ResizeTo(horizontal ? SIZE_HORIZONTAL : SIZE_VERTICAL, duration, Easing.OutPow10);
+
+            rankText.MoveTo(horizontal ? new Vector2(-40, -10) : new Vector2(-70, 0), duration, Easing.OutPow10);
+            username.MoveTo(horizontal ? new Vector2(0, -46) : new Vector2(0, -86), duration, Easing.OutPow10);
+            scoreText.MoveTo(horizontal ? new Vector2(0, -16) : new Vector2(0, -56), duration, Easing.OutPow10);
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            scaleContainer.ScaleTo(1.03f, 750, Easing.OutPow10);
+            mainContent.ScaleTo(1.03f, 750, Easing.OutPow10);
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            scaleContainer.ScaleTo(1f, 750, Easing.OutPow10);
+            mainContent.ScaleTo(1, 750, Easing.OutPow10);
+
+            mainContent.MoveTo(Vector2.Zero, 1250, Easing.OutPow10);
+            avatarPositionTarget.MoveTo(avatarPosition, 1250, Easing.OutPow10);
+            base.OnHoverLost(e);
+        }
+
+        protected override bool OnMouseMove(MouseMoveEvent e)
+        {
+            var offset = (avatarPositionTarget.ToLocalSpace(e.ScreenSpaceMousePosition) - avatarPositionTarget.DrawSize / 2) * 0.02f;
+
+            mainContent.MoveTo(offset * 0.5f, 1000, Easing.OutPow10);
+            avatarPositionTarget.MoveTo(avatarPosition + offset, 400, Easing.OutPow10);
+            return base.OnMouseMove(e);
+        }
+
+        private void onRoomStateChanged(MatchRoomState? state) => Scheduler.Add(() =>
+        {
+            if (state is not MatchmakingRoomState matchmakingState)
+                return;
+
+            if (!matchmakingState.Users.UserDictionary.TryGetValue(User.Id, out MatchmakingUser? userScore))
+                return;
+
+            rankText.Text = $"#{userScore.Placement}";
+            scoreText.Text = $"{userScore.Points} pts";
+        });
+
+        private void onMatchEvent(MatchServerEvent e)
+        {
+            switch (e)
+            {
+                case MatchmakingAvatarActionEvent action:
+                    if (action.UserId != RoomUser.UserID)
+                        break;
+
+                    switch (action.Action)
+                    {
+                        case MatchmakingAvatarAction.Jump:
+                            avatarJumpTarget.MoveToY(-10, 200, Easing.Out)
+                                            .Then().MoveToY(0, 200, Easing.In);
+                            avatarJumpTarget.ScaleTo(new Vector2(1, 1.05f), 200, Easing.Out)
+                                            .Then().ScaleTo(new Vector2(1, 0.95f), 200, Easing.In)
+                                            .Then().ScaleTo(Vector2.One, 800, Easing.OutElastic);
+                            break;
+                    }
+
+                    break;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+            {
+                client.MatchRoomStateChanged -= onRoomStateChanged;
+                client.MatchEvent -= onMatchEvent;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/PlayerPanelOverlay.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/PlayerPanelOverlay.cs
new file mode 100644
index 0000000000..ba6021469f
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/PlayerPanelOverlay.cs
@@ -0,0 +1,313 @@
+// 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.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Utils;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    /// <summary>
+    /// A component which maintains the layout of the players in a matchmaking room.
+    /// Can be controlled to display the panels in a certain location and in multiple styles.
+    /// </summary>
+    public partial class PlayerPanelOverlay : CompositeDrawable
+    {
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        private Container<PlayerPanel> panels = null!;
+        private PlayerPanelCellContainer gridLayout = null!;
+        private PlayerPanelCellContainer splitLayoutLeft = null!;
+        private PlayerPanelCellContainer splitLayoutRight = null!;
+
+        private PanelDisplayStyle displayStyle;
+        private Drawable? displayArea;
+        private bool isAnimatingToDisplayArea;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
+            {
+                gridLayout = new PlayerPanelCellContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Spacing = new Vector2(20),
+                },
+                splitLayoutLeft = new PlayerPanelCellContainer
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    RelativeSizeAxes = Axes.Y,
+                    AutoSizeAxes = Axes.X,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(5),
+                },
+                splitLayoutRight = new PlayerPanelCellContainer
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    RelativeSizeAxes = Axes.Y,
+                    AutoSizeAxes = Axes.X,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(5),
+                },
+                panels = new Container<PlayerPanel>
+                {
+                    RelativeSizeAxes = Axes.Both
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            // Set position/size so we don't initially animate.
+            Position = getFinalPosition();
+            Size = getFinalSize();
+
+            client.MatchRoomStateChanged += onRoomStateChanged;
+            client.UserJoined += onUserJoined;
+            client.UserLeft += onUserLeft;
+
+            if (client.Room != null)
+            {
+                onRoomStateChanged(client.Room.MatchState);
+                foreach (var user in client.Room.Users)
+                    onUserJoined(user);
+            }
+
+            updateDisplay();
+        }
+
+        public PanelDisplayStyle DisplayStyle
+        {
+            set
+            {
+                displayStyle = value;
+                if (IsLoaded)
+                    updateDisplay();
+            }
+        }
+
+        public Drawable? DisplayArea
+        {
+            set
+            {
+                displayArea = value;
+                isAnimatingToDisplayArea = true;
+            }
+        }
+
+        private void onUserJoined(MultiplayerRoomUser user) => Scheduler.Add(() =>
+        {
+            panels.Add(new PlayerPanel(user)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Scale = new Vector2(0.8f)
+            });
+
+            updateDisplay();
+        });
+
+        private void onUserLeft(MultiplayerRoomUser user) => Scheduler.Add(() =>
+        {
+            panels.Single(p => p.RoomUser.Equals(user)).Expire();
+            updateDisplay();
+        });
+
+        private void onRoomStateChanged(MatchRoomState? state) => Scheduler.Add(updateDisplay);
+
+        private void updateDisplay()
+        {
+            gridLayout.ReleasePanels();
+            splitLayoutLeft.ReleasePanels();
+            splitLayoutRight.ReleasePanels();
+
+            switch (displayStyle)
+            {
+                case PanelDisplayStyle.Grid:
+                    foreach (var panel in panels)
+                    {
+                        panel.FadeTo(1, 200);
+                        panel.Horizontal = false;
+                    }
+
+                    gridLayout.AcquirePanels(panels.ToArray());
+                    break;
+
+                case PanelDisplayStyle.Split:
+                    foreach (var panel in panels)
+                    {
+                        panel.FadeTo(1, 200);
+                        panel.Horizontal = true;
+                    }
+
+                    int leftCount = (int)Math.Ceiling(panels.Count / 2f);
+
+                    splitLayoutLeft.AcquirePanels(panels.Take(leftCount).ToArray());
+                    splitLayoutRight.AcquirePanels(panels.Skip(leftCount).ToArray());
+                    break;
+
+                case PanelDisplayStyle.Hidden:
+                    foreach (var panel in panels)
+                        panel.FadeTo(0, 200);
+                    return;
+            }
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            var targetPos = getFinalPosition();
+            var targetSize = getFinalSize();
+
+            double duration = isAnimatingToDisplayArea ? 60 : 0;
+
+            if (Time.Elapsed > 0)
+            {
+                Position = new Vector2(
+                    (float)Interpolation.DampContinuously(Position.X, targetPos.X, duration, Time.Elapsed),
+                    (float)Interpolation.DampContinuously(Position.Y, targetPos.Y, duration, Time.Elapsed)
+                );
+
+                Size = new Vector2(
+                    (float)Interpolation.DampContinuously(Size.X, targetSize.X, duration, Time.Elapsed),
+                    (float)Interpolation.DampContinuously(Size.Y, targetSize.Y, duration, Time.Elapsed)
+                );
+            }
+
+            // If we don't track the animating state, the animation will also occur when resizing the window.
+            isAnimatingToDisplayArea &= !Precision.AlmostEquals(Size, targetSize, 0.5f);
+        }
+
+        private Vector2 getFinalPosition()
+            => displayArea == null ? Vector2.Zero : Parent!.ToLocalSpace(displayArea.ScreenSpaceDrawQuad.TopLeft);
+
+        private Vector2 getFinalSize()
+            => displayArea == null ? Parent!.DrawSize : Parent!.ToLocalSpace(displayArea.ScreenSpaceDrawQuad.BottomRight) - Parent!.ToLocalSpace(displayArea.ScreenSpaceDrawQuad.TopLeft);
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+            {
+                client.MatchRoomStateChanged -= onRoomStateChanged;
+                client.UserJoined -= onUserJoined;
+                client.UserLeft -= onUserLeft;
+            }
+        }
+
+        private partial class PlayerPanelCellContainer : FillFlowContainer<PlayerPanelCell>
+        {
+            [Resolved]
+            private MultiplayerClient client { get; set; } = null!;
+
+            public void AcquirePanels(PlayerPanel[] panels)
+            {
+                while (Count < panels.Length)
+                {
+                    Add(new PlayerPanelCell
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre
+                    });
+                }
+
+                while (Count > panels.Length)
+                    Remove(Children[^1], true);
+
+                for (int i = 0; i < panels.Length; i++)
+                {
+                    // We'll invalidate the layout position to represent the new placements and the re-flow will happen in UpdateAfterChildren().
+                    // But the cells expect their positions to be valid as they're updated, which won't be the case until the re-flow happens.
+                    int i2 = i;
+                    ScheduleAfterChildren(() => Children[i2].AcquirePanel(panels[i2]));
+
+                    if (client.Room?.MatchState is not MatchmakingRoomState matchmakingState)
+                        continue;
+
+                    if (matchmakingState.Users.UserDictionary.TryGetValue(panels[i].User.Id, out MatchmakingUser? user))
+                        SetLayoutPosition(Children[i], user.Placement);
+                    else
+                        SetLayoutPosition(Children[i], float.MaxValue);
+                }
+            }
+
+            public void ReleasePanels()
+            {
+                // Matches the schedule in AcquirePanels.
+                ScheduleAfterChildren(() =>
+                {
+                    foreach (var panel in Children)
+                        panel.ReleasePanel();
+                });
+            }
+        }
+
+        private partial class PlayerPanelCell : Drawable
+        {
+            private PlayerPanel? panel;
+            private bool isAnimating;
+
+            public void AcquirePanel(PlayerPanel panel)
+            {
+                this.panel = panel;
+                isAnimating = true;
+            }
+
+            public void ReleasePanel()
+            {
+                panel = null;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (panel?.Parent == null)
+                    return;
+
+                Size = panel.Horizontal ? PlayerPanel.SIZE_HORIZONTAL : PlayerPanel.SIZE_VERTICAL;
+                Size *= panel.Scale;
+
+                var targetPos = getFinalPosition();
+
+                double duration = isAnimating ? 60 : 0;
+
+                if (Time.Elapsed > 0)
+                {
+                    panel.Position = new Vector2(
+                        (float)Interpolation.DampContinuously(panel.Position.X, targetPos.X, duration, Time.Elapsed),
+                        (float)Interpolation.DampContinuously(panel.Position.Y, targetPos.Y, duration, Time.Elapsed)
+                    );
+                }
+
+                // If we don't track the animating state, the animation will also occur when resizing the window.
+                isAnimating &= !Precision.AlmostEquals(panel.Position, targetPos, 0.5f);
+
+                Vector2 getFinalPosition()
+                    => panel.Parent.ToLocalSpace(ScreenSpaceDrawQuad.Centre) - panel.AnchorPosition;
+            }
+        }
+    }
+
+    public enum PanelDisplayStyle
+    {
+        Grid,
+        Split,
+        Hidden
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Results/PanelRoomAward.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Results/PanelRoomAward.cs
new file mode 100644
index 0000000000..5e7c3865c1
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Results/PanelRoomAward.cs
@@ -0,0 +1,57 @@
+// 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;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Database;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API.Requests.Responses;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.Results
+{
+    public partial class PanelRoomAward : CompositeDrawable
+    {
+        private readonly Color4 backgroundColour = Color4.SaddleBrown;
+
+        private readonly string text;
+        private readonly int userId;
+
+        public PanelRoomAward(string text, int userId)
+        {
+            this.text = text;
+            this.userId = userId;
+
+            AutoSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(UserLookupCache userLookupCache)
+        {
+            // Should be cached by this point.
+            APIUser? user = userLookupCache.GetUserAsync(userId).GetResultSafely();
+
+            InternalChild = new CircularContainer
+            {
+                AutoSizeAxes = Axes.Both,
+                Masking = true,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = backgroundColour
+                    },
+                    new OsuSpriteText
+                    {
+                        Margin = new MarginPadding(10),
+                        Text = $"{text}: {user?.Username}"
+                    }
+                }
+            };
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Results/PanelUserStatistic.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Results/PanelUserStatistic.cs
new file mode 100644
index 0000000000..2051359f32
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Results/PanelUserStatistic.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.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics.Sprites;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.Results
+{
+    public partial class PanelUserStatistic : CompositeDrawable
+    {
+        private readonly Color4 backgroundColour = Color4.SaddleBrown;
+
+        private readonly string text;
+
+        public PanelUserStatistic(string text)
+        {
+            this.text = text;
+
+            AutoSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChild = new CircularContainer
+            {
+                AutoSizeAxes = Axes.Both,
+                Masking = true,
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = backgroundColour
+                    },
+                    new OsuSpriteText
+                    {
+                        Margin = new MarginPadding(10),
+                        Text = text
+                    }
+                }
+            };
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Results/SubScreenResults.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Results/SubScreenResults.cs
new file mode 100644
index 0000000000..3e6b437f63
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/Results/SubScreenResults.cs
@@ -0,0 +1,343 @@
+// 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.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Utils;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.Results
+{
+    /// <summary>
+    /// Final room results, during <see cref="MatchmakingStage.Ended"/>
+    /// </summary>
+    public partial class SubScreenResults : MatchmakingSubScreen
+    {
+        private const float grid_spacing = 5;
+
+        public override PanelDisplayStyle PlayersDisplayStyle => PanelDisplayStyle.Grid;
+        public override Drawable PlayersDisplayArea { get; }
+
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        private readonly OsuSpriteText placementText;
+        private readonly FillFlowContainer<PanelUserStatistic> userStatistics;
+        private readonly FillFlowContainer<PanelRoomAward> roomStatistics;
+
+        public SubScreenResults()
+        {
+            InternalChild = new GridContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                RowDimensions =
+                [
+                    new Dimension(GridSizeMode.AutoSize),
+                    new Dimension(GridSizeMode.Absolute, grid_spacing),
+                    new Dimension(),
+                    new Dimension(GridSizeMode.Absolute, grid_spacing),
+                    new Dimension(GridSizeMode.AutoSize),
+                    new Dimension(GridSizeMode.Absolute, 75)
+                ],
+                Content = new Drawable[]?[]
+                {
+                    [
+                        new FillFlowContainer
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            AutoSizeAxes = Axes.Both,
+                            Direction = FillDirection.Vertical,
+                            Spacing = new Vector2(grid_spacing),
+                            Children = new[]
+                            {
+                                new OsuSpriteText
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    Text = "Placement",
+                                    Font = OsuFont.Default.With(size: 12)
+                                },
+                                placementText = new OsuSpriteText
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    Font = OsuFont.Default.With(size: 72),
+                                    UseFullGlyphHeight = false
+                                }
+                            }
+                        }
+                    ],
+                    null,
+                    [
+                        new GridContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            ColumnDimensions =
+                            [
+                                new Dimension(GridSizeMode.AutoSize),
+                                new Dimension(GridSizeMode.Absolute, grid_spacing),
+                                new Dimension()
+                            ],
+                            Content = new Drawable?[][]
+                            {
+                                [
+                                    new FillFlowContainer
+                                    {
+                                        Anchor = Anchor.CentreLeft,
+                                        Origin = Anchor.CentreLeft,
+                                        AutoSizeAxes = Axes.Both,
+                                        Direction = FillDirection.Vertical,
+                                        Spacing = new Vector2(grid_spacing),
+                                        Children = new Drawable[]
+                                        {
+                                            new OsuSpriteText
+                                            {
+                                                Anchor = Anchor.TopCentre,
+                                                Origin = Anchor.TopCentre,
+                                                Text = "Breakdown",
+                                                Font = OsuFont.Default.With(size: 12)
+                                            },
+                                            userStatistics = new FillFlowContainer<PanelUserStatistic>
+                                            {
+                                                Anchor = Anchor.TopCentre,
+                                                Origin = Anchor.TopCentre,
+                                                AutoSizeAxes = Axes.Both,
+                                                Direction = FillDirection.Vertical,
+                                                Spacing = new Vector2(grid_spacing)
+                                            }
+                                        }
+                                    },
+                                    null,
+                                    PlayersDisplayArea = Empty().With(d =>
+                                    {
+                                        d.RelativeSizeAxes = Axes.Both;
+                                    })
+                                ]
+                            }
+                        }
+                    ],
+                    null,
+                    [
+                        new FillFlowContainer
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Vertical,
+                            Spacing = new Vector2(grid_spacing),
+                            Children = new Drawable[]
+                            {
+                                new OsuSpriteText
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    Text = "Statistics",
+                                    Font = OsuFont.Default.With(size: 12)
+                                },
+                                roomStatistics = new FillFlowContainer<PanelRoomAward>
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Spacing = new Vector2(grid_spacing)
+                                }
+                            }
+                        },
+                    ],
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            client.MatchRoomStateChanged += onRoomStateChanged;
+
+            onRoomStateChanged(client.Room?.MatchState);
+        }
+
+        private void onRoomStateChanged(MatchRoomState? state) => Scheduler.Add(() =>
+        {
+            if (state is not MatchmakingRoomState matchmakingState || matchmakingState.Stage != MatchmakingStage.Ended)
+                return;
+
+            populateUserStatistics(matchmakingState);
+            populateRoomStatistics(matchmakingState);
+        });
+
+        private void populateUserStatistics(MatchmakingRoomState state)
+        {
+            userStatistics.Clear();
+
+            if (state.Users[client.LocalUser!.UserID].Rounds.Count == 0)
+            {
+                placementText.Text = "-";
+                addStatistic("No rounds played");
+                return;
+            }
+
+            int overallPlacement = state.Users[client.LocalUser!.UserID].Placement;
+            int overallPoints = state.Users[client.LocalUser!.UserID].Points;
+            int bestPlacement = state.Users[client.LocalUser!.UserID].Rounds.Min(r => r.Placement);
+            var accuracyPlacement = state.Users.Select(u => (user: u, avgAcc: u.Rounds.Select(r => r.Accuracy).DefaultIfEmpty(0).Average()))
+                                         .OrderByDescending(t => t.avgAcc)
+                                         .Select((t, i) => (info: t, index: i))
+                                         .Single(t => t.info.user.UserId == client.LocalUser!.UserID);
+
+            placementText.Text = $"#{state.Users[client.LocalUser!.UserID].Placement}";
+            addStatistic($"#{overallPlacement} overall ({overallPoints}pts)");
+            addStatistic($"#{bestPlacement} best placement");
+            addStatistic($"#{accuracyPlacement.index + 1} accuracy ({accuracyPlacement.info.avgAcc.FormatAccuracy()})");
+
+            void addStatistic(string text)
+            {
+                userStatistics.Add(new PanelUserStatistic(text)
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre
+                });
+            }
+        }
+
+        private void populateRoomStatistics(MatchmakingRoomState state)
+        {
+            roomStatistics.Clear();
+
+            long maxScore = long.MinValue;
+            int maxScoreUserId = 0;
+
+            double maxAccuracy = double.MinValue;
+            int maxAccuracyUserId = 0;
+
+            int maxCombo = int.MinValue;
+            int maxComboUserId = 0;
+
+            long maxBonusScore = 0;
+            int maxBonusScoreUserId = 0;
+
+            long largestScoreDifference = long.MinValue;
+            int largestScoreDifferenceUserId = 0;
+
+            long smallestScoreDifference = long.MaxValue;
+            int smallestScoreDifferenceUserId = 0;
+
+            for (int round = 1; round <= state.CurrentRound; round++)
+            {
+                long roundHighestScore = long.MinValue;
+                int roundHighestScoreUserId = 0;
+
+                long roundLowestScore = long.MaxValue;
+
+                foreach (MatchmakingUser user in state.Users)
+                {
+                    if (!user.Rounds.RoundsDictionary.TryGetValue(round, out MatchmakingRound? mmRound))
+                        continue;
+
+                    if (mmRound.TotalScore > maxScore)
+                    {
+                        maxScore = mmRound.TotalScore;
+                        maxScoreUserId = user.UserId;
+                    }
+
+                    if (mmRound.Accuracy > maxAccuracy)
+                    {
+                        maxAccuracy = mmRound.Accuracy;
+                        maxAccuracyUserId = user.UserId;
+                    }
+
+                    if (mmRound.MaxCombo > maxCombo)
+                    {
+                        maxCombo = mmRound.MaxCombo;
+                        maxComboUserId = user.UserId;
+                    }
+
+                    if (mmRound.TotalScore > roundHighestScore)
+                    {
+                        roundHighestScore = mmRound.TotalScore;
+                        roundHighestScoreUserId = user.UserId;
+                    }
+
+                    if (mmRound.TotalScore < roundLowestScore)
+                        roundLowestScore = mmRound.TotalScore;
+                }
+
+                long roundScoreDifference = roundHighestScore - roundLowestScore;
+
+                if (roundScoreDifference > 0 && roundScoreDifference > largestScoreDifference)
+                {
+                    largestScoreDifference = roundScoreDifference;
+                    largestScoreDifferenceUserId = roundHighestScoreUserId;
+                }
+
+                if (roundScoreDifference > 0 && roundScoreDifference < smallestScoreDifference)
+                {
+                    smallestScoreDifference = roundScoreDifference;
+                    smallestScoreDifferenceUserId = roundHighestScoreUserId;
+                }
+            }
+
+            foreach (MatchmakingUser user in state.Users)
+            {
+                int userBonusScore = 0;
+
+                foreach (MatchmakingRound round in user.Rounds)
+                {
+                    userBonusScore += round.Statistics.TryGetValue(HitResult.LargeBonus, out int bonus) ? bonus * 5 : 0;
+                    userBonusScore += round.Statistics.TryGetValue(HitResult.SmallBonus, out bonus) ? bonus : 0;
+                }
+
+                if (userBonusScore > maxBonusScore)
+                {
+                    maxBonusScore = userBonusScore;
+                    maxBonusScoreUserId = user.UserId;
+                }
+            }
+
+            // Highest score - highest score across all rounds.
+            addStatistic(maxScoreUserId, "Highest score");
+
+            // Most accurate - highest accuracy across all rounds.
+            addStatistic(maxAccuracyUserId, "Most accurate");
+
+            // Most combo - highest combo across all rounds.
+            addStatistic(maxComboUserId, "Most combo");
+
+            // Most bonus - most bonus score across all rounds.
+            if (maxBonusScoreUserId > 0)
+                addStatistic(maxBonusScoreUserId, "Most bonus");
+
+            // Most clutch - smallest victory in any round.
+            if (smallestScoreDifferenceUserId > 0)
+                addStatistic(smallestScoreDifferenceUserId, "Most clutch");
+
+            // Best finish - largest victory in any round.
+            if (largestScoreDifferenceUserId > 0)
+                addStatistic(largestScoreDifferenceUserId, "Best finish");
+
+            void addStatistic(int userId, string text)
+            {
+                roomStatistics.Add(new PanelRoomAward(text, userId)
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre
+                });
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+                client.MatchRoomStateChanged -= onRoomStateChanged;
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/RoundResults/SubScreenRoundResults.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/RoundResults/SubScreenRoundResults.cs
new file mode 100644
index 0000000000..580d157a8b
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/RoundResults/SubScreenRoundResults.cs
@@ -0,0 +1,214 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Logging;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Models;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
+using osu.Game.Scoring;
+using osu.Game.Screens.Ranking;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.RoundResults
+{
+    /// <summary>
+    /// Per-round results, during <see cref="MatchmakingStage.ResultsDisplaying"/>
+    /// </summary>
+    public partial class SubScreenRoundResults : MatchmakingSubScreen
+    {
+        private const int panel_spacing = 5;
+
+        public override PanelDisplayStyle PlayersDisplayStyle => PanelDisplayStyle.Hidden;
+        public override Drawable? PlayersDisplayArea => null;
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapLookupCache beatmapLookupCache { get; set; } = null!;
+
+        [Resolved]
+        private ScoreManager scoreManager { get; set; } = null!;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
+        private AutoScrollContainer scrollContainer = null!;
+        private LoadingSpinner loadingSpinner = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChildren = new Drawable[]
+            {
+                scrollContainer = new AutoScrollContainer
+                {
+                    RelativeSizeAxes = Axes.Both
+                },
+                loadingSpinner = new LoadingSpinner
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            loadingSpinner.Show();
+
+            queryScores().FireAndForget();
+        }
+
+        private async Task queryScores()
+        {
+            try
+            {
+                if (client.Room == null)
+                    return;
+
+                Task<APIBeatmap?> beatmapTask = beatmapLookupCache.GetBeatmapAsync(client.Room.CurrentPlaylistItem.BeatmapID);
+                TaskCompletionSource<List<MultiplayerScore>> scoreTask = new TaskCompletionSource<List<MultiplayerScore>>();
+
+                var request = new IndexPlaylistScoresRequest(client.Room.RoomID, client.Room.Settings.PlaylistItemId);
+                request.Success += req => scoreTask.SetResult(req.Scores);
+                request.Failure += e => scoreTask.SetException(e);
+                api.Queue(request);
+
+                await Task.WhenAll(beatmapTask, scoreTask.Task).ConfigureAwait(false);
+
+                APIBeatmap? apiBeatmap = beatmapTask.GetResultSafely();
+                List<MultiplayerScore> apiScores = scoreTask.Task.GetResultSafely();
+
+                if (apiBeatmap == null)
+                    return;
+
+                // Reference: PlaylistItemResultsScreen
+                setScores(apiScores.Select(s => s.CreateScoreInfo(scoreManager, rulesets, new BeatmapInfo
+                {
+                    Difficulty = new BeatmapDifficulty(apiBeatmap.Difficulty),
+                    Metadata =
+                    {
+                        Artist = apiBeatmap.Metadata.Artist,
+                        Title = apiBeatmap.Metadata.Title,
+                        Author = new RealmUser
+                        {
+                            Username = apiBeatmap.Metadata.Author.Username,
+                            OnlineID = apiBeatmap.Metadata.Author.OnlineID,
+                        }
+                    },
+                    DifficultyName = apiBeatmap.DifficultyName,
+                    StarRating = apiBeatmap.StarRating,
+                    Length = apiBeatmap.Length,
+                    BPM = apiBeatmap.BPM
+                })).ToArray());
+            }
+            catch (Exception e)
+            {
+                Logger.Error(e, "Failed to load scores for playlist item.");
+                throw;
+            }
+            finally
+            {
+                Scheduler.Add(() => loadingSpinner.Hide());
+            }
+        }
+
+        private void setScores(ScoreInfo[] scores) => Scheduler.Add(() =>
+        {
+            Container panels;
+
+            scrollContainer.Child = panels = new Container
+            {
+                RelativeSizeAxes = Axes.Y,
+                Width = scores.Length * (ScorePanel.CONTRACTED_WIDTH + panel_spacing),
+                ChildrenEnumerable = scores.Select(s => new RoundResultsScorePanel(s)
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft
+                })
+            };
+
+            for (int i = 0; i < panels.Count; i++)
+            {
+                panels[i].MoveToX(panels.DrawWidth * 2)
+                         .Delay(i * 100)
+                         .MoveToX((ScorePanel.CONTRACTED_WIDTH + panel_spacing) * i, 500, Easing.OutQuint);
+            }
+        });
+
+        private partial class RoundResultsScorePanel : CompositeDrawable
+        {
+            public RoundResultsScorePanel(ScoreInfo score)
+            {
+                AutoSizeAxes = Axes.Both;
+                InternalChild = new InstantSizingScorePanel(score);
+            }
+
+            public override bool PropagateNonPositionalInputSubTree => false;
+            public override bool PropagatePositionalInputSubTree => false;
+
+            private partial class InstantSizingScorePanel : ScorePanel
+            {
+                public InstantSizingScorePanel(ScoreInfo score, bool isNewLocalScore = false)
+                    : base(score, isNewLocalScore)
+                {
+                }
+
+                protected override void LoadComplete()
+                {
+                    base.LoadComplete();
+                    FinishTransforms(true);
+                }
+            }
+        }
+
+        private partial class AutoScrollContainer : UserTrackingScrollContainer
+        {
+            private const float initial_offset = -0.5f;
+            private const double scroll_duration = 20000;
+
+            private double? scrollStartTime;
+
+            public AutoScrollContainer()
+                : base(Direction.Horizontal)
+            {
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (!UserScrolling && Children.Count > 0)
+                {
+                    scrollStartTime ??= Time.Current;
+
+                    double scrollOffset = (Time.Current - scrollStartTime.Value) / scroll_duration;
+
+                    if (scrollOffset < 1)
+                        ScrollTo(DrawWidth * (initial_offset + scrollOffset), false);
+                }
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/RoundWarmup/SubScreenRoundWarmup.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/RoundWarmup/SubScreenRoundWarmup.cs
new file mode 100644
index 0000000000..e389cbabfa
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/RoundWarmup/SubScreenRoundWarmup.cs
@@ -0,0 +1,24 @@
+// 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.Screens;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match.RoundWarmup
+{
+    /// <summary>
+    /// Shown during <see cref="MatchmakingStage.RoundWarmupTime"/>
+    /// </summary>
+    public partial class SubScreenRoundWarmup : MatchmakingSubScreen
+    {
+        public override PanelDisplayStyle PlayersDisplayStyle => PanelDisplayStyle.Grid;
+        public override Drawable PlayersDisplayArea => this;
+
+        public override void OnEntering(ScreenTransitionEvent e)
+        {
+            base.OnEntering(e);
+            this.MoveToX(0);
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/ScreenMatchmaking.ScreenStack.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/ScreenMatchmaking.ScreenStack.cs
new file mode 100644
index 0000000000..c1f436e0c9
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/ScreenMatchmaking.ScreenStack.cs
@@ -0,0 +1,133 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Diagnostics;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Screens;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.BeatmapSelect;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.Results;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.RoundResults;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.RoundWarmup;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    public partial class ScreenMatchmaking
+    {
+        public partial class ScreenStack : CompositeDrawable
+        {
+            [Resolved]
+            private MultiplayerClient client { get; set; } = null!;
+
+            private Framework.Screens.ScreenStack screenStack = null!;
+            private PlayerPanelOverlay playersList = null!;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                InternalChildren = new Drawable[]
+                {
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding(10)
+                        {
+                            Bottom = StageDisplay.HEIGHT,
+                        },
+                        Children = new Drawable[]
+                        {
+                            screenStack = new Framework.Screens.ScreenStack(),
+                        }
+                    },
+                    playersList = new PlayerPanelOverlay
+                    {
+                        DisplayArea = this
+                    },
+                    new StageDisplay
+                    {
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft,
+                        RelativeSizeAxes = Axes.X
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                screenStack.ScreenPushed += onScreenPushed;
+                screenStack.ScreenExited += onScreenExited;
+
+                screenStack.Push(new SubScreenRoundWarmup());
+
+                client.MatchRoomStateChanged += onMatchRoomStateChanged;
+                onMatchRoomStateChanged(client.Room!.MatchState);
+            }
+
+            private void onScreenPushed(IScreen lastScreen, IScreen newScreen)
+            {
+                if (newScreen is not MatchmakingSubScreen matchmakingSubScreen)
+                    return;
+
+                playersList.DisplayStyle = matchmakingSubScreen.PlayersDisplayStyle;
+                playersList.DisplayArea = matchmakingSubScreen.PlayersDisplayArea;
+            }
+
+            private void onScreenExited(IScreen lastScreen, IScreen newScreen)
+            {
+                if (newScreen is not MatchmakingSubScreen matchmakingSubScreen)
+                    return;
+
+                playersList.DisplayStyle = matchmakingSubScreen.PlayersDisplayStyle;
+                playersList.DisplayArea = matchmakingSubScreen.PlayersDisplayArea;
+            }
+
+            private void onMatchRoomStateChanged(MatchRoomState? state) => Scheduler.Add(() =>
+            {
+                if (state is not MatchmakingRoomState matchmakingState)
+                    return;
+
+                switch (matchmakingState.Stage)
+                {
+                    case MatchmakingStage.WaitingForClientsJoin:
+                    case MatchmakingStage.RoundWarmupTime:
+                        while (screenStack.CurrentScreen is not SubScreenRoundWarmup)
+                            screenStack.Exit();
+                        break;
+
+                    case MatchmakingStage.UserBeatmapSelect:
+                        screenStack.Push(new SubScreenBeatmapSelect());
+                        break;
+
+                    case MatchmakingStage.ServerBeatmapFinalised:
+                        Debug.Assert(screenStack.CurrentScreen is SubScreenBeatmapSelect);
+                        ((SubScreenBeatmapSelect)screenStack.CurrentScreen).RollFinalBeatmap(matchmakingState.CandidateItems, matchmakingState.CandidateItem);
+                        break;
+
+                    case MatchmakingStage.ResultsDisplaying:
+                        screenStack.Push(new SubScreenRoundResults());
+                        break;
+
+                    case MatchmakingStage.Ended:
+                        screenStack.Push(new SubScreenResults());
+                        break;
+                }
+            });
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                if (client.IsNotNull())
+                    client.MatchRoomStateChanged -= onMatchRoomStateChanged;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/ScreenMatchmaking.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/ScreenMatchmaking.cs
new file mode 100644
index 0000000000..e4031c5e98
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/ScreenMatchmaking.cs
@@ -0,0 +1,368 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using System.Threading;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+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.Input.Events;
+using osu.Framework.Logging;
+using osu.Framework.Screens;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Graphics.Cursor;
+using osu.Game.Online;
+using osu.Game.Online.Matchmaking.Events;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Dialog;
+using osu.Game.Rulesets;
+using osu.Game.Screens.OnlinePlay.Match.Components;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match.Gameplay;
+using osu.Game.Screens.OnlinePlay.Multiplayer;
+using osu.Game.Users;
+using osuTK.Input;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    /// <summary>
+    /// The main matchmaking screen which houses a custom <see cref="ScreenStack"/> through the life cycle of a single session.
+    /// </summary>
+    public partial class ScreenMatchmaking : OsuScreen
+    {
+        /// <summary>
+        /// Padding between rows of the content.
+        /// </summary>
+        private const float row_padding = 10;
+
+        public override bool? ApplyModTrackAdjustments => true;
+
+        public override bool DisallowExternalBeatmapRulesetChanges => true;
+
+        public override bool ShowFooter => true;
+
+        [Cached(typeof(OnlinePlayBeatmapAvailabilityTracker))]
+        private readonly OnlinePlayBeatmapAvailabilityTracker beatmapAvailabilityTracker = new MultiplayerBeatmapAvailabilityTracker();
+
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; } = null!;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapLookupCache beatmapLookupCache { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapModelDownloader beatmapDownloader { get; set; } = null!;
+
+        [Resolved]
+        private IDialogOverlay dialogOverlay { get; set; } = null!;
+
+        [Resolved]
+        private AudioManager audio { get; set; } = null!;
+
+        private readonly MultiplayerRoom room;
+
+        private Sample? sampleStart;
+        private CancellationTokenSource? downloadCheckCancellation;
+        private int? lastDownloadCheckedBeatmapId;
+
+        private MatchChatDisplay chat = null!;
+
+        public ScreenMatchmaking(MultiplayerRoom room)
+        {
+            this.room = room;
+
+            Activity.Value = new UserActivity.InLobby(room);
+            Padding = new MarginPadding { Horizontal = -HORIZONTAL_OVERFLOW_PADDING };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
+        {
+            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 GridContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding
+                            {
+                                Horizontal = WaveOverlayContainer.WIDTH_PADDING,
+                                Top = row_padding,
+                            },
+                            RowDimensions = new[]
+                            {
+                                new Dimension(),
+                                new Dimension(GridSizeMode.Absolute, row_padding),
+                                new Dimension(GridSizeMode.AutoSize),
+                            },
+                            Content = new Drawable[]?[]
+                            {
+                                [
+                                    new Container
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Masking = true,
+                                        CornerRadius = 10,
+                                        Children = new Drawable[]
+                                        {
+                                            new Box
+                                            {
+                                                RelativeSizeAxes = Axes.Both,
+                                                Colour = colourProvider.Background6,
+                                            },
+                                            new ScreenStack(),
+                                        }
+                                    }
+                                ],
+                                null,
+                                [
+                                    new Container
+                                    {
+                                        Anchor = Anchor.TopRight,
+                                        Origin = Anchor.TopRight,
+                                        Width = 700,
+                                        Height = 130,
+                                        Padding = new MarginPadding { Bottom = row_padding },
+                                        Child = chat = new MatchmakingChatDisplay(new Room(room))
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            client.RoomUpdated += onRoomUpdated;
+            client.UserStateChanged += onUserStateChanged;
+            client.SettingsChanged += onSettingsChanged;
+            client.LoadRequested += onLoadRequested;
+
+            beatmapAvailabilityTracker.Availability.BindValueChanged(onBeatmapAvailabilityChanged, true);
+
+            Footer!.Add(chat.CreateProxy());
+        }
+
+        private void onRoomUpdated()
+        {
+            if (this.IsCurrentScreen() && client.Room == null)
+            {
+                Logger.Log($"{this} exiting due to loss of room or connection");
+                this.Exit();
+            }
+        }
+
+        private void onUserStateChanged(MultiplayerRoomUser user, MultiplayerUserState state)
+        {
+            if (user.Equals(client.LocalUser) && state == MultiplayerUserState.Idle)
+                this.MakeCurrent();
+        }
+
+        private void onSettingsChanged(MultiplayerRoomSettings _) => Scheduler.Add(() =>
+        {
+            checkForAutomaticDownload();
+            updateGameplayState();
+        });
+
+        private void onBeatmapAvailabilityChanged(ValueChangedEvent<BeatmapAvailability> e) => Scheduler.Add(() =>
+        {
+            if (client.Room == null || client.LocalUser == null)
+                return;
+
+            client.ChangeBeatmapAvailability(e.NewValue).FireAndForget();
+
+            switch (e.NewValue.State)
+            {
+                case DownloadState.NotDownloaded:
+                case DownloadState.LocallyAvailable:
+                    updateGameplayState();
+                    break;
+            }
+        });
+
+        private void updateGameplayState()
+        {
+            MultiplayerPlaylistItem item = client.Room!.CurrentPlaylistItem;
+
+            if (item.Expired)
+                return;
+
+            RulesetInfo ruleset = rulesets.GetRuleset(item.RulesetID)!;
+            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)}", item.BeatmapID);
+            Beatmap.Value = beatmapManager.GetWorkingBeatmap(localBeatmap);
+            Ruleset.Value = ruleset;
+            Mods.Value = item.RequiredMods.Select(m => m.ToMod(rulesetInstance)).ToArray();
+
+            if (Beatmap.Value is DummyWorkingBeatmap)
+            {
+                if (client.LocalUser!.State == MultiplayerUserState.Ready)
+                    client.ChangeState(MultiplayerUserState.Idle).FireAndForget();
+            }
+            else
+            {
+                if (client.LocalUser!.State == MultiplayerUserState.Idle)
+                    client.ChangeState(MultiplayerUserState.Ready).FireAndForget();
+            }
+
+            client.ChangeBeatmapAvailability(beatmapAvailabilityTracker.Availability.Value).FireAndForget();
+        }
+
+        private void onLoadRequested() => Scheduler.Add(() =>
+        {
+            updateGameplayState();
+
+            if (Beatmap.IsDefault)
+            {
+                Logger.Log("Aborting gameplay start - beatmap not downloaded.");
+                return;
+            }
+
+            sampleStart?.Play();
+
+            this.Push(new MultiplayerPlayerLoader(() => new ScreenGameplay(new Room(room), new PlaylistItem(client.Room!.CurrentPlaylistItem), room.Users.ToArray())));
+        });
+
+        private void checkForAutomaticDownload()
+        {
+            if (client.Room == null)
+                return;
+
+            MultiplayerPlaylistItem item = client.Room.CurrentPlaylistItem;
+
+            // This method is called every time anything changes in the room.
+            // This could result in download requests firing far too often, when we only expect them to fire once per beatmap.
+            //
+            // Without this check, we would see especially egregious behaviour when a user has hit the download rate limit.
+            if (lastDownloadCheckedBeatmapId == item.BeatmapID)
+                return;
+
+            lastDownloadCheckedBeatmapId = item.BeatmapID;
+
+            downloadCheckCancellation?.Cancel();
+
+            // In a perfect world we'd use BeatmapAvailability, but there's no event-driven flow for when a selection changes.
+            // ie. if selection changes from "not downloaded" to another "not downloaded" we wouldn't get a value changed raised.
+            beatmapLookupCache
+                .GetBeatmapAsync(item.BeatmapID, (downloadCheckCancellation = new CancellationTokenSource()).Token)
+                .ContinueWith(resolved => Schedule(() =>
+                {
+                    var beatmapSet = resolved.GetResultSafely()?.BeatmapSet;
+
+                    if (beatmapSet == null)
+                        return;
+
+                    if (beatmapManager.IsAvailableLocally(new BeatmapSetInfo { OnlineID = beatmapSet.OnlineID }))
+                        return;
+
+                    beatmapDownloader.Download(beatmapSet);
+                }));
+        }
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            switch (e.Key)
+            {
+                case Key.Space:
+                    if (e.Repeat)
+                        return true;
+
+                    client.SendMatchRequest(new MatchmakingAvatarActionRequest { Action = MatchmakingAvatarAction.Jump }).FireAndForget();
+                    return true;
+            }
+
+            return false;
+        }
+
+        private bool exitConfirmed;
+
+        public override bool OnExiting(ScreenExitEvent e)
+        {
+            if (base.OnExiting(e))
+                return true;
+
+            if (exitConfirmed)
+            {
+                client.LeaveRoom().FireAndForget();
+                return false;
+            }
+
+            if (dialogOverlay.CurrentDialog is ConfirmDialog confirmDialog)
+                confirmDialog.PerformOkAction();
+            else
+            {
+                dialogOverlay.Push(new ConfirmDialog("Are you sure you want to leave this multiplayer match?", () =>
+                {
+                    exitConfirmed = true;
+                    if (this.IsCurrentScreen())
+                        this.Exit();
+                }));
+            }
+
+            return true;
+        }
+
+        public override void OnResuming(ScreenTransitionEvent e)
+        {
+            base.OnResuming(e);
+
+            if (e.Last is not MultiplayerPlayerLoader playerLoader)
+                return;
+
+            if (!playerLoader.GameplayPassed)
+            {
+                client.AbortGameplay().FireAndForget();
+                return;
+            }
+
+            client.ChangeState(MultiplayerUserState.Idle);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+            {
+                client.RoomUpdated -= onRoomUpdated;
+                client.UserStateChanged -= onUserStateChanged;
+                client.SettingsChanged -= onSettingsChanged;
+                client.LoadRequested -= onLoadRequested;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/StageDisplay.StageSegment.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/StageDisplay.StageSegment.cs
new file mode 100644
index 0000000000..301cac1437
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/StageDisplay.StageSegment.cs
@@ -0,0 +1,242 @@
+// 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.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.Matchmaking;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Overlays;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    public partial class StageDisplay
+    {
+        internal partial class StageSegment : CompositeDrawable
+        {
+            [Resolved]
+            private MultiplayerClient client { get; set; } = null!;
+
+            public readonly int? Round;
+
+            private readonly MatchmakingStage stage;
+
+            private readonly LocalisableString displayText;
+            private Drawable progressBar = null!;
+
+            private DateTimeOffset countdownStartTime;
+            private DateTimeOffset countdownEndTime;
+            private SpriteIcon arrow = null!;
+
+            private Sample? countdownTickSample;
+            private double? lastSamplePlayback;
+
+            private Container mainContent = null!;
+
+            public bool Active { get; private set; }
+
+            public float Progress => progressBar.Width;
+
+            public StageSegment(int? round, MatchmakingStage stage, LocalisableString displayText)
+            {
+                Round = round;
+
+                this.stage = stage;
+                this.displayText = displayText;
+
+                AutoSizeAxes = Axes.Both;
+
+                Anchor = Anchor.CentreLeft;
+                Origin = Anchor.CentreLeft;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(AudioManager audio, OverlayColourProvider colourProvider)
+            {
+                InternalChild = new FillFlowContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+                    Spacing = new Vector2(5),
+                    Children = new Drawable[]
+                    {
+                        arrow = new SpriteIcon
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            Alpha = 0.5f,
+                            Size = new Vector2(16),
+                            Icon = FontAwesome.Solid.ArrowRight,
+                            Margin = new MarginPadding { Horizontal = 10 }
+                        },
+                        mainContent = new Container
+                        {
+                            Masking = true,
+                            CornerRadius = 5,
+                            CornerExponent = 10,
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            AutoSizeAxes = Axes.Both,
+                            Children = new[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour =
+                                        ColourInfo.GradientVertical(
+                                            colourProvider.Dark2,
+                                            colourProvider.Dark1
+                                        ),
+                                },
+                                progressBar = new Box
+                                {
+                                    Blending = BlendingParameters.Additive,
+                                    EdgeSmoothness = new Vector2(1),
+                                    RelativeSizeAxes = Axes.Both,
+                                    Width = 0,
+                                    Colour = colourProvider.Dark3,
+                                },
+                                new OsuSpriteText
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Text = displayText,
+                                    Padding = new MarginPadding(10)
+                                }
+                            }
+                        }
+                    }
+                };
+
+                Alpha = 0.5f;
+                countdownTickSample = audio.Samples.Get(@"Multiplayer/countdown-tick");
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                client.MatchRoomStateChanged += onMatchRoomStateChanged;
+                client.CountdownStarted += onCountdownStarted;
+                client.CountdownStopped += onCountdownStopped;
+
+                if (client.Room != null)
+                {
+                    onMatchRoomStateChanged(client.Room.MatchState);
+                    foreach (var countdown in client.Room.ActiveCountdowns)
+                        onCountdownStarted(countdown);
+                }
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (!Active)
+                    return;
+
+                TimeSpan total = countdownEndTime - countdownStartTime;
+                TimeSpan elapsed = DateTimeOffset.Now - countdownStartTime;
+
+                if (total.TotalMilliseconds <= 0)
+                {
+                    progressBar.Width = 0;
+                    return;
+                }
+
+                progressBar.Width = (float)Math.Clamp(elapsed.TotalMilliseconds / total.TotalMilliseconds, 0, 1);
+
+                int secondsRemaining = Math.Max(0, (int)Math.Ceiling((total.TotalMilliseconds - elapsed.TotalMilliseconds) / 1000));
+
+                if (total.TotalMilliseconds - elapsed.TotalMilliseconds <= 3000
+                    && lastSamplePlayback != secondsRemaining)
+                {
+                    countdownTickSample?.Play();
+                    lastSamplePlayback = secondsRemaining;
+                }
+            }
+
+            private void onMatchRoomStateChanged(MatchRoomState? state) => Scheduler.Add(() =>
+            {
+                bool wasActive = Active;
+
+                Active = false;
+
+                if (state is not MatchmakingRoomState roomState)
+                    return;
+
+                if (Round != null && roomState.CurrentRound != Round)
+                    return;
+
+                Active = stage == roomState.Stage;
+
+                if (wasActive)
+                    progressBar.Width = 1;
+
+                mainContent.ScaleTo(Active ? 1.3f : 1, 500, Easing.OutQuint);
+
+                bool isPreparing =
+                    (stage == MatchmakingStage.RoundWarmupTime && roomState.Stage == MatchmakingStage.WaitingForClientsJoin) ||
+                    (stage == MatchmakingStage.GameplayWarmupTime && roomState.Stage == MatchmakingStage.WaitingForClientsBeatmapDownload) ||
+                    (stage == MatchmakingStage.ResultsDisplaying && roomState.Stage == MatchmakingStage.Gameplay);
+
+                if (isPreparing)
+                {
+                    arrow.FadeTo(1, 500)
+                         .Then()
+                         .FadeTo(0.5f, 500)
+                         .Loop();
+                }
+            });
+
+            private void onCountdownStarted(MultiplayerCountdown countdown) => Scheduler.Add(() =>
+            {
+                if (!Active)
+                    return;
+
+                if (countdown is not MatchmakingStageCountdown)
+                    return;
+
+                countdownStartTime = DateTimeOffset.Now;
+                countdownEndTime = countdownStartTime + countdown.TimeRemaining;
+                arrow.FadeIn(500, Easing.OutQuint);
+
+                this.FadeIn(200);
+            });
+
+            private void onCountdownStopped(MultiplayerCountdown countdown) => Scheduler.Add(() =>
+            {
+                if (!Active)
+                    return;
+
+                if (countdown is not MatchmakingStageCountdown)
+                    return;
+
+                countdownEndTime = DateTimeOffset.Now;
+            });
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                if (client.IsNotNull())
+                {
+                    client.MatchRoomStateChanged -= onMatchRoomStateChanged;
+                    client.CountdownStarted -= onCountdownStarted;
+                    client.CountdownStopped -= onCountdownStopped;
+                }
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/StageDisplay.StatusText.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/StageDisplay.StatusText.cs
new file mode 100644
index 0000000000..8d94df11e4
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/StageDisplay.StatusText.cs
@@ -0,0 +1,129 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Localisation;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    public partial class StageDisplay
+    {
+        public partial class StatusText : CompositeDrawable
+        {
+            [Resolved]
+            private MultiplayerClient client { get; set; } = null!;
+
+            private OsuSpriteText text = null!;
+
+            private Sample? textChangedSample;
+            private double? lastSamplePlayback;
+
+            public StatusText()
+            {
+                AutoSizeAxes = Axes.X;
+                Height = 16;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(AudioManager audio)
+            {
+                InternalChild = text = new OsuSpriteText
+                {
+                    Alpha = 0,
+                    Height = 16,
+                    Font = OsuFont.Style.Caption1,
+                    AlwaysPresent = true,
+                };
+
+                textChangedSample = audio.Samples.Get(@"Multiplayer/Matchmaking/stage-message");
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                client.MatchRoomStateChanged += onMatchRoomStateChanged;
+                onMatchRoomStateChanged(client.Room!.MatchState);
+            }
+
+            private void onMatchRoomStateChanged(MatchRoomState? state) => Scheduler.Add(() =>
+            {
+                if (state is not MatchmakingRoomState matchmakingState)
+                    return;
+
+                text.Text = getTextForStatus(matchmakingState.Stage);
+
+                if (text.Text == string.Empty || (lastSamplePlayback != null && Time.Current - lastSamplePlayback < OsuGameBase.SAMPLE_DEBOUNCE_TIME))
+                    return;
+
+                textChangedSample?.Play();
+                lastSamplePlayback = Time.Current;
+
+                LocalisableString textForStatus = getTextForStatus(matchmakingState.Stage);
+
+                if (string.IsNullOrEmpty(textForStatus.ToString()))
+                {
+                    text.FadeOut();
+                    return;
+                }
+
+                text.RotateTo(2f)
+                    .RotateTo(0, 500, Easing.OutQuint);
+
+                text.FadeInFromZero(500, Easing.OutQuint);
+
+                using (text.BeginDelayedSequence(500))
+                {
+                    text
+                        .FadeTo(0.6f, 400, Easing.In)
+                        .Then()
+                        .FadeTo(1, 400, Easing.Out)
+                        .Loop();
+                }
+
+                text.ScaleTo(0.3f)
+                    .ScaleTo(1, 500, Easing.OutQuint);
+
+                text.Text = textForStatus;
+            });
+
+            private LocalisableString getTextForStatus(MatchmakingStage status)
+            {
+                switch (status)
+                {
+                    case MatchmakingStage.WaitingForClientsJoin:
+                        return "Players are joining the match...";
+
+                    case MatchmakingStage.WaitingForClientsBeatmapDownload:
+                        return "Players are downloading the beatmap...";
+
+                    case MatchmakingStage.Gameplay:
+                        return "Game is in progress...";
+
+                    case MatchmakingStage.Ended:
+                        return "Thanks for playing! The match will close shortly.";
+
+                    default:
+                        return string.Empty;
+                }
+            }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+
+                if (client.IsNotNull())
+                    client.MatchRoomStateChanged -= onMatchRoomStateChanged;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Match/StageDisplay.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/StageDisplay.cs
new file mode 100644
index 0000000000..e383df71c9
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Match/StageDisplay.cs
@@ -0,0 +1,251 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+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.UserInterface;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
+using osu.Game.Overlays;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Match
+{
+    /// <summary>
+    /// A "global" footer staple element in matchmaking which shows the current progression of the room, from start to finish.
+    /// </summary>
+    public partial class StageDisplay : CompositeDrawable
+    {
+        public const float HEIGHT = 96;
+
+        // TODO: get this from somewhere?
+        private const int round_count = 5;
+
+        private OsuScrollContainer scroll = null!;
+        private FillFlowContainer flow = null!;
+
+        private CurrentRoundDisplay roundDisplay = null!;
+
+        public StageDisplay()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider)
+        {
+            InternalChildren = new Drawable[]
+            {
+                new Box
+                {
+                    Colour = colourProvider.Dark6,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = HEIGHT,
+                    Children = new Drawable[]
+                    {
+                        scroll = new StageScrollContainer
+                        {
+                            ScrollbarVisible = false,
+                            ClampExtension = 0,
+                            RelativeSizeAxes = Axes.X,
+                            Height = HEIGHT,
+                            Child = flow = new FillFlowContainer
+                            {
+                                Padding = new MarginPadding { Horizontal = 2000 },
+                                AutoSizeAxes = Axes.Both,
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                Direction = FillDirection.Horizontal,
+                            },
+                        },
+                        new StatusText
+                        {
+                            Y = 32,
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre
+                        },
+                        new Box
+                        {
+                            Colour = ColourInfo.GradientHorizontal(
+                                colourProvider.Dark4,
+                                colourProvider.Dark5.Opacity(0)
+                            ),
+                            RelativeSizeAxes = Axes.Y,
+                            Width = 240,
+                        },
+                        roundDisplay = new CurrentRoundDisplay
+                        {
+                            X = 12,
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                        },
+                    }
+                },
+            };
+
+            flow.Add(new StageSegment(null, MatchmakingStage.WaitingForClientsJoin, "Waiting for other users"));
+
+            for (int i = 1; i <= round_count; i++)
+            {
+                flow.Add(new StageSegment(i, MatchmakingStage.RoundWarmupTime, "Next Round"));
+                flow.Add(new StageSegment(i, MatchmakingStage.UserBeatmapSelect, "Beatmap Selection"));
+                flow.Add(new StageSegment(i, MatchmakingStage.GameplayWarmupTime, "Get Ready"));
+                flow.Add(new StageSegment(i, MatchmakingStage.ResultsDisplaying, "Results"));
+            }
+
+            flow.Add(new StageSegment(null, MatchmakingStage.Ended, "Match End"));
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            var bubble = flow.OfType<StageSegment>().FirstOrDefault(b => b.Active);
+
+            if (bubble != null)
+            {
+                scroll.ScrollTo(flow.Padding.Left + bubble.X + bubble.Progress * bubble.DrawWidth - scroll.DrawWidth / 2);
+                roundDisplay.Round = bubble.Round;
+            }
+        }
+
+        private partial class StageScrollContainer : OsuScrollContainer
+        {
+            public override bool HandlePositionalInput => false;
+            public override bool HandleNonPositionalInput => false;
+
+            public StageScrollContainer()
+                : base(Direction.Horizontal)
+            {
+            }
+        }
+
+        private partial class CurrentRoundDisplay : CompositeDrawable
+        {
+            private OsuSpriteText text = null!;
+
+            private Circle innerCircle = null!;
+            private CircularProgress progress = null!;
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colours)
+            {
+                Size = new Vector2(76);
+
+                InternalChildren = new Drawable[]
+                {
+                    new Circle
+                    {
+                        Colour = ColourInfo.GradientVertical(
+                            colours.Dark2,
+                            colours.Dark4
+                        ),
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    progress = new CircularProgress
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Colour = ColourInfo.GradientVertical(
+                            colours.Light1,
+                            colours.Dark2
+                        ),
+                        InnerRadius = 0.1f,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    innerCircle = new Circle
+                    {
+                        Alpha = 0.2f,
+                        Blending = BlendingParameters.Additive,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Colour = ColourInfo.GradientVertical(
+                            colours.Dark1,
+                            colours.Dark2
+                        ),
+                        Scale = new Vector2(0.9f),
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    new OsuSpriteText
+                    {
+                        Y = 10,
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        Font = OsuFont.Style.Caption2,
+                        Text = "Round",
+                    },
+                    text = new OsuSpriteText
+                    {
+                        Font = OsuFont.Style.Heading1,
+                        Position = new Vector2(-8, -3),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Text = "1"
+                    },
+                    new OsuSpriteText
+                    {
+                        Font = OsuFont.Style.Heading2,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Y = 4,
+                        Text = "/"
+                    },
+                    new OsuSpriteText
+                    {
+                        Font = OsuFont.Style.Heading1,
+                        Position = new Vector2(10, 11),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Text = $"{round_count}"
+                    },
+                };
+            }
+
+            private int round;
+
+            public int? Round
+            {
+                set
+                {
+                    value ??= 1;
+
+                    if (round == value)
+                        return;
+
+                    round = value.Value;
+
+                    this.ScaleTo(6, 1000, Easing.OutPow10)
+                        .MoveToY(-300, 1000, Easing.OutPow10)
+                        .Then()
+                        .MoveToY(0, 500, Easing.InQuart)
+                        .ScaleTo(1, 500, Easing.InQuart);
+
+                    Scheduler.AddDelayed(() =>
+                    {
+                        progress.ProgressTo((float)round / round_count, 500, Easing.InOutQuart);
+                        Scheduler.AddDelayed(() =>
+                        {
+                            innerCircle
+                                .FadeTo(1, 250, Easing.OutQuint)
+                                .Then()
+                                .FadeTo(0.2f, 5000, Easing.OutQuint);
+
+                            text.Text = $"{round}";
+                        }, 150);
+                    }, 250);
+                }
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/CloudVisualisation.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/CloudVisualisation.cs
new file mode 100644
index 0000000000..33ed21f3db
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/CloudVisualisation.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;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Utils;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osu.Game.Screens.Ranking;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Queue
+{
+    /// <summary>
+    /// A visualisation at the top level of matchmaking which shows the overall system status.
+    /// This is intended to be something which users can watch while idle, for fun or otherwise.
+    /// </summary>
+    public partial class CloudVisualisation : CompositeDrawable
+    {
+        private APIUser[] users = [];
+        private Container usersContainer = null!;
+
+        private readonly Bindable<double?> lastSamplePlayback = new Bindable<double?>();
+
+        public APIUser[] Users
+        {
+            get => users;
+            set
+            {
+                users = value;
+
+                foreach (var u in usersContainer)
+                    u.Delay(RNG.Next(0, 1000)).FadeOut(500).Expire();
+
+                LoadComponentsAsync(users.Select(u => new MovingAvatar(u, lastSamplePlayback)), avatars =>
+                {
+                    if (usersContainer.Count == 0)
+                    {
+                        usersContainer.ScaleTo(0)
+                                      .ScaleTo(1, 5000, Easing.OutPow10);
+                    }
+
+                    usersContainer.AddRange(avatars);
+                });
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            InternalChildren = new Drawable[]
+            {
+                usersContainer = new AspectContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                },
+            };
+        }
+
+        public partial class MovingAvatar : MatchmakingAvatar
+        {
+            private float angle;
+            private float angularSpeed;
+
+            private float targetSpeed;
+            private float targetScale;
+            private float targetAlpha;
+
+            private readonly Bindable<double?> lastSamplePlayback = new Bindable<double?>();
+
+            private const int num_appear_samples = 6;
+            private Sample? playerAppearSample;
+
+            public MovingAvatar(APIUser apiUser, Bindable<double?> lastSamplePlayback)
+                : base(apiUser)
+            {
+                RelativePositionAxes = Axes.Both;
+                Scale = new Vector2(2);
+
+                Origin = Anchor.Centre;
+                this.lastSamplePlayback.BindTo(lastSamplePlayback);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(AudioManager audio)
+            {
+                playerAppearSample = audio.Samples.Get($@"Multiplayer/Matchmaking/Cloud/appear-{RNG.Next(0, num_appear_samples)}");
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                updateParams();
+
+                angle = RNG.NextSingle(0f, MathF.Tau);
+
+                angularSpeed = targetSpeed;
+                Scale = new Vector2(targetScale);
+
+                Hide();
+                int appearDelay = RNG.Next(0, 1000);
+                this.Delay(appearDelay).FadeTo(targetAlpha, 2000, Easing.OutQuint);
+                Scheduler.AddDelayed(playAppearSample, appearDelay);
+            }
+
+            private void updateParams()
+            {
+                targetSpeed = RNG.NextSingle(0.05f, 0.5f);
+                targetScale = RNG.NextSingle(0.2f, 3f);
+                targetAlpha = RNG.NextSingle(0.5f, 1f);
+
+                Scheduler.AddDelayed(updateParams, RNG.Next(500, 5000));
+            }
+
+            private void playAppearSample()
+            {
+                bool enoughTimeElapsed = !lastSamplePlayback.Value.HasValue || Time.Current - lastSamplePlayback.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
+                if (!enoughTimeElapsed) return;
+
+                var chan = playerAppearSample?.GetChannel();
+                if (chan == null) return;
+
+                chan.Frequency.Value = 0.5f + RNG.NextDouble(1.5f);
+                chan.Balance.Value = MathF.Cos(angle) * OsuGameBase.SFX_STEREO_STRENGTH;
+                chan.Play();
+
+                lastSamplePlayback.Value = Time.Current;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                float elapsed = (float)Math.Min(20, Time.Elapsed) / 1000;
+
+                Scale = new Vector2((float)Interpolation.Lerp(Scale.X, targetScale, elapsed / 100));
+                Alpha = (float)Interpolation.Lerp(Alpha, targetAlpha, elapsed / 100);
+                angularSpeed = (float)Interpolation.Lerp(angularSpeed, targetSpeed, elapsed / 100);
+
+                angle += angularSpeed * elapsed * 0.5f;
+
+                Position = new Vector2(0.5f) +
+                           new Vector2(MathF.Cos(angle), MathF.Sin(angle)) * angularSpeed;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/PoolSelector.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/PoolSelector.cs
new file mode 100644
index 0000000000..71f976329f
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/PoolSelector.cs
@@ -0,0 +1,236 @@
+// 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.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Matchmaking;
+using osu.Game.Overlays;
+using osu.Game.Rulesets;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Queue
+{
+    public partial class PoolSelector : CompositeDrawable
+    {
+        private const float icon_size = 48;
+
+        public readonly Bindable<MatchmakingPool[]> AvailablePools = new Bindable<MatchmakingPool[]>();
+        public readonly Bindable<MatchmakingPool?> SelectedPool = new Bindable<MatchmakingPool?>();
+
+        private FillFlowContainer<SelectorButton> poolFlow = null!;
+
+        public PoolSelector()
+        {
+            AutoSizeAxes = Axes.Both;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            InternalChild = poolFlow = new FillFlowContainer<SelectorButton>
+            {
+                AutoSizeAxes = Axes.X,
+                Height = icon_size * 1.2f,
+                Direction = FillDirection.Horizontal,
+                Spacing = new Vector2(5),
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            AvailablePools.BindValueChanged(pools =>
+            {
+                poolFlow.Clear();
+
+                foreach (var p in pools.NewValue)
+                {
+                    poolFlow.Add(new SelectorButton(p)
+                    {
+                        SelectedPool = { BindTarget = SelectedPool },
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    });
+                }
+            }, true);
+        }
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            var currentSelection = poolFlow.SingleOrDefault(b => b.IsSelected);
+
+            switch (e.Key)
+            {
+                case Key.Left:
+                {
+                    var next = poolFlow.Reverse().SkipWhile(b => b != currentSelection).Skip(1).FirstOrDefault();
+                    (next ?? poolFlow.Last()).TriggerClickWithSound();
+                    return true;
+                }
+
+                case Key.Right:
+                {
+                    var next = poolFlow.SkipWhile(b => b != currentSelection).Skip(1).FirstOrDefault();
+                    (next ?? poolFlow.First()).TriggerClickWithSound();
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private partial class SelectorButton : OsuAnimatedButton
+        {
+            public bool IsSelected => SelectedPool.Value?.Equals(pool) == true;
+
+            public readonly Bindable<MatchmakingPool?> SelectedPool = new Bindable<MatchmakingPool?>();
+
+            [Resolved]
+            private RulesetStore rulesetStore { get; set; } = null!;
+
+            private readonly MatchmakingPool pool;
+            private Drawable iconSprite = null!;
+
+            private Box flashLayer = null!;
+
+            public SelectorButton(MatchmakingPool pool)
+                : base(HoverSampleSet.ButtonSidebar)
+            {
+                this.pool = pool;
+
+                Size = new Vector2(icon_size);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider)
+            {
+                Content.Masking = true;
+                Content.CornerRadius = 20;
+                Content.CornerExponent = 10;
+
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        Colour = colourProvider.Background2,
+                        Alpha = 0.4f,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    flashLayer = new Box
+                    {
+                        Colour = Color4.White,
+                        Blending = BlendingParameters.Additive,
+                        Alpha = 0,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding(10),
+                        Children = new[]
+                        {
+                            iconSprite = createIcon(),
+                        }
+                    },
+                };
+
+                Action = () => SelectedPool.Value = pool;
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                SelectedPool.BindValueChanged(onSelectionChanged, true);
+                FinishTransforms(true);
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                if (!IsSelected)
+                    flashLayer.FadeTo(0.05f, 200, Easing.OutQuint);
+                return base.OnHover(e);
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                if (!IsSelected)
+                    flashLayer.FadeTo(0f, 200, Easing.OutQuint);
+                base.OnHoverLost(e);
+            }
+
+            private void onSelectionChanged(ValueChangedEvent<MatchmakingPool?> selection)
+            {
+                if (IsSelected)
+                {
+                    this.ScaleTo(1.2f, 200, Easing.OutQuint);
+                    iconSprite.FadeColour(Color4.Gold, 100, Easing.OutQuint);
+                    flashLayer.FadeTo(0.1f, 200, Easing.OutQuint);
+                }
+                else
+                {
+                    this.ScaleTo(1f, 200, Easing.OutQuint);
+                    iconSprite.FadeColour(OsuColour.Gray(0.5f), 100);
+                    flashLayer.FadeOut(200, Easing.OutQuint);
+                }
+            }
+
+            private Drawable createIcon()
+            {
+                Ruleset? rulesetInstance = rulesetStore.GetRuleset(pool.RulesetId)?.CreateInstance();
+                if (rulesetInstance == null)
+                    return Empty();
+
+                Drawable icon = rulesetInstance.CreateIcon().With(d => d.RelativeSizeAxes = Axes.Both);
+
+                if (pool.Variant == 0)
+                    return icon;
+
+                return new BufferedContainer(pixelSnapping: true)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new[]
+                    {
+                        icon,
+                        new Container
+                        {
+                            Anchor = Anchor.BottomRight,
+                            Origin = Anchor.BottomRight,
+                            Size = icon_size * new Vector2(0.4f, 0.28f),
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                },
+                                new OsuSpriteText
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Text = $"{pool.Variant}K",
+                                    Font = OsuFont.Default.With(size: icon_size * 0.3f, weight: FontWeight.Bold),
+                                    UseFullGlyphHeight = false,
+                                    Blending = new BlendingParameters
+                                    {
+                                        AlphaEquation = BlendingEquation.ReverseSubtract
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/QueueController.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/QueueController.cs
new file mode 100644
index 0000000000..40ac0e5777
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/QueueController.cs
@@ -0,0 +1,172 @@
+// 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.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Notifications;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Intro;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Queue
+{
+    /// <summary>
+    /// A component which acts as a bridge between the online component (ie <see cref="MultiplayerClient"/>)
+    /// and the visual representations and flow of queueing for matchmaking.
+    ///
+    /// Includes support for deferring to background.
+    /// </summary>
+    /// <remarks>
+    /// This is initialised and cached in the <see cref="ScreenQueue"/> but can be used throughout the system via DI.</remarks>
+    public partial class QueueController : Component
+    {
+        public readonly Bindable<ScreenQueue.MatchmakingScreenState> CurrentState = new Bindable<ScreenQueue.MatchmakingScreenState>();
+
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        [Resolved]
+        private INotificationOverlay? notifications { get; set; }
+
+        [Resolved]
+        private IPerformFromScreenRunner? performer { get; set; }
+
+        private ProgressNotification? backgroundNotification;
+        private Notification? readyNotification;
+        private bool isBackgrounded;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            client.RoomUpdated += onRoomUpdated;
+            client.MatchmakingQueueJoined += onMatchmakingQueueJoined;
+            client.MatchmakingQueueLeft += onMatchmakingQueueLeft;
+            client.MatchmakingRoomInvited += onMatchmakingRoomInvited;
+            client.MatchmakingRoomReady += onMatchmakingRoomReady;
+        }
+
+        public void SearchInBackground()
+        {
+            if (isBackgrounded)
+                return;
+
+            isBackgrounded = true;
+            postNotification();
+        }
+
+        public void SearchInForeground()
+        {
+            if (!isBackgrounded)
+                return;
+
+            isBackgrounded = false;
+            closeNotifications();
+        }
+
+        private void onRoomUpdated() => Scheduler.Add(() =>
+        {
+            if (client.Room == null)
+                CurrentState.Value = ScreenQueue.MatchmakingScreenState.Idle;
+        });
+
+        private void onMatchmakingQueueJoined() => Scheduler.Add(() =>
+        {
+            CurrentState.Value = ScreenQueue.MatchmakingScreenState.Queueing;
+
+            if (isBackgrounded)
+            {
+                closeNotifications();
+                postNotification();
+            }
+        });
+
+        private void onMatchmakingQueueLeft() => Scheduler.Add(() =>
+        {
+            if (CurrentState.Value != ScreenQueue.MatchmakingScreenState.InRoom)
+                CurrentState.Value = ScreenQueue.MatchmakingScreenState.Idle;
+
+            closeNotifications();
+        });
+
+        private void onMatchmakingRoomInvited() => Scheduler.Add(() =>
+        {
+            CurrentState.Value = ScreenQueue.MatchmakingScreenState.PendingAccept;
+
+            if (backgroundNotification != null)
+            {
+                backgroundNotification.State = ProgressNotificationState.Completed;
+                backgroundNotification = null;
+            }
+        });
+
+        private void onMatchmakingRoomReady(long roomId, string password) => Scheduler.Add(() =>
+        {
+            client.JoinRoom(new Room { RoomID = roomId }, password)
+                  .FireAndForget(() => Scheduler.Add(() =>
+                  {
+                      CurrentState.Value = ScreenQueue.MatchmakingScreenState.InRoom;
+                  }));
+        });
+
+        private void postNotification()
+        {
+            if (backgroundNotification != null)
+                return;
+
+            notifications?.Post(backgroundNotification = new ProgressNotification
+            {
+                Text = "Searching for opponents...",
+                CompletionTarget = n => notifications.Post(readyNotification = n),
+                CompletionText = "Your match is ready! Click to join.",
+                CompletionClickAction = () =>
+                {
+                    client.MatchmakingAcceptInvitation().FireAndForget();
+                    performer?.PerformFromScreen(s => s.Push(new IntroScreen()));
+
+                    closeNotifications();
+                    return true;
+                },
+                CancelRequested = () =>
+                {
+                    client.MatchmakingLeaveQueue().FireAndForget();
+
+                    closeNotifications();
+                    return true;
+                }
+            });
+        }
+
+        private void closeNotifications()
+        {
+            if (backgroundNotification != null)
+            {
+                backgroundNotification.State = ProgressNotificationState.Cancelled;
+                backgroundNotification.Close(false);
+            }
+
+            readyNotification?.Close(false);
+
+            backgroundNotification = null;
+            readyNotification = null;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+            {
+                client.RoomUpdated -= onRoomUpdated;
+                client.MatchmakingQueueJoined -= onMatchmakingQueueJoined;
+                client.MatchmakingQueueLeft -= onMatchmakingQueueLeft;
+                client.MatchmakingRoomInvited -= onMatchmakingRoomInvited;
+                client.MatchmakingRoomReady -= onMatchmakingRoomReady;
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/ScreenQueue.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/ScreenQueue.cs
new file mode 100644
index 0000000000..501a46d4c4
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/ScreenQueue.cs
@@ -0,0 +1,486 @@
+// 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 System.Threading;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
+using osu.Framework.Screens;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Input.Bindings;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Matchmaking;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Dialog;
+using osu.Game.Rulesets;
+using osu.Game.Screens.OnlinePlay.Matchmaking.Match;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Matchmaking.Queue
+{
+    /// <summary>
+    /// The initial screen that users arrive at when preparing for a quick play session.
+    /// </summary>
+    public partial class ScreenQueue : OsuScreen
+    {
+        public override bool ShowFooter => true;
+
+        private Container mainContent = null!;
+
+        private MatchmakingScreenState state;
+        private CloudVisualisation cloud = null!;
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        [Resolved]
+        private MultiplayerClient client { get; set; } = null!;
+
+        [Resolved]
+        private IDialogOverlay dialogOverlay { get; set; } = null!;
+
+        [Resolved]
+        private QueueController controller { get; set; } = null!;
+
+        [Resolved]
+        private UserLookupCache userLookupCache { get; set; } = null!;
+
+        [Resolved]
+        private IBindable<RulesetInfo> ruleset { get; set; } = null!;
+
+        private readonly IBindable<MatchmakingScreenState> currentState = new Bindable<MatchmakingScreenState>();
+
+        private readonly Bindable<MatchmakingPool[]> availablePools = new Bindable<MatchmakingPool[]>();
+        private readonly Bindable<MatchmakingPool?> selectedPool = new Bindable<MatchmakingPool?>();
+
+        private CancellationTokenSource userLookupCancellation = new CancellationTokenSource();
+
+        private Sample? matchFoundSample;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            InternalChildren = new Drawable[]
+            {
+                cloud = new CloudVisualisation
+                {
+                    Y = -100,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Size = new Vector2(0.6f)
+                },
+                new MatchmakingAvatar(api.LocalUser.Value, true)
+                {
+                    Y = -100,
+                    Scale = new Vector2(3),
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                },
+                new Container
+                {
+                    RelativePositionAxes = Axes.Y,
+                    Y = 0.25f,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    AutoSizeAxes = Axes.Both,
+                    CornerRadius = 10f,
+                    Masking = true,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = colourProvider.Background3,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        mainContent = new Container
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Alpha = 0,
+                            AutoSizeAxes = Axes.Both,
+                            AutoSizeDuration = 300,
+                            AutoSizeEasing = Easing.OutQuint,
+                            Padding = new MarginPadding(20),
+                        },
+                    }
+                },
+            };
+
+            currentState.BindTo(controller.CurrentState);
+            currentState.BindValueChanged(s => SetState(s.NewValue));
+
+            client.MatchmakingLobbyStatusChanged += onMatchmakingLobbyStatusChanged;
+
+            populateAvailablePools().FireAndForget();
+        }
+
+        private async Task populateAvailablePools()
+        {
+            MatchmakingPool[] pools = await client.GetMatchmakingPools().ConfigureAwait(false);
+
+            Schedule(() =>
+            {
+                availablePools.Value = pools;
+
+                // Default to the user's ruleset for the initial pool selection.
+                selectedPool.Value = pools.FirstOrDefault(p => p.RulesetId == ruleset.Value.OnlineID) ?? pools.FirstOrDefault();
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            matchFoundSample = audio.Samples.Get(@"Multiplayer/Matchmaking/match-found");
+        }
+
+        private void onMatchmakingLobbyStatusChanged(MatchmakingLobbyStatus status) => Scheduler.Add(() =>
+        {
+            userLookupCancellation.Cancel();
+            var cancellation = userLookupCancellation = new CancellationTokenSource();
+
+            userLookupCache.GetUsersAsync(status.UsersInQueue, cancellation.Token)
+                           .ContinueWith(result => Schedule(() =>
+                           {
+                               APIUser?[] users = result.GetResultSafely();
+                               if (!cancellation.IsCancellationRequested)
+                                   Users = users.OfType<APIUser>().ToArray();
+                           }), cancellation.Token);
+        });
+
+        public override void OnEntering(ScreenTransitionEvent e)
+        {
+            base.OnEntering(e);
+
+            controller.SearchInForeground();
+
+            client.MatchmakingJoinLobby().FireAndForget();
+
+            using (BeginDelayedSequence(800))
+                Schedule(() => SetState(currentState.Value));
+        }
+
+        public override void OnResuming(ScreenTransitionEvent e)
+        {
+            base.OnResuming(e);
+
+            client.MatchmakingJoinLobby().FireAndForget();
+        }
+
+        public override void OnSuspending(ScreenTransitionEvent e)
+        {
+            base.OnSuspending(e);
+
+            client.MatchmakingLeaveLobby().FireAndForget();
+        }
+
+        private bool exitConfirmed;
+        private bool isBackgrounded;
+
+        public override bool OnExiting(ScreenExitEvent e)
+        {
+            if (base.OnExiting(e))
+                return true;
+
+            client.MatchmakingLeaveLobby().FireAndForget();
+
+            if (isBackgrounded)
+                return false;
+
+            if (exitConfirmed)
+            {
+                client.MatchmakingLeaveQueue().FireAndForget();
+                return false;
+            }
+
+            if (currentState.Value == MatchmakingScreenState.Idle)
+                return false;
+
+            if (dialogOverlay.CurrentDialog is ConfirmDialog confirmDialog)
+                confirmDialog.PerformOkAction();
+            else
+            {
+                dialogOverlay.Push(new ConfirmDialog("Are you sure you want to leave the matchmaking queue?", () =>
+                {
+                    exitConfirmed = true;
+                    if (this.IsCurrentScreen())
+                        this.Exit();
+                }));
+            }
+
+            return true;
+        }
+
+        public APIUser[] Users
+        {
+            set => cloud.Users = value;
+        }
+
+        public void SetState(MatchmakingScreenState newState)
+        {
+            state = newState;
+
+            mainContent.FadeInFromZero(500, Easing.OutQuint);
+            mainContent.Clear();
+
+            switch (newState)
+            {
+                case MatchmakingScreenState.Idle:
+                    mainContent.Child = new FillFlowContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        AutoSizeAxes = Axes.Both,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(10),
+                        Children = new Drawable[]
+                        {
+                            new PoolSelector
+                            {
+                                Anchor = Anchor.TopCentre,
+                                Origin = Anchor.TopCentre,
+                                AvailablePools = { BindTarget = availablePools },
+                                SelectedPool = { BindTarget = selectedPool }
+                            },
+                            new BeginQueueingButton(200)
+                            {
+                                DarkerColour = colours.Blue2,
+                                LighterColour = colours.Blue1,
+                                Anchor = Anchor.TopCentre,
+                                Origin = Anchor.TopCentre,
+                                SelectedPool = { BindTarget = selectedPool },
+                                Action = () =>
+                                {
+                                    Debug.Assert(selectedPool.Value != null);
+                                    client.MatchmakingJoinQueue(selectedPool.Value.Id).FireAndForget();
+                                },
+                                Text = "Begin queueing",
+                            }
+                        }
+                    };
+                    break;
+
+                case MatchmakingScreenState.Queueing:
+                    ShearedButton sendToBackgroundButton;
+
+                    mainContent.Child = new FillFlowContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        AutoSizeAxes = Axes.Both,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(20),
+                        Children = new Drawable[]
+                        {
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Text = "Waiting for a game...",
+                                Font = OsuFont.GetFont(size: 32, weight: FontWeight.Light, typeface: Typeface.TorusAlternate),
+                            },
+                            new LoadingSpinner
+                            {
+                                State = { Value = Visibility.Visible },
+                            },
+                            sendToBackgroundButton = new ShearedButton(200)
+                            {
+                                DarkerColour = colours.Orange3,
+                                LighterColour = colours.Orange4,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Text = "Queue in background",
+                                Action = () =>
+                                {
+                                    controller.SearchInBackground();
+                                    isBackgrounded = true;
+                                    this.Exit();
+                                },
+                                Enabled = { Value = false },
+                                TooltipText = "Wait 5 seconds for this option to become available."
+                            }
+                        }
+                    };
+
+                    Scheduler.AddDelayed(() =>
+                    {
+                        if (state != newState)
+                            return;
+
+                        sendToBackgroundButton.Enabled.Value = true;
+                        sendToBackgroundButton.TooltipText = "You will receive a notification when your game is ready. Make sure to watch out for it!";
+                    }, 5000);
+                    break;
+
+                case MatchmakingScreenState.PendingAccept:
+                    mainContent.Child = new FillFlowContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        AutoSizeAxes = Axes.Both,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(20),
+                        Children = new Drawable[]
+                        {
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Text = "Found a match!",
+                                Font = OsuFont.GetFont(size: 32, weight: FontWeight.Regular, typeface: Typeface.TorusAlternate),
+                            },
+                            new SelectionButton(200)
+                            {
+                                DarkerColour = colours.YellowDark,
+                                LighterColour = colours.YellowLight,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Action = () =>
+                                {
+                                    client.MatchmakingAcceptInvitation().FireAndForget();
+                                    SetState(MatchmakingScreenState.AcceptedWaitingForRoom);
+                                },
+                                Text = "Join match!",
+                            }
+                        }
+                    };
+                    matchFoundSample?.Play();
+                    break;
+
+                case MatchmakingScreenState.AcceptedWaitingForRoom:
+                    mainContent.Child = new FillFlowContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        AutoSizeAxes = Axes.Both,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(20),
+                        Children = new Drawable[]
+                        {
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Text = "Waiting for all players...",
+                                Font = OsuFont.GetFont(size: 32, weight: FontWeight.Light, typeface: Typeface.TorusAlternate),
+                            },
+                            new LoadingSpinner
+                            {
+                                State = { Value = Visibility.Visible },
+                            },
+                        }
+                    };
+                    break;
+
+                case MatchmakingScreenState.InRoom:
+                    // room received, show users and transition to next screen.
+                    mainContent.Child = new FillFlowContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        AutoSizeAxes = Axes.Both,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(20),
+                        Children = new Drawable[]
+                        {
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Text = "Good luck!",
+                                Font = OsuFont.GetFont(size: 32, weight: FontWeight.Light, typeface: Typeface.TorusAlternate),
+                            },
+                        }
+                    };
+
+                    using (BeginDelayedSequence(2000))
+                        Schedule(() => this.Push(new ScreenMatchmaking(client.Room!)));
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(newState), newState, null);
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (client.IsNotNull())
+                client.MatchmakingLobbyStatusChanged -= onMatchmakingLobbyStatusChanged;
+        }
+
+        public enum MatchmakingScreenState
+        {
+            Idle,
+            Queueing,
+            PendingAccept,
+            AcceptedWaitingForRoom,
+            InRoom
+        }
+
+        private partial class BeginQueueingButton : SelectionButton
+        {
+            public readonly IBindable<MatchmakingPool?> SelectedPool = new Bindable<MatchmakingPool?>();
+
+            public BeginQueueingButton(float? width = null)
+                : base(width)
+            {
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                SelectedPool.BindValueChanged(p => Enabled.Value = p.NewValue != null, true);
+            }
+        }
+
+        private partial class SelectionButton : ShearedButton, IKeyBindingHandler<GlobalAction>
+        {
+            public SelectionButton(float? width = null, float height = DEFAULT_HEIGHT)
+                : base(width, height)
+            {
+            }
+
+            public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+            {
+                if (e.Action == GlobalAction.Select && !e.Repeat)
+                {
+                    TriggerClickWithSound();
+                    return true;
+                }
+
+                return false;
+            }
+
+            public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+            {
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
index 689a8df12f..bbac86fd2d 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
@@ -280,7 +280,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                                                                             new AddItemButton
                                                                             {
                                                                                 RelativeSizeAxes = Axes.X,
-                                                                                Height = 40,
+                                                                                Height = 30,
                                                                                 Text = "Add item",
                                                                                 Action = () => ShowSongSelect()
                                                                             },
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs
index 9083a21704..a001863780 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayer.cs
@@ -70,6 +70,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             if (!LoadedBeatmapSuccessfully)
                 return;
 
+            // also applied in `MultiSpectatorPlayer.load()`
             ScoreProcessor.ApplyNewJudgementsWhenFailed = true;
 
             LoadComponentAsync(new FillFlowContainer
@@ -170,6 +171,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         protected override void PerformFail()
         {
             // base logic intentionally suppressed - failing in multiplayer only marks the score with F rank
+            // see also: `MultiSpectatorPlayer.PerformFail()`
             ScoreProcessor.FailScore(Score.ScoreInfo);
         }
 
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantsList.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantsList.cs
index b553fcc9cd..7429fc817c 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantsList.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Participants/ParticipantsList.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Participants
         private MultiplayerClient client { get; set; } = null!;
 
         public ParticipantsList()
-            : base(ParticipantPanel.HEIGHT, initialPoolSize: 20)
+            : base(ParticipantPanel.HEIGHT + 1, initialPoolSize: 20)
         {
         }
 
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorPlayer.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorPlayer.cs
index 8526e11e12..0dd547bfbb 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorPlayer.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorPlayer.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.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -42,6 +43,12 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             if (cancellationToken.IsCancellationRequested)
                 return;
 
+            if (!LoadedBeatmapSuccessfully)
+                return;
+
+            // also applied in `MultiplayerPlayer.load()`
+            ScoreProcessor.ApplyNewJudgementsWhenFailed = true;
+
             HUDOverlay.PlayerSettingsOverlay.Expire();
             HUDOverlay.HoldToQuit.Expire();
         }
@@ -76,5 +83,15 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         }
 
         protected override ResultsScreen CreateResults(ScoreInfo score) => new MultiSpectatorResultsScreen(score);
+
+        protected override void PerformFail()
+        {
+            // base logic intentionally suppressed - failing in multiplayer only marks the score with F rank
+            // see also: `MultiplayerPlayer.PerformFail()`
+            ScoreProcessor.FailScore(Score.ScoreInfo);
+        }
+
+        protected override void ConcludeFailedScore(Score score)
+            => throw new NotSupportedException($"{nameof(MultiSpectatorPlayer)} should never be calling {nameof(ConcludeFailedScore)}. Failing in multiplayer only marks the score with F rank.");
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
index 1f96f0d371..200e6a715d 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
@@ -178,17 +178,31 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         {
             base.Update();
 
-            if (!isCandidateAudioSource(currentAudioSource?.SpectatorPlayerClock))
-            {
-                currentAudioSource = instances.Where(i => isCandidateAudioSource(i.SpectatorPlayerClock)).MinBy(i => Math.Abs(i.SpectatorPlayerClock.CurrentTime - syncManager.CurrentMasterTime));
+            checkAudioSource();
+        }
 
-                // Only bind adjustments if there's actually a valid source, else just use the previous ones to ensure no sudden changes to audio.
-                if (currentAudioSource != null)
-                    bindAudioAdjustments(currentAudioSource);
+        private void checkAudioSource()
+        {
+            // always use the maximised player instance as the current audio source if there is one
+            if (grid.MaximisedCell?.Content is PlayerArea maximisedPlayer && maximisedPlayer == currentAudioSource)
+                return;
 
-                foreach (var instance in instances)
-                    instance.Mute = instance != currentAudioSource;
-            }
+            // if there is no maximised player instance and the previous audio source is still good to use, keep using it
+            if (grid.MaximisedCell == null && isCandidateAudioSource(currentAudioSource?.SpectatorPlayerClock))
+                return;
+
+            // at this point we're in one of the following scenarios:
+            // - the maximised player instance is not the current audio source => we want to switch to the maximised player instance
+            // - there is no maximised player instance, and the previous audio source is stopped => find another running audio source
+            currentAudioSource = grid.MaximisedCell?.Content as PlayerArea
+                                 ?? instances.Where(i => isCandidateAudioSource(i.SpectatorPlayerClock)).MinBy(i => Math.Abs(i.SpectatorPlayerClock.CurrentTime - syncManager.CurrentMasterTime));
+
+            // Only bind adjustments if there's actually a valid source, else just use the previous ones to ensure no sudden changes to audio.
+            if (currentAudioSource != null)
+                bindAudioAdjustments(currentAudioSource);
+
+            foreach (var instance in instances)
+                instance.Mute = instance != currentAudioSource;
         }
 
         private void bindAudioAdjustments(PlayerArea first)
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid_Cell.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.Cell.cs
similarity index 93%
rename from osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid_Cell.cs
rename to osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.Cell.cs
index bc31299615..d1ba214117 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid_Cell.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.Cell.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         /// <summary>
         /// A cell of the grid. Contains the content and tracks to the linked facade.
         /// </summary>
-        private partial class Cell : CompositeDrawable
+        public partial class Cell : CompositeDrawable
         {
             /// <summary>
             /// The index of the original facade of this cell.
@@ -33,11 +33,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             /// </summary>
             public Action<Cell>? ToggleMaximisationState;
 
-            /// <summary>
-            /// Whether this cell is currently maximised.
-            /// </summary>
-            public bool IsMaximised { get; private set; }
-
             private Facade facade;
 
             private bool isAnimating;
@@ -83,7 +78,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             public void SetFacade(Facade newFacade, bool isMaximised)
             {
                 facade = newFacade;
-                IsMaximised = isMaximised;
                 isAnimating = true;
 
                 TweenEdgeEffectTo(new EdgeEffectParameters
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.cs
index 6e71c010e5..c3ad14dba2 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerGrid.cs
@@ -31,6 +31,11 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         /// </summary>
         public Facade MaximisedFacade { get; }
 
+        /// <summary>
+        /// The currently-maximised cell.
+        /// </summary>
+        public Cell? MaximisedCell { get; private set; }
+
         private readonly Container paddingContainer;
         private readonly FillFlowContainer<Facade> facadeContainer;
         private readonly Container<Cell> cellContainer;
@@ -99,7 +104,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
         private void toggleMaximisationState(Cell target)
         {
             // in the case the target is the already maximised cell (or there is only one cell), no cell should be maximised.
-            bool hasMaximised = !target.IsMaximised && cellContainer.Count > 1;
+            bool hasMaximised = target != MaximisedCell && cellContainer.Count > 1;
+            MaximisedCell = hasMaximised ? target : null;
 
             // Iterate through all cells to ensure only one is maximised at any time.
             foreach (var cell in cellContainer.ToList())
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
index 5b42bcf254..fdda6f6c85 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
@@ -13,6 +13,7 @@ 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.Logging;
 using osu.Framework.Screens;
@@ -164,225 +165,229 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             InternalChild = new OsuContextMenuContainer
             {
                 RelativeSizeAxes = Axes.Both,
-                Children = new Drawable[]
+                Child = new PopoverContainer
                 {
-                    roomUpdater = new PlaylistsRoomUpdater(room),
-                    beatmapAvailabilityTracker,
-                    new MultiplayerRoomSounds(),
-                    new Container
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
                     {
-                        RelativeSizeAxes = Axes.Both,
-                        Padding = new MarginPadding
+                        roomUpdater = new PlaylistsRoomUpdater(room),
+                        beatmapAvailabilityTracker,
+                        new MultiplayerRoomSounds(),
+                        new Container
                         {
-                            Horizontal = WaveOverlayContainer.WIDTH_PADDING,
-                            Bottom = footer_height + footer_padding
-                        },
-                        Children = new[]
-                        {
-                            roomContent = new GridContainer
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding
                             {
-                                RelativeSizeAxes = Axes.Both,
-                                RowDimensions = new[]
+                                Horizontal = WaveOverlayContainer.WIDTH_PADDING,
+                                Bottom = footer_height + footer_padding
+                            },
+                            Children = new[]
+                            {
+                                roomContent = new GridContainer
                                 {
-                                    new Dimension(GridSizeMode.AutoSize),
-                                    new Dimension(GridSizeMode.Absolute, row_padding),
-                                },
-                                Content = new[]
-                                {
-                                    new Drawable[]
+                                    RelativeSizeAxes = Axes.Both,
+                                    RowDimensions = new[]
                                     {
-                                        new PlaylistsRoomPanel(room)
-                                        {
-                                            SelectedItem = SelectedItem
-                                        }
+                                        new Dimension(GridSizeMode.AutoSize),
+                                        new Dimension(GridSizeMode.Absolute, row_padding),
                                     },
-                                    null,
-                                    new Drawable[]
+                                    Content = new[]
                                     {
-                                        new Container
+                                        new Drawable[]
                                         {
-                                            RelativeSizeAxes = Axes.Both,
-                                            Masking = true,
-                                            CornerRadius = 10,
-                                            Children = new Drawable[]
+                                            new PlaylistsRoomPanel(room)
                                             {
-                                                new Box
+                                                SelectedItem = SelectedItem
+                                            }
+                                        },
+                                        null,
+                                        new Drawable[]
+                                        {
+                                            new Container
+                                            {
+                                                RelativeSizeAxes = Axes.Both,
+                                                Masking = true,
+                                                CornerRadius = 10,
+                                                Children = new Drawable[]
                                                 {
-                                                    RelativeSizeAxes = Axes.Both,
-                                                    Colour = Color4Extensions.FromHex(@"3e3a44") // Temporary.
-                                                },
-                                                new GridContainer
-                                                {
-                                                    RelativeSizeAxes = Axes.Both,
-                                                    Padding = new MarginPadding(content_padding),
-                                                    ColumnDimensions = new[]
+                                                    new Box
                                                     {
-                                                        new Dimension(),
-                                                        new Dimension(GridSizeMode.Absolute, column_padding),
-                                                        new Dimension(),
-                                                        new Dimension(GridSizeMode.Absolute, column_padding),
-                                                        new Dimension(),
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Colour = Color4Extensions.FromHex(@"3e3a44") // Temporary.
                                                     },
-                                                    Content = new[]
+                                                    new GridContainer
                                                     {
-                                                        new Drawable?[]
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Padding = new MarginPadding(content_padding),
+                                                        ColumnDimensions = new[]
                                                         {
-                                                            new GridContainer
+                                                            new Dimension(),
+                                                            new Dimension(GridSizeMode.Absolute, column_padding),
+                                                            new Dimension(),
+                                                            new Dimension(GridSizeMode.Absolute, column_padding),
+                                                            new Dimension(),
+                                                        },
+                                                        Content = new[]
+                                                        {
+                                                            new Drawable?[]
                                                             {
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                RowDimensions = new[]
+                                                                new GridContainer
                                                                 {
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                    new Dimension(),
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                },
-                                                                Content = new[]
-                                                                {
-                                                                    new Drawable[]
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    RowDimensions = new[]
                                                                     {
-                                                                        new OverlinedPlaylistHeader(room),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(),
+                                                                        new Dimension(GridSizeMode.AutoSize),
                                                                     },
-                                                                    new Drawable[]
+                                                                    Content = new[]
                                                                     {
-                                                                        drawablePlaylist = new DrawableRoomPlaylist
+                                                                        new Drawable[]
                                                                         {
-                                                                            RelativeSizeAxes = Axes.Both,
-                                                                            SelectedItem = { BindTarget = SelectedItem },
-                                                                            AllowSelection = true,
-                                                                            AllowShowingResults = true,
-                                                                            RequestResults = showResults
-                                                                        }
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        new AddPlaylistToCollectionButton(room)
+                                                                            new OverlinedPlaylistHeader(room),
+                                                                        },
+                                                                        new Drawable[]
                                                                         {
-                                                                            Margin = new MarginPadding { Top = 5 },
-                                                                            RelativeSizeAxes = Axes.X,
-                                                                            Size = new Vector2(1, 40)
+                                                                            drawablePlaylist = new DrawableRoomPlaylist
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.Both,
+                                                                                SelectedItem = { BindTarget = SelectedItem },
+                                                                                AllowSelection = true,
+                                                                                AllowShowingResults = true,
+                                                                                RequestResults = showResults
+                                                                            }
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new AddPlaylistToCollectionButton(room)
+                                                                            {
+                                                                                Margin = new MarginPadding { Top = 5 },
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                Size = new Vector2(1, 40)
+                                                                            }
                                                                         }
                                                                     }
-                                                                }
-                                                            },
-                                                            null,
-                                                            new GridContainer
-                                                            {
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                RowDimensions = new[]
-                                                                {
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                    new Dimension(GridSizeMode.AutoSize),
-                                                                    new Dimension(GridSizeMode.AutoSize),
                                                                 },
-                                                                Content = new[]
+                                                                null,
+                                                                new GridContainer
                                                                 {
-                                                                    new Drawable[]
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    RowDimensions = new[]
                                                                     {
-                                                                        userModsSection = new FillFlowContainer
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                        new Dimension(GridSizeMode.AutoSize),
+                                                                    },
+                                                                    Content = new[]
+                                                                    {
+                                                                        new Drawable[]
                                                                         {
-                                                                            RelativeSizeAxes = Axes.X,
-                                                                            AutoSizeAxes = Axes.Y,
-                                                                            Margin = new MarginPadding { Bottom = row_padding },
-                                                                            Alpha = 0,
-                                                                            Children = new Drawable[]
+                                                                            userModsSection = new FillFlowContainer
                                                                             {
-                                                                                new OverlinedHeader("Extra mods"),
-                                                                                new FillFlowContainer
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                AutoSizeAxes = Axes.Y,
+                                                                                Margin = new MarginPadding { Bottom = row_padding },
+                                                                                Alpha = 0,
+                                                                                Children = new Drawable[]
                                                                                 {
-                                                                                    AutoSizeAxes = Axes.Both,
-                                                                                    Direction = FillDirection.Horizontal,
-                                                                                    Spacing = new Vector2(10, 0),
-                                                                                    Children = new Drawable[]
+                                                                                    new OverlinedHeader("Extra mods"),
+                                                                                    new FillFlowContainer
                                                                                     {
-                                                                                        new UserModSelectButton
+                                                                                        AutoSizeAxes = Axes.Both,
+                                                                                        Direction = FillDirection.Horizontal,
+                                                                                        Spacing = new Vector2(10, 0),
+                                                                                        Children = new Drawable[]
                                                                                         {
-                                                                                            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 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 Drawable[]
-                                                                    {
-                                                                        userStyleSection = new FillFlowContainer
+                                                                        },
+                                                                        new Drawable[]
                                                                         {
-                                                                            RelativeSizeAxes = Axes.X,
-                                                                            AutoSizeAxes = Axes.Y,
-                                                                            Margin = new MarginPadding { Bottom = row_padding },
-                                                                            Alpha = 0,
-                                                                            Children = new Drawable[]
+                                                                            userStyleSection = new FillFlowContainer
                                                                             {
-                                                                                new OverlinedHeader("Difficulty"),
-                                                                                userStyleDisplayContainer = new Container<DrawableRoomPlaylistItem>
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                AutoSizeAxes = Axes.Y,
+                                                                                Margin = new MarginPadding { Bottom = row_padding },
+                                                                                Alpha = 0,
+                                                                                Children = new Drawable[]
                                                                                 {
-                                                                                    RelativeSizeAxes = Axes.X,
-                                                                                    AutoSizeAxes = Axes.Y
+                                                                                    new OverlinedHeader("Difficulty"),
+                                                                                    userStyleDisplayContainer = new Container<DrawableRoomPlaylistItem>
+                                                                                    {
+                                                                                        RelativeSizeAxes = Axes.X,
+                                                                                        AutoSizeAxes = Axes.Y
+                                                                                    }
                                                                                 }
                                                                             }
-                                                                        }
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        progressSection = new FillFlowContainer
-                                                                        {
-                                                                            RelativeSizeAxes = Axes.X,
-                                                                            AutoSizeAxes = Axes.Y,
-                                                                            Margin = new MarginPadding { Bottom = row_padding },
-                                                                            Alpha = 0,
-                                                                            Direction = FillDirection.Vertical,
-                                                                            Children = new Drawable[]
-                                                                            {
-                                                                                new OverlinedHeader("Progress"),
-                                                                                new RoomLocalUserInfo(room),
-                                                                            }
-                                                                        }
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        new OverlinedHeader("Leaderboard")
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        leaderboard = new MatchLeaderboard(room)
-                                                                        {
-                                                                            RelativeSizeAxes = Axes.Both
                                                                         },
-                                                                    }
-                                                                }
-                                                            },
-                                                            null,
-                                                            new GridContainer
-                                                            {
-                                                                RelativeSizeAxes = Axes.Both,
-                                                                RowDimensions = new[]
-                                                                {
-                                                                    new Dimension(GridSizeMode.AutoSize)
-                                                                },
-                                                                Content = new[]
-                                                                {
-                                                                    new Drawable[]
-                                                                    {
-                                                                        new OverlinedHeader("Chat")
-                                                                    },
-                                                                    new Drawable[]
-                                                                    {
-                                                                        new MatchChatDisplay(room)
+                                                                        new Drawable[]
                                                                         {
-                                                                            RelativeSizeAxes = Axes.Both
+                                                                            progressSection = new FillFlowContainer
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.X,
+                                                                                AutoSizeAxes = Axes.Y,
+                                                                                Margin = new MarginPadding { Bottom = row_padding },
+                                                                                Alpha = 0,
+                                                                                Direction = FillDirection.Vertical,
+                                                                                Children = new Drawable[]
+                                                                                {
+                                                                                    new OverlinedHeader("Progress"),
+                                                                                    new RoomLocalUserInfo(room),
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            new OverlinedHeader("Leaderboard")
+                                                                        },
+                                                                        new Drawable[]
+                                                                        {
+                                                                            leaderboard = new MatchLeaderboard(room)
+                                                                            {
+                                                                                RelativeSizeAxes = Axes.Both
+                                                                            },
+                                                                        }
+                                                                    }
+                                                                },
+                                                                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
+                                                                            }
                                                                         }
                                                                     }
                                                                 }
@@ -393,39 +398,39 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                                             }
                                         }
                                     }
-                                }
-                            },
-                            settingsOverlay = new PlaylistsRoomSettingsOverlay(room)
-                            {
-                                EditPlaylist = () =>
+                                },
+                                settingsOverlay = new PlaylistsRoomSettingsOverlay(room)
                                 {
-                                    if (this.IsCurrentScreen())
-                                        this.Push(new PlaylistsSongSelect(room));
+                                    EditPlaylist = () =>
+                                    {
+                                        if (this.IsCurrentScreen())
+                                            this.Push(new PlaylistsSongSelect(room));
+                                    }
                                 }
                             }
-                        }
-                    },
-                    new Container
-                    {
-                        Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.BottomLeft,
-                        RelativeSizeAxes = Axes.X,
-                        Height = footer_height,
-                        Children = new Drawable[]
+                        },
+                        new Container
                         {
-                            new Box
+                            Anchor = Anchor.BottomLeft,
+                            Origin = Anchor.BottomLeft,
+                            RelativeSizeAxes = Axes.X,
+                            Height = footer_height,
+                            Children = new Drawable[]
                             {
-                                RelativeSizeAxes = Axes.Both,
-                                Colour = Color4Extensions.FromHex(@"28242d") // Temporary.
-                            },
-                            new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Padding = new MarginPadding(5),
-                                Child = new PlaylistsRoomFooter(room)
+                                new Box
                                 {
-                                    OnStart = startPlay,
-                                    OnClose = closePlaylist
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4Extensions.FromHex(@"28242d") // Temporary.
+                                },
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding(5),
+                                    Child = new PlaylistsRoomFooter(room)
+                                    {
+                                        OnStart = startPlay,
+                                        OnClose = closePlaylist
+                                    }
                                 }
                             }
                         }
diff --git a/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs b/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs
index bd8f17185b..d55bf46f97 100644
--- a/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonCounterTextComponent.cs
@@ -15,6 +15,7 @@ using osu.Framework.Text;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Screens.Play.HUD
 {
@@ -26,6 +27,8 @@ namespace osu.Game.Screens.Play.HUD
 
         public IBindable<float> WireframeOpacity { get; } = new BindableFloat();
         public Bindable<bool> ShowLabel { get; } = new BindableBool();
+        public Bindable<Color4> LabelColour { get; } = new Bindable<Color4>(Color4.White);
+        public Bindable<Color4> TextColour { get; } = new Bindable<Color4>(Color4.White);
 
         public Container NumberContainer { get; private set; }
 
@@ -58,7 +61,6 @@ namespace osu.Game.Screens.Play.HUD
                 labelText = new OsuSpriteText
                 {
                     Alpha = 0,
-                    BypassAutoSizeAxes = Axes.X,
                     Text = label.GetValueOrDefault(),
                     Font = OsuFont.Torus.With(size: 12, weight: FontWeight.Bold),
                     Margin = new MarginPadding { Left = 2.5f },
@@ -72,13 +74,13 @@ namespace osu.Game.Screens.Play.HUD
                     {
                         wireframesPart = new ArgonCounterSpriteText(wireframesLookup)
                         {
-                            Anchor = anchor,
-                            Origin = anchor,
+                            Anchor = Anchor.TopRight,
+                            Origin = Anchor.TopRight,
                         },
                         textPart = new ArgonCounterSpriteText(textLookup)
                         {
-                            Anchor = anchor,
-                            Origin = anchor,
+                            Anchor = Anchor.TopRight,
+                            Origin = Anchor.TopRight,
                         },
                     }
                 }
@@ -110,7 +112,7 @@ namespace osu.Game.Screens.Play.HUD
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            labelText.Colour = colours.Blue0;
+            LabelColour.Value = colours.Blue0;
         }
 
         protected override void LoadComplete()
@@ -122,6 +124,12 @@ namespace osu.Game.Screens.Play.HUD
                 labelText.Alpha = s.NewValue ? 1 : 0;
                 NumberContainer.Y = s.NewValue ? 12 : 0;
             }, true);
+            LabelColour.BindValueChanged(c => labelText.Colour = c.NewValue, true);
+            TextColour.BindValueChanged(c =>
+            {
+                textPart.Colour = c.NewValue;
+                wireframesPart.Colour = c.NewValue;
+            }, true);
         }
 
         private partial class ArgonCounterSpriteText : OsuSpriteText
diff --git a/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs b/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
index f184ad6a03..d768fedca4 100644
--- a/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/DefaultRankDisplay.cs
@@ -19,22 +19,25 @@ namespace osu.Game.Screens.Play.HUD
 {
     public partial class DefaultRankDisplay : CompositeDrawable, ISerialisableDrawable
     {
+        public bool UsesFixedAnchor { get; set; }
+
         [Resolved]
         private ScoreProcessor scoreProcessor { get; set; } = null!;
 
         [SettingSource(typeof(DefaultRankDisplayStrings), nameof(DefaultRankDisplayStrings.PlaySamplesOnRankChange))]
         public BindableBool PlaySamples { get; set; } = new BindableBool(true);
 
-        public bool UsesFixedAnchor { get; set; }
-
         private UpdateableRank rankDisplay = null!;
 
         private SkinnableSound rankDownSample = null!;
         private SkinnableSound rankUpSample = null!;
 
-        private Bindable<double?> lastSamplePlaybackTime = null!;
+        private Bindable<double?> lastSamplePlayback = null!;
+        private double lastChangeTime;
 
-        private IBindable<ScoreRank> rank = null!;
+        private ScoreRank? displayedRank;
+
+        private const int time_between_changes = 1500;
 
         public DefaultRankDisplay()
         {
@@ -48,7 +51,7 @@ namespace osu.Game.Screens.Play.HUD
             {
                 rankDownSample = new SkinnableSound(new SampleInfo("Gameplay/rank-down")),
                 rankUpSample = new SkinnableSound(new SampleInfo("Gameplay/rank-up")),
-                rankDisplay = new UpdateableRank(ScoreRank.X)
+                rankDisplay = new UpdateableRank
                 {
                     RelativeSizeAxes = Axes.Both
                 },
@@ -57,31 +60,49 @@ namespace osu.Game.Screens.Play.HUD
             if (skinEditor != null)
                 PlaySamples.Value = false;
 
-            lastSamplePlaybackTime = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
+            lastSamplePlayback = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            rank = scoreProcessor.Rank.GetBoundCopy();
-            rank.BindValueChanged(r =>
+            updateRank(scoreProcessor.Rank.Value);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            var currentRank = scoreProcessor.Rank.Value;
+
+            if (currentRank == displayedRank)
+                return;
+
+            if (Time.Current - lastChangeTime >= time_between_changes || scoreProcessor.HasCompleted.Value || currentRank == ScoreRank.F)
+                updateRank(currentRank);
+        }
+
+        private void updateRank(ScoreRank rank)
+        {
+            rankDisplay.Rank = rank;
+
+            // Check sample time separately to ensure two copies of the rank display don't both play samples on a change.
+            bool enoughSampleTimeElapsed = !lastSamplePlayback.Value.HasValue || Time.Current - lastSamplePlayback.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
+
+            // Also don't play rank-down sfx on quit/retry/initial update.
+            if (displayedRank != null && rank > ScoreRank.F && PlaySamples.Value && enoughSampleTimeElapsed)
             {
-                bool enoughTimeElapsed = !lastSamplePlaybackTime.Value.HasValue || Time.Current - lastSamplePlaybackTime.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
+                if (rank > displayedRank)
+                    rankUpSample.Play();
+                else
+                    rankDownSample.Play();
 
-                // Don't play rank-down sfx on quit/retry
-                if (r.NewValue != r.OldValue && r.NewValue > ScoreRank.F && PlaySamples.Value && enoughTimeElapsed)
-                {
-                    if (r.NewValue > rankDisplay.Rank)
-                        rankUpSample.Play();
-                    else
-                        rankDownSample.Play();
+                lastSamplePlayback.Value = Time.Current;
+            }
 
-                    lastSamplePlaybackTime.Value = Time.Current;
-                }
-
-                rankDisplay.Rank = r.NewValue;
-            }, true);
+            displayedRank = rank;
+            lastChangeTime = Time.Current;
         }
     }
 }
diff --git a/osu.Game/Screens/Play/SoloSpectatorPlayer.cs b/osu.Game/Screens/Play/SoloSpectatorPlayer.cs
index be83a4c6b5..87d77db847 100644
--- a/osu.Game/Screens/Play/SoloSpectatorPlayer.cs
+++ b/osu.Game/Screens/Play/SoloSpectatorPlayer.cs
@@ -45,6 +45,26 @@ namespace osu.Game.Screens.Play
             });
         }
 
+        #region Fail handling
+
+        protected override bool CheckModsAllowFailure()
+        {
+            if (!allowFail)
+                return false;
+
+            return base.CheckModsAllowFailure();
+        }
+
+        private bool allowFail;
+
+        /// <summary>
+        /// Should be called when it is apparent that the player being spectated has failed.
+        /// This will subsequently stop blocking the fail screen from displaying (usually done out of safety).
+        /// </summary>
+        public void AllowFail() => allowFail = true;
+
+        #endregion
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
diff --git a/osu.Game/Screens/Play/SoloSpectatorScreen.cs b/osu.Game/Screens/Play/SoloSpectatorScreen.cs
index 269bc3bb92..75f8da707c 100644
--- a/osu.Game/Screens/Play/SoloSpectatorScreen.cs
+++ b/osu.Game/Screens/Play/SoloSpectatorScreen.cs
@@ -183,7 +183,7 @@ namespace osu.Game.Screens.Play
         {
             if (this.GetChildScreen() is SpectatorPlayerLoader loader)
             {
-                if (loader.GetChildScreen() is SpectatorPlayer player)
+                if (loader.GetChildScreen() is SoloSpectatorPlayer player)
                 {
                     player.AllowFail();
                     resetStartState();
diff --git a/osu.Game/Screens/Play/SpectatorPlayer.cs b/osu.Game/Screens/Play/SpectatorPlayer.cs
index 6bfb6e033a..4bd9bfafc0 100644
--- a/osu.Game/Screens/Play/SpectatorPlayer.cs
+++ b/osu.Game/Screens/Play/SpectatorPlayer.cs
@@ -29,16 +29,6 @@ namespace osu.Game.Screens.Play
 
         private readonly Score score;
 
-        protected override bool CheckModsAllowFailure()
-        {
-            if (!allowFail)
-                return false;
-
-            return base.CheckModsAllowFailure();
-        }
-
-        private bool allowFail;
-
         protected SpectatorPlayer(Score score, PlayerConfiguration? configuration = null)
             : base(configuration)
         {
@@ -72,12 +62,6 @@ namespace osu.Game.Screens.Play
             }, true);
         }
 
-        /// <summary>
-        /// Should be called when it is apparent that the player being spectated has failed.
-        /// This will subsequently stop blocking the fail screen from displaying (usually done out of safety).
-        /// </summary>
-        public void AllowFail() => allowFail = true;
-
         protected override void StartGameplay()
         {
             base.StartGameplay();
diff --git a/osu.Game/Screens/Ranking/Expanded/Accuracy/RankText.cs b/osu.Game/Screens/Ranking/Expanded/Accuracy/RankText.cs
index 76e59b32b8..ce8bd941c2 100644
--- a/osu.Game/Screens/Ranking/Expanded/Accuracy/RankText.cs
+++ b/osu.Game/Screens/Ranking/Expanded/Accuracy/RankText.cs
@@ -47,7 +47,7 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
                     Origin = Anchor.Centre,
                     GlowColour = OsuColour.ForRank(rank),
                     Spacing = new Vector2(-15, 0),
-                    Text = DrawableRank.GetRankName(rank),
+                    Text = DrawableRank.GetRankLetter(rank),
                     Font = OsuFont.Numeric.With(size: 76),
                     UseFullGlyphHeight = false
                 },
@@ -87,7 +87,7 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
                             Spacing = new Vector2(-15, 0),
-                            Text = DrawableRank.GetRankName(rank),
+                            Text = DrawableRank.GetRankLetter(rank),
                             Font = OsuFont.Numeric.With(size: 76),
                             UseFullGlyphHeight = false,
                             Shadow = false
diff --git a/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs b/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs
index 3c1aec745d..5c5c814c5b 100644
--- a/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs
+++ b/osu.Game/Screens/Ranking/Statistics/StatisticsPanel.cs
@@ -19,7 +19,6 @@ using osu.Game.Extensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Models;
 using osu.Game.Online.API;
 using osu.Game.Online.Placeholders;
 using osu.Game.Scoring;
@@ -246,11 +245,8 @@ namespace osu.Game.Screens.Ranking.Statistics
                 // We may want to iterate on the following conditions further in the future
 
                 var localUserScore = AchievedScore ?? realm.Run(r =>
-                    r.All<ScoreInfo>()
-                     .Filter($@"{nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} == $0"
-                             + $@" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $1"
-                             + $@" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
-                             + $@" && {nameof(ScoreInfo.DeletePending)} == false", api.LocalUser.Value.Id, newScore.BeatmapInfo.ID, newScore.BeatmapInfo.Ruleset.ShortName)
+                    r.GetAllLocalScoresForUser(api.LocalUser.Value.Id)
+                     .Filter($@"{nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $0", newScore.BeatmapInfo.ID)
                      .AsEnumerable()
                      .OrderByDescending(score => score.Ruleset.MatchesOnlineID(newScore.BeatmapInfo.Ruleset))
                      .ThenByDescending(score => score.Rank)
diff --git a/osu.Game/Screens/Ranking/UserTagControl_AddTagsPopover.cs b/osu.Game/Screens/Ranking/UserTagControl.AddTagsPopover.cs
similarity index 100%
rename from osu.Game/Screens/Ranking/UserTagControl_AddTagsPopover.cs
rename to osu.Game/Screens/Ranking/UserTagControl.AddTagsPopover.cs
diff --git a/osu.Game/Screens/Ranking/UserTagControl_DrawableUserTag.cs b/osu.Game/Screens/Ranking/UserTagControl.DrawableUserTag.cs
similarity index 100%
rename from osu.Game/Screens/Ranking/UserTagControl_DrawableUserTag.cs
rename to osu.Game/Screens/Ranking/UserTagControl.DrawableUserTag.cs
diff --git a/osu.Game/Screens/Select/Carousel/TopLocalRank.cs b/osu.Game/Screens/Select/Carousel/TopLocalRank.cs
index da9661f702..6f1f2e8370 100644
--- a/osu.Game/Screens/Select/Carousel/TopLocalRank.cs
+++ b/osu.Game/Screens/Select/Carousel/TopLocalRank.cs
@@ -9,7 +9,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
-using osu.Game.Models;
 using osu.Game.Online.API;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Rulesets;
@@ -59,12 +58,9 @@ namespace osu.Game.Screens.Select.Carousel
             {
                 scoreSubscription?.Dispose();
                 scoreSubscription = realm.RegisterForNotifications(r =>
-                        r.All<ScoreInfo>()
-                         .Filter($"{nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} == $0"
-                                 + $" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $1"
-                                 + $" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
-                                 + $" && {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $2"
-                                 + $" && {nameof(ScoreInfo.DeletePending)} == false", api.LocalUser.Value.Id, beatmapInfo.ID, ruleset.Value.ShortName),
+                        r.GetAllLocalScoresForUser(api.LocalUser.Value.Id)
+                         .Filter($@"{nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $0"
+                                 + $" && {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $1", beatmapInfo.ID, ruleset.Value.ShortName),
                     localScoresChanged);
             }, true);
 
diff --git a/osu.Game/Screens/Select/FilterQueryParser.cs b/osu.Game/Screens/Select/FilterQueryParser.cs
index 7d66a61884..8cf3bda1c5 100644
--- a/osu.Game/Screens/Select/FilterQueryParser.cs
+++ b/osu.Game/Screens/Select/FilterQueryParser.cs
@@ -57,7 +57,7 @@ namespace osu.Game.Screens.Select
                     return TryUpdateCriteriaRange(ref criteria.OverallDifficulty, op, value);
 
                 case "bpm":
-                    return TryUpdateCriteriaRange(ref criteria.BPM, op, value, 0.01d / 2);
+                    return TryUpdateCriteriaRange(ref criteria.BPM, op, value, 0.5f);
 
                 case "length":
                     return tryUpdateLengthRange(criteria, op, value);
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
index da841aa361..780b5155fd 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
@@ -8,13 +8,17 @@ using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Pooling;
+using osu.Framework.Localisation;
 using osu.Framework.Threading;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
@@ -24,7 +28,6 @@ using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Carousel;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Models;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
 using osu.Game.Screens.Select;
@@ -40,12 +43,12 @@ namespace osu.Game.Screens.SelectV2
         /// <summary>
         /// From the provided beatmaps, select the most appropriate one for the user's skill.
         /// </summary>
-        public required Action<IEnumerable<BeatmapInfo>> RequestRecommendedSelection { private get; init; }
+        public required Action<IEnumerable<GroupedBeatmap>> RequestRecommendedSelection { private get; init; }
 
         /// <summary>
         /// Selection requested for the provided beatmap.
         /// </summary>
-        public required Action<BeatmapInfo> RequestSelection { private get; init; }
+        public required Action<GroupedBeatmap> RequestSelection { private get; init; }
 
         public const float SPACING = 3f;
 
@@ -69,15 +72,15 @@ namespace osu.Game.Screens.SelectV2
             if (grouping.BeatmapSetsGroupedTogether)
             {
                 // Give some space around the expanded beatmap set, at the top..
-                if (bottom.Model is BeatmapSetInfo && bottom.IsExpanded)
+                if (bottom.Model is GroupedBeatmapSet && bottom.IsExpanded)
                     return SPACING * 2;
 
                 // ..and the bottom.
-                if (top.Model is BeatmapInfo && bottom.Model is BeatmapSetInfo)
+                if (top.Model is GroupedBeatmap && bottom.Model is GroupedBeatmapSet)
                     return SPACING * 2;
 
                 // Beatmap difficulty panels do not overlap with themselves or any other panel.
-                if (top.Model is BeatmapInfo || bottom.Model is BeatmapInfo)
+                if (top.Model is GroupedBeatmap || bottom.Model is GroupedBeatmap)
                     return SPACING;
             }
             else
@@ -102,14 +105,14 @@ namespace osu.Game.Screens.SelectV2
             {
                 new BeatmapCarouselFilterMatching(() => Criteria!),
                 new BeatmapCarouselFilterSorting(() => Criteria!),
-                grouping = new BeatmapCarouselFilterGrouping(() => Criteria!, getDetachedCollections, getTopRanksMapping)
+                grouping = new BeatmapCarouselFilterGrouping(() => Criteria!, GetAllCollections, GetBeatmapInfoGuidToTopRankMapping)
             };
 
             AddInternal(loading = new LoadingLayer());
         }
 
         [BackgroundDependencyLoader]
-        private void load(BeatmapStore beatmapStore, RealmAccess realm, AudioManager audio, OsuConfigManager config, CancellationToken? cancellationToken)
+        private void load(BeatmapStore beatmapStore, AudioManager audio, OsuConfigManager config, CancellationToken? cancellationToken)
         {
             setupPools();
             detachedBeatmaps = beatmapStore.GetBeatmapSets(cancellationToken);
@@ -143,6 +146,9 @@ namespace osu.Game.Screens.SelectV2
             switch (changed.Action)
             {
                 case NotifyCollectionChangedAction.Add:
+                    if (!newItems!.Any())
+                        return;
+
                     Items.AddRange(newItems!.SelectMany(s => s.Beatmaps));
                     break;
 
@@ -154,7 +160,7 @@ namespace osu.Game.Screens.SelectV2
                         foreach (var beatmap in set.Beatmaps)
                         {
                             Items.RemoveAll(i => i is BeatmapInfo bi && beatmap.Equals(bi));
-                            selectedSetDeleted |= CheckModelEquality(CurrentSelection, beatmap);
+                            selectedSetDeleted |= CheckModelEquality((CurrentSelection as GroupedBeatmap)?.Beatmap, beatmap);
                         }
                     }
 
@@ -196,22 +202,22 @@ namespace osu.Game.Screens.SelectV2
                         {
                             if (CheckValidForSetSelection(item))
                             {
-                                if (item.Model is BeatmapInfo beatmapInfo)
+                                if (item.Model is GroupedBeatmap groupedBeatmap)
                                 {
                                     // check the new selection wasn't deleted above
-                                    if (!Items.Contains(beatmapInfo))
+                                    if (!Items.Contains(groupedBeatmap.Beatmap))
                                         return false;
 
-                                    RequestSelection(beatmapInfo);
+                                    RequestSelection(groupedBeatmap);
                                     return true;
                                 }
 
-                                if (item.Model is BeatmapSetInfo beatmapSetInfo)
+                                if (item.Model is GroupedBeatmapSet groupedSet)
                                 {
-                                    if (oldItems.Contains(beatmapSetInfo))
+                                    if (oldItems.Contains(groupedSet.BeatmapSet))
                                         return false;
 
-                                    RequestRecommendedSelection(beatmapSetInfo.Beatmaps);
+                                    selectRecommendedDifficultyForBeatmapSet(groupedSet);
                                     return true;
                                 }
                             }
@@ -248,12 +254,20 @@ namespace osu.Game.Screens.SelectV2
                             newSetBeatmaps.FirstOrDefault(b => b.OnlineID > 0 && b.OnlineID == beatmap.OnlineID) ??
                             newSetBeatmaps.FirstOrDefault(b => b.DifficultyName == beatmap.DifficultyName && b.Ruleset.Equals(beatmap.Ruleset));
 
+                        // The matching beatmap may have been deleted or invalidated in some way since this event was fired.
+                        // Let's make sure we have the most up-to-date realm state.
+                        if (matchingNewBeatmap?.ID is Guid matchingID)
+                            matchingNewBeatmap = realm.Run(r => r.FindWithRefresh<BeatmapInfo>(matchingID)?.Detach());
+
                         if (matchingNewBeatmap != null)
                         {
                             // TODO: should this exist in song select instead of here?
                             // we need to ensure the global beatmap is also updated alongside changes.
-                            if (CurrentSelection != null && CheckModelEquality(beatmap, CurrentSelection))
-                                RequestSelection(matchingNewBeatmap);
+                            if (CurrentBeatmap != null && beatmap.Equals(CurrentBeatmap))
+                                // we don't know in which group the matching new beatmap is, but that's fine - we can keep the previous one for now.
+                                // we are about to modify `Items`, which - if required - will trigger a re-filter,
+                                // which will pick a correct group - if one is present - via `HandleFilterCompleted()`.
+                                RequestSelection(new GroupedBeatmap(CurrentGroupedBeatmap?.Group, matchingNewBeatmap));
 
                             Items.ReplaceRange(previousIndex, 1, [matchingNewBeatmap]);
                             newSetBeatmaps.Remove(matchingNewBeatmap);
@@ -282,10 +296,60 @@ namespace osu.Game.Screens.SelectV2
 
         protected GroupDefinition? ExpandedGroup { get; private set; }
 
-        protected BeatmapSetInfo? ExpandedBeatmapSet { get; private set; }
+        protected GroupedBeatmapSet? ExpandedBeatmapSet { get; private set; }
 
         protected override bool ShouldActivateOnKeyboardSelection(CarouselItem item) =>
-            grouping.BeatmapSetsGroupedTogether && item.Model is BeatmapInfo;
+            grouping.BeatmapSetsGroupedTogether && item.Model is GroupedBeatmap;
+
+        /// <summary>
+        /// The currently selected <see cref="GroupedBeatmap"/>.
+        /// </summary>
+        /// <remarks>
+        /// The selection is never reset due to not existing. It can be set to anything.
+        /// If no matching carousel item exists, there will be no visually selected item while waiting for potential new item which matches.
+        /// </remarks>
+        public GroupedBeatmap? CurrentGroupedBeatmap
+        {
+            get => CurrentSelection as GroupedBeatmap;
+            set => CurrentSelection = value;
+        }
+
+        /// <summary>
+        /// The currently selected <see cref="BeatmapInfo"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is a property mostly dedicated to external consumers who only care about showing some particular copy of a beatmap
+        /// (there could be multiple panels for one beatmap due to grouping).
+        /// Through this property, the carousel basically figures out what group to use internally.
+        /// </remarks>
+        public BeatmapInfo? CurrentBeatmap
+        {
+            get => CurrentGroupedBeatmap?.Beatmap;
+            set
+            {
+                if (value == null)
+                {
+                    CurrentGroupedBeatmap = null;
+                    return;
+                }
+
+                if (CurrentGroupedBeatmap != null && value.Equals(CurrentGroupedBeatmap.Beatmap))
+                    return;
+
+                // it is not universally guaranteed that the carousel items will be materialised at the time this is set.
+                // therefore, in cases where it is known that they will not be, default to a null group.
+                // even if grouping is active, this will be rectified to a correct group on the next invocation of `HandleFilterCompleted()`.
+                CurrentGroupedBeatmap = IsLoaded && !IsFiltering
+                    ? GetCarouselItems()?.Select(item => item.Model).OfType<GroupedBeatmap>().FirstOrDefault(gb => gb.Beatmap.Equals(value))
+                    : new GroupedBeatmap(null, value);
+            }
+        }
+
+        /// <summary>
+        /// Tracks whether the user has manually requested to collapse an open group.
+        /// In this case, refilters should not forcibly expand groups until the user expands a group again themselves.
+        /// </summary>
+        private bool userCollapsedGroup;
 
         protected override void HandleItemActivated(CarouselItem item)
         {
@@ -299,29 +363,37 @@ namespace osu.Game.Screens.SelectV2
                         {
                             setExpansionStateOfGroup(ExpandedGroup, false);
                             ExpandedGroup = null;
+                            userCollapsedGroup = true;
                             return;
                         }
 
                         setExpandedGroup(group);
 
-                        // If the active selection is within this group, it should get keyboard focus immediately.
-                        if (CurrentSelectionItem?.IsVisible == true && CurrentSelection is BeatmapInfo info)
-                            RequestSelection(info);
-
-                        return;
-
-                    case BeatmapSetInfo setInfo:
-                        selectRecommendedDifficultyForBeatmapSet(setInfo);
-                        return;
-
-                    case BeatmapInfo beatmapInfo:
-                        if (CurrentSelection != null && CheckModelEquality(CurrentSelection, beatmapInfo))
+                        if (userCollapsedGroup)
                         {
-                            RequestPresentBeatmap?.Invoke(beatmapInfo);
+                            if (grouping.BeatmapSetsGroupedTogether && CurrentGroupedBeatmap != null)
+                                setExpandedSet(new GroupedBeatmapSet(CurrentGroupedBeatmap.Group, CurrentGroupedBeatmap.Beatmap.BeatmapSet!));
+                            userCollapsedGroup = false;
+                        }
+
+                        // If the active selection is within this group, it should get keyboard focus immediately.
+                        if (CurrentSelectionItem?.IsVisible == true && CurrentSelection is GroupedBeatmap gb)
+                            RequestSelection(gb);
+
+                        return;
+
+                    case GroupedBeatmapSet groupedSet:
+                        selectRecommendedDifficultyForBeatmapSet(groupedSet);
+                        return;
+
+                    case GroupedBeatmap groupedBeatmap:
+                        if (CurrentSelection != null && CheckModelEquality(CurrentSelection, groupedBeatmap))
+                        {
+                            RequestPresentBeatmap?.Invoke(groupedBeatmap.Beatmap);
                             return;
                         }
 
-                        RequestSelection(beatmapInfo);
+                        RequestSelection(groupedBeatmap);
                         return;
                 }
             }
@@ -337,22 +409,73 @@ namespace osu.Game.Screens.SelectV2
 
             switch (model)
             {
-                case BeatmapSetInfo:
+                case GroupedBeatmapSet:
                 case GroupDefinition:
                     throw new InvalidOperationException("Groups should never become selected");
 
-                case BeatmapInfo beatmapInfo:
-                    // Find any containing group. There should never be too many groups so iterating is efficient enough.
-                    GroupDefinition? containingGroup = grouping.GroupItems.SingleOrDefault(kvp => kvp.Value.Any(i => CheckModelEquality(i.Model, beatmapInfo))).Key;
+                case GroupedBeatmap groupedBeatmap:
+                    if (userCollapsedGroup)
+                        break;
 
-                    setExpandedGroup(containingGroup);
+                    setExpandedGroup(groupedBeatmap.Group);
 
                     if (grouping.BeatmapSetsGroupedTogether)
-                        setExpandedSet(beatmapInfo);
+                        setExpandedSet(new GroupedBeatmapSet(groupedBeatmap.Group, groupedBeatmap.Beatmap.BeatmapSet!));
                     break;
             }
         }
 
+        protected override bool HandleItemsChanged(NotifyCollectionChangedEventArgs args)
+        {
+            switch (args.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                case NotifyCollectionChangedAction.Remove:
+                case NotifyCollectionChangedAction.Move:
+                case NotifyCollectionChangedAction.Reset:
+                    return true;
+
+                case NotifyCollectionChangedAction.Replace:
+                    var oldBeatmaps = args.OldItems!.OfType<BeatmapInfo>().ToList();
+                    var newBeatmaps = args.NewItems!.OfType<BeatmapInfo>().ToList();
+
+                    for (int i = 0; i < oldBeatmaps.Count; i++)
+                    {
+                        var oldBeatmap = oldBeatmaps[i];
+                        var newBeatmap = newBeatmaps[i];
+
+                        // Ignore changes which don't concern us.
+                        //
+                        // Here are some examples of things that can go wrong:
+                        // - Background difficulty calculation runs and causes a realm update.
+                        //   We use `BeatmapDifficultyCache` and don't want to know about these.
+                        // - Background user tag population runs and causes a realm update.
+                        //   We don't display user tags so want to ignore this.
+                        bool equalForDisplayPurposes =
+                            // covers metadata changes
+                            oldBeatmap.Hash == newBeatmap.Hash &&
+                            // sanity check
+                            oldBeatmap.OnlineID == newBeatmap.OnlineID &&
+                            // displayed on panel
+                            oldBeatmap.Status == newBeatmap.Status &&
+                            // displayed on panel
+                            oldBeatmap.DifficultyName == newBeatmap.DifficultyName &&
+                            // hidden changed, needs re-filter
+                            oldBeatmap.Hidden == newBeatmap.Hidden &&
+                            // might be used for grouping, returning from gameplay
+                            oldBeatmap.LastPlayed == newBeatmap.LastPlayed;
+
+                        if (equalForDisplayPurposes)
+                            return false;
+                    }
+
+                    return true;
+
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
         protected override void HandleFilterCompleted()
         {
             base.HandleFilterCompleted();
@@ -362,9 +485,27 @@ namespace osu.Game.Screens.SelectV2
             // Store selected group before handling selection (it may implicitly change the expanded group).
             var groupForReselection = ExpandedGroup;
 
-            // Ensure correct post-selection logic is handled on the new items list.
-            // This will update the visual state of the selected item.
-            HandleItemSelected(CurrentSelection);
+            var currentGroupedBeatmap = CurrentSelection as GroupedBeatmap;
+
+            // The filter might have changed the set of available groups, which means that the current selection may point to a stale group.
+            // Check whether that is the case.
+            bool groupingRemainsOff = currentGroupedBeatmap?.Group == null && grouping.GroupItems.Count == 0;
+            bool groupStillExists = currentGroupedBeatmap?.Group != null && grouping.GroupItems.ContainsKey(currentGroupedBeatmap.Group);
+
+            if (groupingRemainsOff || groupStillExists)
+            {
+                // Only update the visual state of the selected item.
+                HandleItemSelected(currentGroupedBeatmap);
+            }
+            else if (currentGroupedBeatmap != null)
+            {
+                // If the group no longer exists, grab an arbitrary other instance of the beatmap under the first group encountered.
+                var newSelection = GetCarouselItems()?.Select(i => i.Model).OfType<GroupedBeatmap>().FirstOrDefault(gb => gb.Beatmap.Equals(currentGroupedBeatmap.Beatmap));
+                // Only change the selection if we actually got a positive hit.
+                // This is necessary so that selection isn't lost if the panel reappears later due to e.g. unapplying some filter criteria that made it disappear in the first place.
+                if (newSelection != null)
+                    CurrentSelection = newSelection;
+            }
 
             // If a group was selected that is not the one containing the selection, attempt to reselect it.
             // If the original group was not found, ExpandedGroup will already have been updated to a valid value in `HandleItemSelected` above.
@@ -372,12 +513,12 @@ namespace osu.Game.Screens.SelectV2
                 setExpandedGroup(groupForReselection);
         }
 
-        private void selectRecommendedDifficultyForBeatmapSet(BeatmapSetInfo beatmapSet)
+        private void selectRecommendedDifficultyForBeatmapSet(GroupedBeatmapSet set)
         {
             // Selecting a set isn't valid – let's re-select the first visible difficulty.
-            if (grouping.SetItems.TryGetValue(beatmapSet, out var items))
+            if (grouping.SetItems.TryGetValue(set, out var items))
             {
-                var beatmaps = items.Select(i => i.Model).OfType<BeatmapInfo>();
+                var beatmaps = items.Select(i => i.Model).OfType<GroupedBeatmap>();
                 RequestRecommendedSelection(beatmaps);
             }
         }
@@ -395,8 +536,10 @@ namespace osu.Game.Screens.SelectV2
 
             foreach (var item in items)
             {
-                if (item.Model is BeatmapInfo beatmapInfo)
+                if (item.Model is GroupedBeatmap groupedBeatmap)
                 {
+                    var beatmapInfo = groupedBeatmap.Beatmap;
+
                     if (beatmapSetInfo == null)
                     {
                         beatmapSetInfo = beatmapInfo.BeatmapSet!;
@@ -409,9 +552,9 @@ namespace osu.Game.Screens.SelectV2
                 }
             }
 
-            var beatmaps = items.Select(i => i.Model).OfType<BeatmapInfo>();
+            var beatmaps = items.Select(i => i.Model).OfType<GroupedBeatmap>();
 
-            if (beatmaps.Any(b => b.Equals(CurrentSelection as BeatmapInfo)))
+            if (beatmaps.Any(b => b.Equals(CurrentSelection as GroupedBeatmap)))
                 return;
 
             RequestRecommendedSelection(beatmaps);
@@ -423,10 +566,10 @@ namespace osu.Game.Screens.SelectV2
         {
             switch (item.Model)
             {
-                case BeatmapSetInfo:
+                case GroupedBeatmapSet:
                     return true;
 
-                case BeatmapInfo:
+                case GroupedBeatmap:
                     return !grouping.BeatmapSetsGroupedTogether;
 
                 case GroupDefinition:
@@ -437,7 +580,7 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
-        private void setExpandedGroup(GroupDefinition group)
+        private void setExpandedGroup(GroupDefinition? group)
         {
             if (ExpandedGroup != null)
                 setExpansionStateOfGroup(ExpandedGroup, false);
@@ -445,7 +588,7 @@ namespace osu.Game.Screens.SelectV2
             ExpandedGroup = group;
 
             if (ExpandedGroup != null)
-                setExpansionStateOfGroup(group, true);
+                setExpansionStateOfGroup(ExpandedGroup, true);
         }
 
         private void setExpansionStateOfGroup(GroupDefinition group, bool expanded)
@@ -462,11 +605,11 @@ namespace osu.Game.Screens.SelectV2
                                 i.IsExpanded = true;
                                 break;
 
-                            case BeatmapSetInfo set:
+                            case GroupedBeatmapSet groupedSet:
                                 // Case where there are set headers, header should be visible
                                 // and items should use the set's expanded state.
                                 i.IsVisible = true;
-                                setExpansionStateOfSetItems(set, i.IsExpanded);
+                                setExpansionStateOfSetItems(groupedSet, i.IsExpanded);
                                 break;
 
                             default:
@@ -496,21 +639,21 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
-        private void setExpandedSet(BeatmapInfo beatmapInfo)
+        private void setExpandedSet(GroupedBeatmapSet set)
         {
             if (ExpandedBeatmapSet != null)
                 setExpansionStateOfSetItems(ExpandedBeatmapSet, false);
-            ExpandedBeatmapSet = beatmapInfo.BeatmapSet!;
+            ExpandedBeatmapSet = set;
             setExpansionStateOfSetItems(ExpandedBeatmapSet, true);
         }
 
-        private void setExpansionStateOfSetItems(BeatmapSetInfo set, bool expanded)
+        private void setExpansionStateOfSetItems(GroupedBeatmapSet set, bool expanded)
         {
             if (grouping.SetItems.TryGetValue(set, out var items))
             {
                 foreach (var i in items)
                 {
-                    if (i.Model is BeatmapSetInfo)
+                    if (i.Model is GroupedBeatmapSet)
                         i.IsExpanded = expanded;
                     else
                         i.IsVisible = expanded;
@@ -548,11 +691,11 @@ namespace osu.Game.Screens.SelectV2
                         sampleToggleGroup?.Play();
                         return;
 
-                    case BeatmapSetInfo:
+                    case GroupedBeatmapSet:
                         sampleChangeSet?.Play();
                         return;
 
-                    case BeatmapInfo:
+                    case GroupedBeatmap:
                         sampleChangeDifficulty?.Play();
                         return;
                 }
@@ -632,17 +775,14 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private RealmAccess realm { get; set; } = null!;
 
-        private List<BeatmapCollection> getDetachedCollections() => realm.Run(r => r.All<BeatmapCollection>().AsEnumerable().Detach());
+        protected virtual List<BeatmapCollection> GetAllCollections() => realm.Run(r => r.All<BeatmapCollection>().AsEnumerable().Detach());
 
-        private Dictionary<Guid, ScoreRank> getTopRanksMapping(FilterCriteria criteria) => realm.Run(r =>
+        protected virtual Dictionary<Guid, ScoreRank> GetBeatmapInfoGuidToTopRankMapping(FilterCriteria criteria) => realm.Run(r =>
         {
             var topRankMapping = new Dictionary<Guid, ScoreRank>();
 
-            var allLocalScores = r.All<ScoreInfo>()
-                                  .Filter($"{nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} == $0"
-                                          + $" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
-                                          + $" && {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $1"
-                                          + $" && {nameof(ScoreInfo.DeletePending)} == false", criteria.LocalUserId, criteria.Ruleset?.ShortName)
+            var allLocalScores = r.GetAllLocalScoresForUser(criteria.LocalUserId)
+                                  .Filter($@"{nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $0", criteria.Ruleset?.ShortName)
                                   .OrderByDescending(s => s.TotalScore)
                                   .ThenBy(s => s.Date);
 
@@ -668,9 +808,11 @@ namespace osu.Game.Screens.SelectV2
         private readonly DrawablePool<PanelBeatmapSet> setPanelPool = new DrawablePool<PanelBeatmapSet>(100);
         private readonly DrawablePool<PanelGroup> groupPanelPool = new DrawablePool<PanelGroup>(100);
         private readonly DrawablePool<PanelGroupStarDifficulty> starsGroupPanelPool = new DrawablePool<PanelGroupStarDifficulty>(11);
+        private readonly DrawablePool<PanelGroupRankDisplay> ranksGroupPanelPool = new DrawablePool<PanelGroupRankDisplay>(9);
 
         private void setupPools()
         {
+            AddInternal(ranksGroupPanelPool);
             AddInternal(starsGroupPanelPool);
             AddInternal(groupPanelPool);
             AddInternal(beatmapPanelPool);
@@ -687,11 +829,16 @@ namespace osu.Game.Screens.SelectV2
             // it is doing a Replace operation on the list. If it is, then check the local handling in beatmapSetsChanged
             // before changing matching requirements here.
 
-            if (x is BeatmapSetInfo beatmapSetX && y is BeatmapSetInfo beatmapSetY)
-                return beatmapSetX.Equals(beatmapSetY);
+            if (x is GroupedBeatmapSet groupedSetX && y is GroupedBeatmapSet groupedSetY)
+                return groupedSetX.Equals(groupedSetY);
 
-            if (x is BeatmapInfo beatmapX && y is BeatmapInfo beatmapY)
-                return beatmapX.Equals(beatmapY);
+            if (x is GroupedBeatmap groupedBeatmapX && y is GroupedBeatmap groupedBeatmapY)
+                return groupedBeatmapX.Equals(groupedBeatmapY);
+
+            // `BeatmapInfo` is no longer used directly in carousel items, but in rare circumstances still is used for model equality comparisons
+            // (see `beatmapSetsChanged()` deletion handling logic, which aims to find a beatmap close to the just-deleted one, disregarding grouping concerns)
+            if (x is BeatmapInfo beatmapInfoX && y is BeatmapInfo beatmapInfoY)
+                return beatmapInfoX.Equals(beatmapInfoY);
 
             if (x is GroupDefinition groupX && y is GroupDefinition groupY)
                 return groupX.Equals(groupY);
@@ -709,16 +856,19 @@ namespace osu.Game.Screens.SelectV2
                 case StarDifficultyGroupDefinition:
                     return starsGroupPanelPool.Get();
 
+                case RankDisplayGroupDefinition:
+                    return ranksGroupPanelPool.Get();
+
                 case GroupDefinition:
                     return groupPanelPool.Get();
 
-                case BeatmapInfo:
+                case GroupedBeatmap:
                     if (!grouping.BeatmapSetsGroupedTogether)
                         return standalonePanelPool.Get();
 
                     return beatmapPanelPool.Get();
 
-                case BeatmapSetInfo:
+                case GroupedBeatmapSet:
                     return setPanelPool.Get();
             }
 
@@ -730,8 +880,8 @@ namespace osu.Game.Screens.SelectV2
         #region Random selection handling
 
         private readonly Bindable<RandomSelectAlgorithm> randomAlgorithm = new Bindable<RandomSelectAlgorithm>();
-        private readonly List<BeatmapInfo> previouslyVisitedRandomBeatmaps = new List<BeatmapInfo>();
-        private readonly List<BeatmapInfo> randomHistory = new List<BeatmapInfo>();
+        private readonly HashSet<BeatmapInfo> previouslyVisitedRandomBeatmaps = new HashSet<BeatmapInfo>();
+        private readonly List<GroupedBeatmap> randomHistory = new List<GroupedBeatmap>();
 
         private Sample? spinSample;
         private Sample? randomSelectSample;
@@ -744,7 +894,7 @@ namespace osu.Game.Screens.SelectV2
                 return false;
 
             var selectionBefore = CurrentSelectionItem;
-            var beatmapBefore = selectionBefore?.Model as BeatmapInfo;
+            var beatmapBefore = selectionBefore?.Model as GroupedBeatmap;
 
             bool success;
 
@@ -754,7 +904,7 @@ namespace osu.Game.Screens.SelectV2
                 randomHistory.Add(beatmapBefore);
                 // keep track of visited beatmaps for "RandomPermutation" random tracking.
                 // note that this is reset when we run out of beatmaps, while `randomHistory` is not.
-                previouslyVisitedRandomBeatmaps.Add(beatmapBefore);
+                previouslyVisitedRandomBeatmaps.Add(beatmapBefore.Beatmap);
             }
 
             if (grouping.BeatmapSetsGroupedTogether)
@@ -782,29 +932,29 @@ namespace osu.Game.Screens.SelectV2
 
         private bool nextRandomBeatmap()
         {
-            ICollection<BeatmapInfo> visibleBeatmaps = ExpandedGroup != null
+            ICollection<GroupedBeatmap> visibleBeatmaps = ExpandedGroup != null
                 // In the case of grouping, users expect random to only operate on the expanded group.
                 // This is going to incur some overhead as we don't have a group-beatmapset mapping currently.
                 //
                 // If this becomes an issue, we could either store a mapping, or run the random algorithm many times
                 // using the `SetItems` method until we get a group HIT.
-                ? grouping.GroupItems[ExpandedGroup].Select(i => i.Model).OfType<BeatmapInfo>().ToArray()
-                : GetCarouselItems()!.Select(i => i.Model).OfType<BeatmapInfo>().ToArray();
+                ? grouping.GroupItems[ExpandedGroup].Select(i => i.Model).OfType<GroupedBeatmap>().ToArray()
+                : GetCarouselItems()!.Select(i => i.Model).OfType<GroupedBeatmap>().ToArray();
 
-            BeatmapInfo beatmap;
+            GroupedBeatmap beatmap;
 
             switch (randomAlgorithm.Value)
             {
                 case RandomSelectAlgorithm.RandomPermutation:
                 {
-                    ICollection<BeatmapInfo> notYetVisitedBeatmaps = visibleBeatmaps.Except(previouslyVisitedRandomBeatmaps).ToList();
+                    ICollection<GroupedBeatmap> notYetVisitedBeatmaps = visibleBeatmaps.ExceptBy(previouslyVisitedRandomBeatmaps, gb => gb.Beatmap).ToList();
 
                     if (!notYetVisitedBeatmaps.Any())
                     {
-                        previouslyVisitedRandomBeatmaps.RemoveAll(b => visibleBeatmaps.Contains(b));
+                        previouslyVisitedRandomBeatmaps.ExceptWith(visibleBeatmaps.Select(b => b.Beatmap));
                         notYetVisitedBeatmaps = visibleBeatmaps;
-                        if (CurrentSelection is BeatmapInfo beatmapInfo)
-                            notYetVisitedBeatmaps = notYetVisitedBeatmaps.Except([beatmapInfo]).ToList();
+                        if (CurrentSelection is GroupedBeatmap groupedBeatmap)
+                            notYetVisitedBeatmaps = notYetVisitedBeatmaps.Except([groupedBeatmap]).ToList();
                     }
 
                     if (notYetVisitedBeatmaps.Count == 0)
@@ -828,30 +978,31 @@ namespace osu.Game.Screens.SelectV2
 
         private bool nextRandomSet()
         {
-            ICollection<BeatmapSetInfo> visibleSets = ExpandedGroup != null
+            ICollection<GroupedBeatmapSet> visibleGroupedSets = ExpandedGroup != null
                 // In the case of grouping, users expect random to only operate on the expanded group.
                 // This is going to incur some overhead as we don't have a group-beatmapset mapping currently.
                 //
                 // If this becomes an issue, we could either store a mapping, or run the random algorithm many times
                 // using the `SetItems` method until we get a group HIT.
-                ? grouping.GroupItems[ExpandedGroup].Select(i => i.Model).OfType<BeatmapSetInfo>().ToArray()
+                ? grouping.GroupItems[ExpandedGroup].Select(i => i.Model).OfType<GroupedBeatmapSet>().ToArray()
                 // This is the fastest way to retrieve sets for randomisation.
                 : grouping.SetItems.Keys;
 
-            BeatmapSetInfo set;
+            GroupedBeatmapSet set;
 
             switch (randomAlgorithm.Value)
             {
                 case RandomSelectAlgorithm.RandomPermutation:
                 {
-                    ICollection<BeatmapSetInfo> notYetVisitedSets = visibleSets.Except(previouslyVisitedRandomBeatmaps.Select(b => b.BeatmapSet!)).ToList();
+                    ICollection<GroupedBeatmapSet> notYetVisitedSets =
+                        visibleGroupedSets.ExceptBy(previouslyVisitedRandomBeatmaps.Select(b => b.BeatmapSet!), groupedSet => groupedSet.BeatmapSet).ToList();
 
                     if (!notYetVisitedSets.Any())
                     {
-                        previouslyVisitedRandomBeatmaps.RemoveAll(b => visibleSets.Contains(b.BeatmapSet!));
-                        notYetVisitedSets = visibleSets;
-                        if (CurrentSelection is BeatmapInfo beatmapInfo)
-                            notYetVisitedSets = notYetVisitedSets.Except([beatmapInfo.BeatmapSet!]).ToList();
+                        previouslyVisitedRandomBeatmaps.ExceptWith(visibleGroupedSets.SelectMany(setUnderGrouping => setUnderGrouping.BeatmapSet.Beatmaps));
+                        notYetVisitedSets = visibleGroupedSets;
+                        if (CurrentSelection is GroupedBeatmap groupedBeatmap)
+                            notYetVisitedSets = notYetVisitedSets.ExceptBy([groupedBeatmap.Beatmap.BeatmapSet!], groupedSet => groupedSet.BeatmapSet).ToList();
                     }
 
                     if (notYetVisitedSets.Count == 0)
@@ -862,7 +1013,7 @@ namespace osu.Game.Screens.SelectV2
                 }
 
                 case RandomSelectAlgorithm.Random:
-                    set = visibleSets.ElementAt(RNG.Next(visibleSets.Count));
+                    set = visibleGroupedSets.ElementAt(RNG.Next(visibleGroupedSets.Count));
                     break;
 
                 default:
@@ -885,15 +1036,19 @@ namespace osu.Game.Screens.SelectV2
                 var previousBeatmap = randomHistory[^1];
                 randomHistory.RemoveAt(randomHistory.Count - 1);
 
-                var previousBeatmapItem = carouselItems.FirstOrDefault(i => i.Model is BeatmapInfo b && b.Equals(previousBeatmap));
+                // when going back through rewind history, we may no longer be in the same grouping mode.
+                // the user wants to go back to the beatmap first and foremost, so the most important thing is to find a panel that corresponds to the beatmap.
+                // going back to the same group is a nice-to-have, but a secondary concern.
+                var previousBeatmapItem = carouselItems.Where(i => i.Model is GroupedBeatmap gb && gb.Beatmap.Equals(previousBeatmap.Beatmap))
+                                                       .MaxBy(i => ((GroupedBeatmap)i.Model).Group == previousBeatmap.Group);
 
                 if (previousBeatmapItem == null)
                     return false;
 
-                if (CurrentSelection is BeatmapInfo beatmapInfo)
+                if (CurrentSelection is GroupedBeatmap groupedBeatmap)
                 {
                     if (randomAlgorithm.Value == RandomSelectAlgorithm.RandomPermutation)
-                        previouslyVisitedRandomBeatmaps.Remove(beatmapInfo);
+                        previouslyVisitedRandomBeatmaps.Remove(groupedBeatmap.Beatmap);
 
                     if (CurrentSelectionItem == null)
                         playSpinSample(0);
@@ -901,7 +1056,7 @@ namespace osu.Game.Screens.SelectV2
                         playSpinSample(visiblePanelCountBetweenItems(previousBeatmapItem, CurrentSelectionItem));
                 }
 
-                RequestSelection(previousBeatmap);
+                RequestSelection((GroupedBeatmap)previousBeatmapItem.Model);
                 return true;
             }
 
@@ -939,15 +1094,15 @@ namespace osu.Game.Screens.SelectV2
         /// <summary>
         /// The title of this group.
         /// </summary>
-        public string Title { get; }
+        public LocalisableString Title { get; }
 
         private readonly string uncasedTitle;
 
-        public GroupDefinition(int order, string title)
+        public GroupDefinition(int order, LocalisableString title)
         {
             Order = order;
             Title = title;
-            uncasedTitle = title.ToLowerInvariant();
+            uncasedTitle = title.ToLower().GetLocalised(LocalisationParameters.DEFAULT);
         }
 
         public virtual bool Equals(GroupDefinition? other) => uncasedTitle == other?.uncasedTitle;
@@ -958,5 +1113,23 @@ namespace osu.Game.Screens.SelectV2
     /// <summary>
     /// Defines a grouping header for a set of carousel items grouped by star difficulty.
     /// </summary>
-    public record StarDifficultyGroupDefinition(int Order, string Title, StarDifficulty Difficulty) : GroupDefinition(Order, Title);
+    public record StarDifficultyGroupDefinition(int Order, LocalisableString Title, StarDifficulty Difficulty) : GroupDefinition(Order, Title);
+
+    /// <summary>
+    /// Defines a grouping header for a set of carousel items grouped by achieved rank.
+    /// </summary>
+    public record RankDisplayGroupDefinition(ScoreRank Rank) : GroupDefinition(-(int)Rank, Rank.GetLocalisableDescription());
+
+    /// <summary>
+    /// Used to represent a portion of a <see cref="BeatmapSetInfo"/> under a <see cref="GroupDefinition"/>.
+    /// The purpose of this model is to support splitting beatmap sets apart when the active grouping mode demands it.
+    /// </summary>
+    public record GroupedBeatmapSet([UsedImplicitly] GroupDefinition? Group, BeatmapSetInfo BeatmapSet);
+
+    /// <summary>
+    /// Used to represent a <see cref="Beatmap"/> under a <see cref="GroupDefinition"/>.
+    /// The purpose of this model is to support showing multiple copies of a beatmap, which can occur if a beatmap appears in multiple groups
+    /// (most prominently, collections group mode).
+    /// </summary>
+    public record GroupedBeatmap(GroupDefinition? Group, BeatmapInfo Beatmap);
 }
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
index f17281db2f..0b7e29c363 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarouselFilterGrouping.cs
@@ -7,6 +7,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Beatmaps;
 using osu.Game.Collections;
 using osu.Game.Graphics.Carousel;
@@ -29,21 +30,22 @@ namespace osu.Game.Screens.SelectV2
         /// <summary>
         /// Beatmap sets contain difficulties as related panels. This dictionary holds the relationships between set-difficulties to allow expanding them on selection.
         /// </summary>
-        public IDictionary<BeatmapSetInfo, HashSet<CarouselItem>> SetItems => setMap;
+        public IDictionary<GroupedBeatmapSet, HashSet<CarouselItem>> SetItems => setMap;
 
         /// <summary>
         /// Groups contain children which are group-selectable. This dictionary holds the relationships between groups-panels to allow expanding them on selection.
         /// </summary>
         public IDictionary<GroupDefinition, HashSet<CarouselItem>> GroupItems => groupMap;
 
-        private Dictionary<BeatmapSetInfo, HashSet<CarouselItem>> setMap = new Dictionary<BeatmapSetInfo, HashSet<CarouselItem>>();
+        private Dictionary<GroupedBeatmapSet, HashSet<CarouselItem>> setMap = new Dictionary<GroupedBeatmapSet, HashSet<CarouselItem>>();
         private Dictionary<GroupDefinition, HashSet<CarouselItem>> groupMap = new Dictionary<GroupDefinition, HashSet<CarouselItem>>();
 
         private readonly Func<FilterCriteria> getCriteria;
         private readonly Func<List<BeatmapCollection>> getCollections;
         private readonly Func<FilterCriteria, IReadOnlyDictionary<Guid, ScoreRank>> getLocalUserTopRanks;
 
-        public BeatmapCarouselFilterGrouping(Func<FilterCriteria> getCriteria, Func<List<BeatmapCollection>> getCollections, Func<FilterCriteria, IReadOnlyDictionary<Guid, ScoreRank>> getLocalUserTopRanks)
+        public BeatmapCarouselFilterGrouping(Func<FilterCriteria> getCriteria, Func<List<BeatmapCollection>> getCollections,
+                                             Func<FilterCriteria, IReadOnlyDictionary<Guid, ScoreRank>> getLocalUserTopRanks)
         {
             this.getCriteria = getCriteria;
             this.getCollections = getCollections;
@@ -55,7 +57,7 @@ namespace osu.Game.Screens.SelectV2
             return await Task.Run(() =>
             {
                 // preallocate space for the new mappings using last known estimates
-                var newSetMap = new Dictionary<BeatmapSetInfo, HashSet<CarouselItem>>(setMap.Count);
+                var newSetMap = new Dictionary<GroupedBeatmapSet, HashSet<CarouselItem>>(setMap.Count);
                 var newGroupMap = new Dictionary<GroupDefinition, HashSet<CarouselItem>>(groupMap.Count);
 
                 var criteria = getCriteria();
@@ -93,11 +95,12 @@ namespace osu.Game.Screens.SelectV2
                         var beatmap = (BeatmapInfo)item.Model;
 
                         bool newBeatmapSet = lastBeatmap?.BeatmapSet!.ID != beatmap.BeatmapSet!.ID;
+                        var groupedBeatmapSet = new GroupedBeatmapSet(group, beatmap.BeatmapSet!);
 
                         if (newBeatmapSet)
                         {
-                            if (!newSetMap.TryGetValue(beatmap.BeatmapSet!, out currentSetItems))
-                                newSetMap[beatmap.BeatmapSet!] = currentSetItems = new HashSet<CarouselItem>();
+                            if (!newSetMap.TryGetValue(groupedBeatmapSet, out currentSetItems))
+                                newSetMap[groupedBeatmapSet] = currentSetItems = new HashSet<CarouselItem>();
                         }
 
                         if (BeatmapSetsGroupedTogether)
@@ -107,7 +110,7 @@ namespace osu.Game.Screens.SelectV2
                                 if (groupItem != null)
                                     groupItem.NestedItemCount++;
 
-                                addItem(new CarouselItem(beatmap.BeatmapSet!)
+                                addItem(new CarouselItem(groupedBeatmapSet)
                                 {
                                     DrawHeight = PanelBeatmapSet.HEIGHT,
                                     DepthLayer = -1
@@ -118,11 +121,12 @@ namespace osu.Game.Screens.SelectV2
                         {
                             if (groupItem != null)
                                 groupItem.NestedItemCount++;
-
-                            item.DrawHeight = PanelBeatmapStandalone.HEIGHT;
                         }
 
-                        addItem(item);
+                        addItem(new CarouselItem(new GroupedBeatmap(group, beatmap))
+                        {
+                            DrawHeight = BeatmapSetsGroupedTogether ? PanelBeatmap.HEIGHT : PanelBeatmapStandalone.HEIGHT,
+                        });
                         lastBeatmap = beatmap;
                         displayedBeatmapsCount++;
                     }
@@ -134,7 +138,7 @@ namespace osu.Game.Screens.SelectV2
                         currentGroupItems?.Add(i);
                         currentSetItems?.Add(i);
 
-                        i.IsVisible = i.Model is GroupDefinition || (group == null && (i.Model is BeatmapSetInfo || !BeatmapSetsGroupedTogether));
+                        i.IsVisible = i.Model is GroupDefinition || (group == null && (i.Model is GroupedBeatmapSet || !BeatmapSetsGroupedTogether));
                     }
                 }
 
@@ -189,11 +193,8 @@ namespace osu.Game.Screens.SelectV2
                     {
                         var date = b.LastPlayed;
 
-                        if (BeatmapSetsGroupedTogether)
-                            date = aggregateMax(b, static b => b.LastPlayed ?? DateTimeOffset.MinValue);
-
                         if (date == null || date == DateTimeOffset.MinValue)
-                            return new GroupDefinition(int.MaxValue, "Never");
+                            return new GroupDefinition(int.MaxValue, "Never").Yield();
 
                         return defineGroupByDate(date.Value);
                     }, items);
@@ -202,29 +203,13 @@ namespace osu.Game.Screens.SelectV2
                     return getGroupsBy(b => defineGroupByStatus(b.BeatmapSet!.Status), items);
 
                 case GroupMode.BPM:
-                    return getGroupsBy(b =>
-                    {
-                        double bpm = FormatUtils.RoundBPM(b.BPM);
-
-                        if (BeatmapSetsGroupedTogether)
-                            bpm = aggregateMax(b, bb => FormatUtils.RoundBPM(bb.BPM));
-
-                        return defineGroupByBPM(bpm);
-                    }, items);
+                    return getGroupsBy(b => defineGroupByBPM(FormatUtils.RoundBPM(b.BPM)), items);
 
                 case GroupMode.Difficulty:
                     return getGroupsBy(b => defineGroupByStars(b.StarRating), items);
 
                 case GroupMode.Length:
-                    return getGroupsBy(b =>
-                    {
-                        double length = b.Length;
-
-                        if (BeatmapSetsGroupedTogether)
-                            length = aggregateMax(b, bb => bb.Length);
-
-                        return defineGroupByLength(length);
-                    }, items);
+                    return getGroupsBy(b => defineGroupByLength(b.Length), items);
 
                 case GroupMode.Source:
                     return getGroupsBy(b => defineGroupBySource(b.BeatmapSet!.Metadata.Source), items);
@@ -253,190 +238,204 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
-        private List<GroupMapping> getGroupsBy(Func<BeatmapInfo, GroupDefinition?> getGroup, List<CarouselItem> items)
+        private List<GroupMapping> getGroupsBy(Func<BeatmapInfo, IEnumerable<GroupDefinition>> defineGroups, List<CarouselItem> items)
         {
-            return items.GroupBy(i => getGroup((BeatmapInfo)i.Model))
-                        .Where(g => g.Key != null)
-                        .OrderBy(g => g.Key!.Order)
-                        .ThenBy(g => g.Key!.Title)
-                        .Select(g => new GroupMapping(g.Key, g.ToList()))
-                        .ToList();
+            var groups = new Dictionary<GroupDefinition, GroupMapping>();
+
+            foreach (var item in items)
+            {
+                foreach (var groupDefinition in defineGroups((BeatmapInfo)item.Model))
+                {
+                    if (!groups.TryGetValue(groupDefinition, out var group))
+                        group = groups[groupDefinition] = new GroupMapping(groupDefinition, []);
+
+                    group.ItemsInGroup.Add(item);
+                }
+            }
+
+            return groups.Values
+                         .OrderBy(g => g.Group!.Order)
+                         .ThenBy(g => g.Group!.Title.ToString())
+                         .ToList();
         }
 
-        private GroupDefinition defineGroupAlphabetically(string name)
+        private IEnumerable<GroupDefinition> defineGroupAlphabetically(string name)
         {
             char firstChar = name.FirstOrDefault();
 
             if (char.IsAsciiDigit(firstChar))
-                return new GroupDefinition(int.MinValue, "0-9");
+                return new GroupDefinition(int.MinValue, "0-9").Yield();
 
             if (char.IsAsciiLetter(firstChar))
-                return new GroupDefinition(char.ToUpperInvariant(firstChar) - 'A', char.ToUpperInvariant(firstChar).ToString());
+                return new GroupDefinition(char.ToUpperInvariant(firstChar) - 'A', char.ToUpperInvariant(firstChar).ToString()).Yield();
 
-            return new GroupDefinition(int.MaxValue, "Other");
+            return new GroupDefinition(int.MaxValue, "Other").Yield();
         }
 
-        private GroupDefinition defineGroupByDate(DateTimeOffset date)
+        private IEnumerable<GroupDefinition> defineGroupByDate(DateTimeOffset date)
         {
             var now = DateTimeOffset.Now;
             var elapsed = now - date;
 
             if (elapsed.TotalDays < 1)
-                return new GroupDefinition(0, "Today");
+                return new GroupDefinition(0, "Today").Yield();
 
             if (elapsed.TotalDays < 2)
-                return new GroupDefinition(1, "Yesterday");
+                return new GroupDefinition(1, "Yesterday").Yield();
 
             if (elapsed.TotalDays < 7)
-                return new GroupDefinition(2, "Last week");
+                return new GroupDefinition(2, "Last week").Yield();
 
             if (elapsed.TotalDays < 30)
-                return new GroupDefinition(3, "Last month");
+                return new GroupDefinition(3, "Last month").Yield();
 
             if (elapsed.TotalDays < 60)
-                return new GroupDefinition(4, "1 month ago");
+                return new GroupDefinition(4, "1 month ago").Yield();
 
             for (int i = 90; i <= 150; i += 30)
             {
                 if (elapsed.TotalDays < i)
-                    return new GroupDefinition(i, $"{i / 30 - 1} months ago");
+                    return new GroupDefinition(i, $"{i / 30 - 1} months ago").Yield();
             }
 
-            return new GroupDefinition(151, "Over 5 months ago");
+            return new GroupDefinition(151, "Over 5 months ago").Yield();
         }
 
-        private GroupDefinition defineGroupByRankedDate(DateTimeOffset? date)
+        private IEnumerable<GroupDefinition> defineGroupByRankedDate(DateTimeOffset? date)
         {
             if (date == null)
-                return new GroupDefinition(0, "Unranked");
+                return new GroupDefinition(0, "Unranked").Yield();
 
-            return new GroupDefinition(-date.Value.Year, $"{date.Value.Year}");
+            return new GroupDefinition(-date.Value.Year, $"{date.Value.Year}").Yield();
         }
 
-        private GroupDefinition defineGroupByStatus(BeatmapOnlineStatus status)
+        private IEnumerable<GroupDefinition> defineGroupByStatus(BeatmapOnlineStatus status)
         {
             switch (status)
             {
                 case BeatmapOnlineStatus.Ranked:
                 case BeatmapOnlineStatus.Approved:
-                    return new GroupDefinition(0, BeatmapOnlineStatus.Ranked.GetDescription());
+                    return new GroupDefinition(0, BeatmapOnlineStatus.Ranked.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.Qualified:
-                    return new GroupDefinition(1, status.GetDescription());
+                    return new GroupDefinition(1, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.WIP:
-                    return new GroupDefinition(2, status.GetDescription());
+                    return new GroupDefinition(2, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.Pending:
-                    return new GroupDefinition(3, status.GetDescription());
+                    return new GroupDefinition(3, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.Graveyard:
-                    return new GroupDefinition(4, status.GetDescription());
+                    return new GroupDefinition(4, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.LocallyModified:
-                    return new GroupDefinition(5, status.GetDescription());
+                    return new GroupDefinition(5, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.None:
-                    return new GroupDefinition(6, status.GetDescription());
+                    return new GroupDefinition(6, status.GetDescription()).Yield();
 
                 case BeatmapOnlineStatus.Loved:
-                    return new GroupDefinition(7, status.GetDescription());
+                    return new GroupDefinition(7, status.GetDescription()).Yield();
 
                 default:
                     throw new ArgumentOutOfRangeException(nameof(status), status, null);
             }
         }
 
-        private GroupDefinition defineGroupByBPM(double bpm)
+        private IEnumerable<GroupDefinition> defineGroupByBPM(double bpm)
         {
             if (bpm < 60)
-                return new GroupDefinition(60, "Under 60 BPM");
+                return new GroupDefinition(60, "Under 60 BPM").Yield();
 
             for (int i = 70; i <= 300; i += 10)
             {
                 if (bpm < i)
-                    return new GroupDefinition(i, $"{i - 10} - {i} BPM");
+                    return new GroupDefinition(i, $"{i - 10} - {i} BPM").Yield();
             }
 
-            return new GroupDefinition(301, "Over 300 BPM");
+            return new GroupDefinition(301, "Over 300 BPM").Yield();
         }
 
-        private GroupDefinition defineGroupByStars(double stars)
+        private IEnumerable<GroupDefinition> defineGroupByStars(double stars)
         {
             // truncation is intentional - compare `FormatUtils.FormatStarRating()`
             int starInt = (int)stars;
             var starDifficulty = new StarDifficulty(starInt, 0);
 
             if (starInt == 0)
-                return new StarDifficultyGroupDefinition(0, "Below 1 Star", starDifficulty);
+                return new StarDifficultyGroupDefinition(0, "Below 1 Star", starDifficulty).Yield();
 
             if (starInt == 1)
-                return new StarDifficultyGroupDefinition(1, "1 Star", starDifficulty);
+                return new StarDifficultyGroupDefinition(1, "1 Star", starDifficulty).Yield();
 
-            return new StarDifficultyGroupDefinition(starInt, $"{starInt} Stars", starDifficulty);
+            return new StarDifficultyGroupDefinition(starInt, $"{starInt} Stars", starDifficulty).Yield();
         }
 
-        private GroupDefinition defineGroupByLength(double length)
+        private IEnumerable<GroupDefinition> defineGroupByLength(double length)
         {
             for (int i = 1; i < 6; i++)
             {
                 if (length <= i * 60_000)
                 {
                     if (i == 1)
-                        return new GroupDefinition(1, "1 minute or less");
+                        return new GroupDefinition(1, "1 minute or less").Yield();
 
-                    return new GroupDefinition(i, $"{i} minutes or less");
+                    return new GroupDefinition(i, $"{i} minutes or less").Yield();
                 }
             }
 
             if (length <= 10 * 60_000)
-                return new GroupDefinition(10, "10 minutes or less");
+                return new GroupDefinition(10, "10 minutes or less").Yield();
 
-            return new GroupDefinition(11, "Over 10 minutes");
+            return new GroupDefinition(11, "Over 10 minutes").Yield();
         }
 
-        private GroupDefinition defineGroupBySource(string source)
+        private IEnumerable<GroupDefinition> defineGroupBySource(string source)
         {
             if (string.IsNullOrEmpty(source))
-                return new GroupDefinition(1, "Unsourced");
+                return new GroupDefinition(1, "Unsourced").Yield();
 
-            return new GroupDefinition(0, source);
+            return new GroupDefinition(0, source).Yield();
         }
 
-        private GroupDefinition defineGroupByCollection(BeatmapInfo beatmap, IEnumerable<BeatmapCollection> collections)
+        private IEnumerable<GroupDefinition> defineGroupByCollection(BeatmapInfo beatmap, IEnumerable<BeatmapCollection> collections)
         {
+            bool anyCollections = false;
+
             foreach (var collection in collections)
             {
                 if (collection.BeatmapMD5Hashes.Contains(beatmap.MD5Hash))
-                    return new GroupDefinition(0, collection.Name);
+                {
+                    yield return new GroupDefinition(0, collection.Name);
+
+                    anyCollections = true;
+                }
             }
 
-            return new GroupDefinition(1, "Not in collection");
+            if (anyCollections)
+                yield break;
+
+            yield return new GroupDefinition(1, "Not in collection");
         }
 
-        private GroupDefinition? defineGroupByOwnMaps(BeatmapInfo beatmap, int? localUserId, string? localUserUsername)
+        private IEnumerable<GroupDefinition> defineGroupByOwnMaps(BeatmapInfo beatmap, int? localUserId, string? localUserUsername)
         {
             var author = beatmap.BeatmapSet!.Metadata.Author;
 
             if (author.OnlineID == localUserId || (author.OnlineID <= 1 && author.Username == localUserUsername))
-                return new GroupDefinition(0, "My maps");
+                return new GroupDefinition(0, "My maps").Yield();
 
             // discard beatmaps not owned by the user.
-            return null;
+            return [];
         }
 
-        private GroupDefinition defineGroupByRankAchieved(BeatmapInfo beatmap, IReadOnlyDictionary<Guid, ScoreRank> topRankMapping)
+        private IEnumerable<GroupDefinition> defineGroupByRankAchieved(BeatmapInfo beatmap, IReadOnlyDictionary<Guid, ScoreRank> topRankMapping)
         {
             if (topRankMapping.TryGetValue(beatmap.ID, out var rank))
-                return new GroupDefinition(-(int)rank, rank.GetDescription());
+                return new RankDisplayGroupDefinition(rank).Yield();
 
-            return new GroupDefinition(int.MaxValue, "Unplayed");
-        }
-
-        private static T? aggregateMax<T>(BeatmapInfo b, Func<BeatmapInfo, T> func)
-        {
-            var beatmaps = b.BeatmapSet!.Beatmaps.Where(bb => !bb.Hidden);
-            return beatmaps.Max(func);
+            return new GroupDefinition(int.MaxValue, "Unplayed").Yield();
         }
 
         private record GroupMapping(GroupDefinition? Group, List<CarouselItem> ItemsInGroup);
diff --git a/osu.Game/Screens/SelectV2/BeatmapDetailsArea_Header.cs b/osu.Game/Screens/SelectV2/BeatmapDetailsArea.Header.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapDetailsArea_Header.cs
rename to osu.Game/Screens/SelectV2/BeatmapDetailsArea.Header.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapDetailsArea_WedgeSelector.cs b/osu.Game/Screens/SelectV2/BeatmapDetailsArea.WedgeSelector.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapDetailsArea_WedgeSelector.cs
rename to osu.Game/Screens/SelectV2/BeatmapDetailsArea.WedgeSelector.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore_Tooltip.cs b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.Tooltip.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapLeaderboardScore_Tooltip.cs
rename to osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.Tooltip.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
index 67f3075e0e..5013150f05 100644
--- a/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapLeaderboardScore.cs
@@ -392,9 +392,9 @@ namespace osu.Game.Screens.SelectV2
                                         Anchor = Anchor.Centre,
                                         Origin = Anchor.Centre,
                                         Spacing = new Vector2(-2),
-                                        Colour = DrawableRank.GetRankNameColour(Score.Rank),
+                                        Colour = DrawableRank.GetRankLetterColour(Score.Rank),
                                         Font = OsuFont.Numeric.With(size: 14),
-                                        Text = DrawableRank.GetRankName(Score.Rank),
+                                        Text = DrawableRank.GetRankLetter(Score.Rank),
                                         ShadowColour = Color4.Black.Opacity(0.3f),
                                         ShadowOffset = new Vector2(0, 0.08f),
                                         Shadow = true,
@@ -652,7 +652,7 @@ namespace osu.Game.Screens.SelectV2
                 Font = OsuFont.Style.Caption1.With(weight: FontWeight.SemiBold);
             }
 
-            protected override string Format() => Date.ToShortRelativeTime(TimeSpan.FromSeconds(30));
+            protected override LocalisableString Format() => Date.ToShortRelativeTime(TimeSpan.FromSeconds(30));
         }
 
         private partial class ScoreComponentLabel : Container
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_FailRetryDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.FailRetryDisplay.cs
similarity index 66%
rename from osu.Game/Screens/SelectV2/BeatmapMetadataWedge_FailRetryDisplay.cs
rename to osu.Game/Screens/SelectV2/BeatmapMetadataWedge.FailRetryDisplay.cs
index 048ec3c40d..9ee61b7c5c 100644
--- a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_FailRetryDisplay.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.FailRetryDisplay.cs
@@ -8,6 +8,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Rendering;
+using osu.Framework.Graphics.Rendering.Vertices;
+using osu.Framework.Graphics.Shaders;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
@@ -95,6 +97,14 @@ namespace osu.Game.Screens.SelectV2
                     }
                 }
 
+                private IShader shader = null!;
+
+                [BackgroundDependencyLoader]
+                private void load(ShaderManager shaders)
+                {
+                    shader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, "FastCircle");
+                }
+
                 protected override void Update()
                 {
                     base.Update();
@@ -123,6 +133,8 @@ namespace osu.Game.Screens.SelectV2
 
                     private Vector2 drawSize;
                     private float[] displayedData = null!;
+                    private IShader shader = null!;
+                    private IVertexBatch<TexturedVertex2D>? quadBatch;
 
                     public GraphDrawNode(GraphDrawable source)
                         : base(source)
@@ -136,6 +148,7 @@ namespace osu.Game.Screens.SelectV2
 
                         drawSize = source.DrawSize;
                         displayedData = source.displayedData;
+                        shader = source.shader;
                     }
 
                     protected override void Draw(IRenderer renderer)
@@ -150,6 +163,9 @@ namespace osu.Game.Screens.SelectV2
                         float totalSpacing = drawSize.X - barWidth * displayedData.Length;
                         float spacing = totalSpacing / (displayedData.Length - 1);
 
+                        quadBatch ??= renderer.CreateQuadBatch<TexturedVertex2D>(displayedData.Length * 4, 1);
+                        shader.Bind();
+
                         for (int i = 0; i < displayedData.Length; i++)
                         {
                             float barHeight = MathF.Max(drawSize.Y * displayedData[i], barWidth);
@@ -158,35 +174,61 @@ namespace osu.Game.Screens.SelectV2
 
                             position += barWidth + spacing;
                         }
+
+                        shader.Unbind();
                     }
 
                     private void drawBar(IRenderer renderer, float position, float width, float height)
                     {
-                        float cornerRadius = width / 2f;
-
-                        Vector3 scale = DrawInfo.MatrixInverse.ExtractScale();
-                        float blendRange = (scale.X + scale.Y) / 2;
+                        // Since bars have corner radius, to avoid masking usage and draw all bars in a single draw call
+                        // we are using FastCircle implementation.
+                        // Not using FastCircle directly to minimize drawable count.
 
                         RectangleF drawRectangle = new RectangleF(new Vector2(position, drawSize.Y - height), new Vector2(width, height));
+                        Vector4 textureRectangle = new Vector4(0, 0, drawRectangle.Width, drawRectangle.Height);
                         Quad screenSpaceDrawQuad = Quad.FromRectangle(drawRectangle) * DrawInfo.Matrix;
 
-                        renderer.PushMaskingInfo(new MaskingInfo
-                        {
-                            ScreenSpaceAABB = screenSpaceDrawQuad.AABB,
-                            MaskingRect = drawRectangle.Normalize(),
-                            ConservativeScreenSpaceQuad = screenSpaceDrawQuad,
-                            ToMaskingSpace = DrawInfo.MatrixInverse,
-                            CornerRadius = cornerRadius,
-                            CornerExponent = 2f,
-                            // We are setting the linear blend range to the approximate size of a _pixel_ here.
-                            // This results in the optimal trade-off between crispness and smoothness of the
-                            // edges of the masked region according to sampling theory.
-                            BlendRange = blendRange,
-                            AlphaExponent = 1,
-                        });
+                        var blend = new Vector2(Math.Min(drawRectangle.Width, drawRectangle.Height) / Math.Min(screenSpaceDrawQuad.Width, screenSpaceDrawQuad.Height));
 
-                        renderer.DrawQuad(renderer.WhitePixel, screenSpaceDrawQuad, DrawColourInfo.Colour);
-                        renderer.PopMaskingInfo();
+                        quadBatch?.AddAction(new TexturedVertex2D(renderer)
+                        {
+                            Position = screenSpaceDrawQuad.BottomLeft,
+                            TexturePosition = new Vector2(0, drawRectangle.Height),
+                            TextureRect = textureRectangle,
+                            BlendRange = blend,
+                            Colour = DrawColourInfo.Colour.BottomLeft.SRGB,
+                        });
+                        quadBatch?.AddAction(new TexturedVertex2D(renderer)
+                        {
+                            Position = screenSpaceDrawQuad.BottomRight,
+                            TexturePosition = new Vector2(drawRectangle.Width, drawRectangle.Height),
+                            TextureRect = textureRectangle,
+                            BlendRange = blend,
+                            Colour = DrawColourInfo.Colour.BottomRight.SRGB,
+                        });
+                        quadBatch?.AddAction(new TexturedVertex2D(renderer)
+                        {
+                            Position = screenSpaceDrawQuad.TopRight,
+                            TexturePosition = new Vector2(drawRectangle.Width, 0),
+                            TextureRect = textureRectangle,
+                            BlendRange = blend,
+                            Colour = DrawColourInfo.Colour.TopRight.SRGB,
+                        });
+                        quadBatch?.AddAction(new TexturedVertex2D(renderer)
+                        {
+                            Position = screenSpaceDrawQuad.TopLeft,
+                            TexturePosition = Vector2.Zero,
+                            TextureRect = textureRectangle,
+                            BlendRange = blend,
+                            Colour = DrawColourInfo.Colour.TopLeft.SRGB,
+                        });
+                    }
+
+                    protected override void Dispose(bool isDisposing)
+                    {
+                        base.Dispose(isDisposing);
+
+                        quadBatch?.Dispose();
                     }
                 }
             }
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_MetadataDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.MetadataDisplay.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapMetadataWedge_MetadataDisplay.cs
rename to osu.Game/Screens/SelectV2/BeatmapMetadataWedge.MetadataDisplay.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_RatingSpreadDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.RatingSpreadDisplay.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapMetadataWedge_RatingSpreadDisplay.cs
rename to osu.Game/Screens/SelectV2/BeatmapMetadataWedge.RatingSpreadDisplay.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_SuccessRateDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.SuccessRateDisplay.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapMetadataWedge_SuccessRateDisplay.cs
rename to osu.Game/Screens/SelectV2/BeatmapMetadataWedge.SuccessRateDisplay.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.TagsLine.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapMetadataWedge_TagsLine.cs
rename to osu.Game/Screens/SelectV2/BeatmapMetadataWedge.TagsLine.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapMetadataWedge_UserRatingDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapMetadataWedge.UserRatingDisplay.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapMetadataWedge_UserRatingDisplay.cs
rename to osu.Game/Screens/SelectV2/BeatmapMetadataWedge.UserRatingDisplay.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.DifficultyDisplay.cs
similarity index 99%
rename from osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
rename to osu.Game/Screens/SelectV2/BeatmapTitleWedge.DifficultyDisplay.cs
index 0e880a740f..55ed488d87 100644
--- a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyDisplay.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.DifficultyDisplay.cs
@@ -249,7 +249,7 @@ namespace osu.Game.Screens.SelectV2
                     mapperText.Text = beatmap.Value.Metadata.Author.Username;
                 }
 
-                starRatingDisplay.Current = (Bindable<StarDifficulty>)difficultyCache.GetBindableDifficulty(beatmap.Value.BeatmapInfo, cancellationSource.Token, SongSelect.SELECTION_DEBOUNCE);
+                starRatingDisplay.Current = (Bindable<StarDifficulty>)difficultyCache.GetBindableDifficulty(beatmap.Value.BeatmapInfo, cancellationSource.Token, SongSelect.DIFFICULTY_CALCULATION_DEBOUNCE);
 
                 updateCountStatistics(cancellationSource.Token);
                 updateDifficultyStatistics();
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.DifficultyStatisticsDisplay.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapTitleWedge_DifficultyStatisticsDisplay.cs
rename to osu.Game/Screens/SelectV2/BeatmapTitleWedge.DifficultyStatisticsDisplay.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_FavouriteButton.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.FavouriteButton.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapTitleWedge_FavouriteButton.cs
rename to osu.Game/Screens/SelectV2/BeatmapTitleWedge.FavouriteButton.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_Statistic.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.Statistic.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapTitleWedge_Statistic.cs
rename to osu.Game/Screens/SelectV2/BeatmapTitleWedge.Statistic.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.StatisticDifficulty.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticDifficulty.cs
rename to osu.Game/Screens/SelectV2/BeatmapTitleWedge.StatisticDifficulty.cs
diff --git a/osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticPlayCount.cs b/osu.Game/Screens/SelectV2/BeatmapTitleWedge.StatisticPlayCount.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/BeatmapTitleWedge_StatisticPlayCount.cs
rename to osu.Game/Screens/SelectV2/BeatmapTitleWedge.StatisticPlayCount.cs
diff --git a/osu.Game/Screens/SelectV2/FilterControl_DifficultyRangeSlider.cs b/osu.Game/Screens/SelectV2/FilterControl.DifficultyRangeSlider.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/FilterControl_DifficultyRangeSlider.cs
rename to osu.Game/Screens/SelectV2/FilterControl.DifficultyRangeSlider.cs
diff --git a/osu.Game/Screens/SelectV2/FooterButtonOptions_Popover.cs b/osu.Game/Screens/SelectV2/FooterButtonOptions.Popover.cs
similarity index 100%
rename from osu.Game/Screens/SelectV2/FooterButtonOptions_Popover.cs
rename to osu.Game/Screens/SelectV2/FooterButtonOptions.Popover.cs
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmap.cs b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
index 106b911606..59603e145d 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmap.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -72,6 +71,8 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private ISongSelect? songSelect { get; set; }
 
+        private BeatmapInfo beatmap => ((GroupedBeatmap)Item!.Model).Beatmap;
+
         public PanelBeatmap()
         {
             PanelXOffset = 60;
@@ -207,9 +208,6 @@ namespace osu.Game.Screens.SelectV2
         {
             base.PrepareForUse();
 
-            Debug.Assert(Item != null);
-            var beatmap = (BeatmapInfo)Item.Model;
-
             difficultyIcon.Icon = getRulesetIcon(beatmap.Ruleset);
 
             localRank.Beatmap = beatmap;
@@ -248,9 +246,7 @@ namespace osu.Game.Screens.SelectV2
             if (Item == null)
                 return;
 
-            var beatmap = (BeatmapInfo)Item.Model;
-
-            starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, starDifficultyCancellationSource.Token, SongSelect.SELECTION_DEBOUNCE);
+            starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, starDifficultyCancellationSource.Token, SongSelect.DIFFICULTY_CALCULATION_DEBOUNCE);
             starDifficultyBindable.BindValueChanged(starDifficulty =>
             {
                 starRatingDisplay.Current.Value = starDifficulty.NewValue;
@@ -293,8 +289,6 @@ namespace osu.Game.Screens.SelectV2
             if (Item == null)
                 return;
 
-            var beatmap = (BeatmapInfo)Item.Model;
-
             if (ruleset.Value.OnlineID == 3)
             {
                 // Account for mania differences locally for now.
@@ -319,7 +313,7 @@ namespace osu.Game.Screens.SelectV2
                 List<MenuItem> items = new List<MenuItem>();
 
                 if (songSelect != null)
-                    items.AddRange(songSelect.GetForwardActions((BeatmapInfo)Item.Model));
+                    items.AddRange(songSelect.GetForwardActions(beatmap));
 
                 return items.ToArray();
             }
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
index d776ab1ffb..a52d3fa216 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
@@ -67,6 +67,15 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private IBindable<RulesetInfo> ruleset { get; set; } = null!;
 
+        private GroupedBeatmapSet groupedBeatmapSet
+        {
+            get
+            {
+                Debug.Assert(Item != null);
+                return (GroupedBeatmapSet)Item!.Model;
+            }
+        }
+
         public PanelBeatmapSet()
         {
             PanelXOffset = 20f;
@@ -125,12 +134,6 @@ namespace osu.Game.Screens.SelectV2
                             Margin = new MarginPadding { Top = 4f },
                             Children = new Drawable[]
                             {
-                                updateButton = new PanelUpdateBeatmapButton
-                                {
-                                    Anchor = Anchor.CentreLeft,
-                                    Origin = Anchor.CentreLeft,
-                                    Margin = new MarginPadding { Right = 5f, Top = -2f },
-                                },
                                 statusPill = new BeatmapSetOnlineStatusPill
                                 {
                                     Origin = Anchor.CentreLeft,
@@ -139,6 +142,12 @@ namespace osu.Game.Screens.SelectV2
                                     Margin = new MarginPadding { Right = 5f },
                                     Animated = false,
                                 },
+                                updateButton = new PanelUpdateBeatmapButton
+                                {
+                                    Anchor = Anchor.CentreLeft,
+                                    Origin = Anchor.CentreLeft,
+                                    Margin = new MarginPadding { Right = 5f, Top = -2f },
+                                },
                                 difficultiesDisplay = new DifficultySpectrumDisplay
                                 {
                                     Anchor = Anchor.CentreLeft,
@@ -179,9 +188,7 @@ namespace osu.Game.Screens.SelectV2
         {
             base.PrepareForUse();
 
-            Debug.Assert(Item != null);
-
-            var beatmapSet = (BeatmapSetInfo)Item.Model;
+            var beatmapSet = groupedBeatmapSet.BeatmapSet;
 
             // Choice of background image matches BSS implementation (always uses the lowest `beatmap_id` from the set).
             setBackground.Beatmap = beatmaps.GetWorkingBeatmap(beatmapSet.Beatmaps.MinBy(b => b.OnlineID));
@@ -215,7 +222,7 @@ namespace osu.Game.Screens.SelectV2
                 if (Item == null)
                     return Array.Empty<MenuItem>();
 
-                var beatmapSet = (BeatmapSetInfo)Item.Model;
+                var beatmapSet = groupedBeatmapSet.BeatmapSet;
 
                 List<MenuItem> items = new List<MenuItem>();
 
@@ -268,9 +275,7 @@ namespace osu.Game.Screens.SelectV2
 
         private MenuItem createCollectionMenuItem(BeatmapCollection collection)
         {
-            var beatmapSet = (BeatmapSetInfo)Item!.Model;
-
-            Debug.Assert(beatmapSet != null);
+            var beatmapSet = groupedBeatmapSet.BeatmapSet;
 
             TernaryState state;
 
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
index 87a35facbd..4ac05c0308 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapStandalone.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -73,6 +72,8 @@ namespace osu.Game.Screens.SelectV2
 
         private Box backgroundBorder = null!;
 
+        private BeatmapInfo beatmap => ((GroupedBeatmap)Item!.Model).Beatmap;
+
         public PanelBeatmapStandalone()
         {
             PanelXOffset = 20;
@@ -219,9 +220,6 @@ namespace osu.Game.Screens.SelectV2
         {
             base.PrepareForUse();
 
-            Debug.Assert(Item != null);
-
-            var beatmap = (BeatmapInfo)Item.Model;
             var beatmapSet = beatmap.BeatmapSet!;
 
             beatmapBackground.Beatmap = beatmaps.GetWorkingBeatmap(beatmap);
@@ -262,9 +260,7 @@ namespace osu.Game.Screens.SelectV2
             if (Item == null)
                 return;
 
-            var beatmap = (BeatmapInfo)Item.Model;
-
-            starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, starDifficultyCancellationSource.Token, SongSelect.SELECTION_DEBOUNCE);
+            starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, starDifficultyCancellationSource.Token, SongSelect.DIFFICULTY_CALCULATION_DEBOUNCE);
             starDifficultyBindable.BindValueChanged(starDifficulty =>
             {
                 starRatingDisplay.Current.Value = starDifficulty.NewValue;
@@ -300,8 +296,6 @@ namespace osu.Game.Screens.SelectV2
             if (Item == null)
                 return;
 
-            var beatmap = (BeatmapInfo)Item.Model;
-
             if (ruleset.Value.OnlineID == 3)
             {
                 // Account for mania differences locally for now.
@@ -326,7 +320,7 @@ namespace osu.Game.Screens.SelectV2
                 List<MenuItem> items = new List<MenuItem>();
 
                 if (songSelect != null)
-                    items.AddRange(songSelect.GetForwardActions((BeatmapInfo)Item.Model));
+                    items.AddRange(songSelect.GetForwardActions(beatmap));
 
                 return items.ToArray();
             }
diff --git a/osu.Game/Screens/SelectV2/PanelGroupRankDisplay.cs b/osu.Game/Screens/SelectV2/PanelGroupRankDisplay.cs
new file mode 100644
index 0000000000..6895c30fee
--- /dev/null
+++ b/osu.Game/Screens/SelectV2/PanelGroupRankDisplay.cs
@@ -0,0 +1,226 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Diagnostics;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Backgrounds;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Leaderboards;
+using osu.Game.Overlays;
+using osu.Game.Scoring;
+using osuTK;
+using osuTK.Graphics;
+using WebCommonStrings = osu.Game.Resources.Localisation.Web.CommonStrings;
+
+namespace osu.Game.Screens.SelectV2
+{
+    public partial class PanelGroupRankDisplay : Panel
+    {
+        public const float HEIGHT = PanelGroup.HEIGHT;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
+
+        private Drawable iconContainer = null!;
+        private Box backgroundBorder = null!;
+        private Box contentBackground = null!;
+        private OsuSpriteText starRatingText = null!;
+        private CircularContainer countPill = null!;
+        private OsuSpriteText countText = null!;
+        private TrianglesV2 triangles = null!;
+        private Box glow = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Height = PanelGroup.HEIGHT;
+
+            Icon = iconContainer = new Container
+            {
+                AlwaysPresent = true,
+                RelativeSizeAxes = Axes.Y,
+                Alpha = 0f,
+                Child = new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Icon = FontAwesome.Solid.ChevronDown,
+                    Size = new Vector2(12),
+                },
+            };
+
+            Background = backgroundBorder = new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Colour = colourProvider.Highlight1,
+            };
+
+            AccentColour = colourProvider.Highlight1;
+            Content.Children = new Drawable[]
+            {
+                contentBackground = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+                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)),
+                },
+                new FillFlowContainer
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    AutoSizeAxes = Axes.Both,
+                    Spacing = new Vector2(10f, 0f),
+                    Margin = new MarginPadding { Left = 10f },
+                    Children = new Drawable[]
+                    {
+                        starRatingText = new OsuSpriteText
+                        {
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            UseFullGlyphHeight = false,
+                            Font = OsuFont.Style.Heading2,
+                        }
+                    }
+                },
+                countPill = new CircularContainer
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    Size = new Vector2(50f, 14f),
+                    Margin = new MarginPadding { Right = 30f },
+                    Masking = true,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Color4.Black.Opacity(0.7f),
+                        },
+                        countText = new OsuSpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Font = OsuFont.Style.Caption1.With(weight: FontWeight.Bold),
+                            UseFullGlyphHeight = false,
+                        }
+                    },
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Expanded.BindValueChanged(_ => onExpanded(), true);
+        }
+
+        private Color4 rankColour;
+
+        protected override void PrepareForUse()
+        {
+            base.PrepareForUse();
+
+            Debug.Assert(Item != null);
+
+            var group = (RankDisplayGroupDefinition)Item.Model;
+            ScoreRank rank = group.Rank;
+
+            rankColour = OsuColour.ForRank(rank);
+
+            AccentColour = rankColour;
+            backgroundBorder.Colour = rankColour;
+            contentBackground.Colour = rankColour.Darken(1f);
+            glow.Colour = ColourInfo.GradientHorizontal(rankColour, rankColour.Opacity(0f));
+
+            switch (rank)
+            {
+                case ScoreRank.SH:
+                case ScoreRank.XH:
+                    starRatingText.Colour = DrawableRank.GetRankLetterColour(rank);
+                    iconContainer.Colour = colourProvider.Background5;
+                    break;
+
+                case ScoreRank.X:
+                case ScoreRank.S:
+                    starRatingText.Colour = DrawableRank.GetRankLetterColour(rank);
+                    iconContainer.Colour = colourProvider.Background5;
+                    break;
+
+                case ScoreRank.F:
+                    starRatingText.Colour = DrawableRank.GetRankLetterColour(rank);
+                    iconContainer.Colour = colourProvider.Content1;
+                    break;
+
+                default:
+                    starRatingText.Colour = Color4.White;
+                    iconContainer.Colour = colourProvider.Background5;
+                    break;
+            }
+
+            starRatingText.Text = group.Title;
+
+            ColourInfo colour = ColourInfo.GradientHorizontal(rankColour.Darken(0.6f), rankColour.Darken(0.8f));
+
+            triangles.Colour = colour;
+
+            countText.Text = Item.NestedItemCount.ToLocalisableString(@"N0");
+
+            onExpanded();
+        }
+
+        private void onExpanded()
+        {
+            const float duration = 500;
+
+            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);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // Move the count pill in the opposite direction to keep it pinned to the screen regardless of the X position of TopLevelContent.
+            countPill.X = -TopLevelContent.X;
+        }
+
+        public override MenuItem[] ContextMenuItems
+        {
+            get
+            {
+                if (Item == null)
+                    return Array.Empty<MenuItem>();
+
+                return new MenuItem[]
+                {
+                    new OsuMenuItem(Expanded.Value ? WebCommonStrings.ButtonsCollapse.ToSentence() : WebCommonStrings.ButtonsExpand.ToSentence(), MenuItemType.Highlighted, () => TriggerClick())
+                };
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs b/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs
index 273f995794..c72835144f 100644
--- a/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs
+++ b/osu.Game/Screens/SelectV2/PanelLocalRankDisplay.cs
@@ -9,7 +9,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
-using osu.Game.Models;
 using osu.Game.Online.API;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Rulesets;
@@ -78,12 +77,9 @@ namespace osu.Game.Screens.SelectV2
                 return;
 
             scoreSubscription = realm.RegisterForNotifications(r =>
-                    r.All<ScoreInfo>()
-                     .Filter($"{nameof(ScoreInfo.User)}.{nameof(RealmUser.OnlineID)} == $0"
-                             + $" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $1"
-                             + $" && {nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.Hash)} == {nameof(ScoreInfo.BeatmapHash)}"
-                             + $" && {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $2"
-                             + $" && {nameof(ScoreInfo.DeletePending)} == false", api.LocalUser.Value.Id, beatmap.ID, ruleset.Value.ShortName),
+                    r.GetAllLocalScoresForUser(api.LocalUser.Value.Id)
+                     .Filter($@"{nameof(ScoreInfo.BeatmapInfo)}.{nameof(BeatmapInfo.ID)} == $0"
+                             + $" && {nameof(ScoreInfo.Ruleset)}.{nameof(RulesetInfo.ShortName)} == $1", beatmap.ID, ruleset.Value.ShortName),
                 localScoresChanged);
         }
 
diff --git a/osu.Game/Screens/SelectV2/RealmPopulatingOnlineLookupSource.cs b/osu.Game/Screens/SelectV2/RealmPopulatingOnlineLookupSource.cs
index 486dfbe255..832095058a 100644
--- a/osu.Game/Screens/SelectV2/RealmPopulatingOnlineLookupSource.cs
+++ b/osu.Game/Screens/SelectV2/RealmPopulatingOnlineLookupSource.cs
@@ -43,6 +43,8 @@ namespace osu.Game.Screens.SelectV2
             var request = new GetBeatmapSetRequest(id);
             var tcs = new TaskCompletionSource<APIBeatmapSet?>();
 
+            token.Register(() => request.Cancel());
+
             // async request success callback is a bit of a dangerous game, but there's some reasoning for it.
             // - don't really want to use `IAPIAccess.PerformAsync()` because we still want to respect request queueing & online status checks
             // - we want the realm write here to be async because it is known to be slow for some users with large beatmap collections
diff --git a/osu.Game/Screens/SelectV2/SongSelect.cs b/osu.Game/Screens/SelectV2/SongSelect.cs
index 947b8f9c7c..64262ed6ab 100644
--- a/osu.Game/Screens/SelectV2/SongSelect.cs
+++ b/osu.Game/Screens/SelectV2/SongSelect.cs
@@ -12,6 +12,7 @@ using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
+using osu.Framework.Development;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -20,6 +21,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Input.StateChanges;
@@ -63,9 +65,20 @@ namespace osu.Game.Screens.SelectV2
     [Cached(typeof(ISongSelect))]
     public abstract partial class SongSelect : ScreenWithBeatmapBackground, IKeyBindingHandler<GlobalAction>, ISongSelect
     {
-        // this is intentionally slightly higher than key repeat, but low enough to not impede user experience.
-        // this avoids rapid churn loading when iterating the carousel using keyboard.
-        public const int SELECTION_DEBOUNCE = 100;
+        /// <summary>
+        /// A debounce that governs how long after a panel is selected before the rest of song select (and the game at large)
+        /// updates to show that selection.
+        ///
+        /// This is intentionally slightly higher than key repeat, but low enough to not impede user experience.
+        /// </summary>
+        public const int SELECTION_DEBOUNCE = 150;
+
+        /// <summary>
+        /// A general "global" debounce to be applied to anything aggressive difficulty calculation at song select,
+        /// either after selection or after a panel comes on screen. Value should be low enough that users don't complain,
+        /// but otherwise as high as possible to reduce overheads.
+        /// </summary>
+        public const int DIFFICULTY_CALCULATION_DEBOUNCE = 150;
 
         private const float logo_scale = 0.4f;
         private const double fade_duration = 300;
@@ -137,6 +150,8 @@ namespace osu.Game.Screens.SelectV2
         [Resolved]
         private IDialogOverlay? dialogOverlay { get; set; }
 
+        private InputManager inputManager = null!;
+
         private readonly RealmPopulatingOnlineLookupSource onlineLookupSource = new RealmPopulatingOnlineLookupSource();
 
         private Bindable<bool> configBackgroundBlur = null!;
@@ -289,9 +304,10 @@ namespace osu.Game.Screens.SelectV2
             });
         }
 
-        private void requestRecommendedSelection(IEnumerable<BeatmapInfo> b)
+        private void requestRecommendedSelection(IEnumerable<GroupedBeatmap> groupedBeatmaps)
         {
-            queueBeatmapSelection(difficultyRecommender?.GetRecommendedBeatmap(b) ?? b.First());
+            var recommendedBeatmap = difficultyRecommender?.GetRecommendedBeatmap(groupedBeatmaps.Select(gb => gb.Beatmap)) ?? groupedBeatmaps.First().Beatmap;
+            queueBeatmapSelection(groupedBeatmaps.First(bug => bug.Beatmap.Equals(recommendedBeatmap)));
         }
 
         /// <summary>
@@ -332,6 +348,8 @@ namespace osu.Game.Screens.SelectV2
         {
             base.LoadComplete();
 
+            inputManager = GetContainingInputManager()!;
+
             filterControl.CriteriaChanged += criteriaChanged;
 
             modSelectOverlay.State.BindValueChanged(v =>
@@ -370,8 +388,67 @@ namespace osu.Game.Screens.SelectV2
                 new Dimension(),
                 new Dimension(GridSizeMode.Relative, 0.5f, minSize: 500, maxSize: 700 + widescreenBonusWidth * 300),
             };
+
+            if (this.IsCurrentScreen())
+                updateDebounce();
         }
 
+        #region Selection debounce
+
+        private BeatmapInfo? debounceQueuedSelection;
+        private double debounceElapsedTime;
+
+        private void debounceQueueSelection(BeatmapInfo beatmap)
+        {
+            debounceQueuedSelection = beatmap;
+            debounceElapsedTime = 0;
+        }
+
+        private void updateDebounce()
+        {
+            if (debounceQueuedSelection == null) return;
+
+            double elapsed = Clock.ElapsedFrameTime;
+
+            // When a key is being held, assume the user is traversing the carousel using key repeat.
+            // We want to change panels less often in this state (basically making debounce longer than initial key repeat, at least).
+            double debounceInterval = inputManager.CurrentState.Keyboard.Keys.HasAnyButtonPressed ? SELECTION_DEBOUNCE * 2 : SELECTION_DEBOUNCE;
+
+            // avoid debounce running early if there's a single long frame.
+            if (!DebugUtils.IsNUnitRunning && Clock.FramesPerSecond > 0)
+                elapsed = Math.Min(1000 / Clock.FramesPerSecond, elapsed);
+
+            debounceElapsedTime += elapsed;
+
+            if (debounceElapsedTime >= debounceInterval)
+                performDebounceSelection();
+        }
+
+        private void performDebounceSelection()
+        {
+            if (debounceQueuedSelection == null) return;
+
+            try
+            {
+                if (Beatmap.Value.BeatmapInfo.Equals(debounceQueuedSelection))
+                    return;
+
+                Beatmap.Value = beatmaps.GetWorkingBeatmap(debounceQueuedSelection);
+            }
+            finally
+            {
+                cancelDebounceSelection();
+            }
+        }
+
+        private void cancelDebounceSelection()
+        {
+            debounceQueuedSelection = null;
+            debounceElapsedTime = 0;
+        }
+
+        #endregion
+
         #region Audio
 
         [Resolved]
@@ -435,8 +512,6 @@ namespace osu.Game.Screens.SelectV2
 
         #region Selection handling
 
-        private ScheduledDelegate? selectionDebounce;
-
         /// <summary>
         /// Finalises selection on the given <see cref="BeatmapInfo"/> and runs the provided action if possible.
         /// </summary>
@@ -452,7 +527,7 @@ namespace osu.Game.Screens.SelectV2
 
             // To ensure sanity, cancel any pending selection as we are about to force a selection.
             // Carousel selection will update to the forced selection via a call of `ensureGlobalBeatmapValid` below, or when song select becomes current again.
-            selectionDebounce?.Cancel();
+            cancelDebounceSelection();
 
             // Forced refetch is important here to guarantee correct invalidation across all difficulties (editor specific).
             Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap, true);
@@ -472,23 +547,16 @@ namespace osu.Game.Screens.SelectV2
         /// - After <see cref="SELECTION_DEBOUNCE"/>, update the global beatmap. This in turn causes song select visuals (title, details, leaderboard) to update.
         ///   This debounce is intended to avoid high overheads from churning lookups while a user is changing selection via rapid keyboard operations.
         /// </remarks>
-        /// <param name="beatmap">The beatmap to be selected.</param>
-        private void queueBeatmapSelection(BeatmapInfo beatmap)
+        /// <param name="groupedBeatmap">The beatmap to be selected.</param>
+        private void queueBeatmapSelection(GroupedBeatmap groupedBeatmap)
         {
             if (!this.IsCurrentScreen())
                 return;
 
-            carousel.CurrentSelection = beatmap;
+            carousel.CurrentGroupedBeatmap = groupedBeatmap;
 
             // Debounce consideration is to avoid beatmap churn on key repeat selection.
-            selectionDebounce?.Cancel();
-            selectionDebounce = Scheduler.AddDelayed(() =>
-            {
-                if (Beatmap.Value.BeatmapInfo.Equals(beatmap))
-                    return;
-
-                Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap);
-            }, SELECTION_DEBOUNCE);
+            debounceQueueSelection(groupedBeatmap.Beatmap);
         }
 
         private bool ensureGlobalBeatmapValid()
@@ -496,7 +564,7 @@ namespace osu.Game.Screens.SelectV2
             if (!this.IsCurrentScreen())
                 return false;
 
-            finaliseBeatmapSelection();
+            performDebounceSelection();
 
             // While filtering, let's not ever attempt to change selection.
             // This will be resolved after the filter completes, see `newItemsPresented`.
@@ -509,7 +577,7 @@ namespace osu.Game.Screens.SelectV2
 
             if (validSelection)
             {
-                carousel.CurrentSelection = currentBeatmap.BeatmapInfo;
+                carousel.CurrentBeatmap = currentBeatmap.BeatmapInfo;
                 return true;
             }
 
@@ -517,7 +585,7 @@ namespace osu.Game.Screens.SelectV2
             if (Beatmap.IsDefault)
             {
                 validSelection = carousel.NextRandom();
-                finaliseBeatmapSelection();
+                performDebounceSelection();
                 return validSelection;
             }
 
@@ -532,22 +600,18 @@ namespace osu.Game.Screens.SelectV2
 
                 if (validBeatmaps.Any())
                 {
-                    requestRecommendedSelection(validBeatmaps);
+                    var beatmap = difficultyRecommender?.GetRecommendedBeatmap(validBeatmaps) ?? validBeatmaps.First();
+                    carousel.CurrentBeatmap = beatmap;
+                    debounceQueueSelection(beatmap);
                     return true;
                 }
             }
 
             // If all else fails, use the default beatmap.
             Beatmap.SetDefault();
-            finaliseBeatmapSelection();
+            performDebounceSelection();
 
             return validSelection;
-
-            void finaliseBeatmapSelection()
-            {
-                if (selectionDebounce?.State == ScheduledDelegate.RunState.Waiting)
-                    selectionDebounce?.RunTask();
-            }
         }
 
         private bool checkBeatmapValidForSelection(BeatmapInfo beatmap, FilterCriteria? criteria)
@@ -653,6 +717,7 @@ namespace osu.Game.Screens.SelectV2
 
             ensurePlayingSelected();
             updateBackgroundDim();
+            fetchOnlineInfo(force: true);
         }
 
         private void onLeavingScreen()
@@ -793,7 +858,7 @@ namespace osu.Game.Screens.SelectV2
             // Interrupting could cause the debounce interval to be reduced.
             //
             // `ensureGlobalBeatmapValid` is run post-selection which will resolve any pending incompatibilities (see `Beatmap` bindable callback).
-            if (selectionDebounce?.State != ScheduledDelegate.RunState.Waiting)
+            if (debounceQueuedSelection == null)
                 ensureGlobalBeatmapValid();
 
             updateWedgeVisibility();
@@ -922,6 +987,14 @@ namespace osu.Game.Screens.SelectV2
 
             switch (e.Action)
             {
+                case GlobalAction.Select:
+                    // in most circumstances this is handled already by the carousel itself, but there are cases where it will not be.
+                    // one of which is filtering out all visible beatmaps and attempting to start gameplay.
+                    // in that case, users still expect a `Select` press to advance to gameplay anyway, using the ambient selected beatmap if there is one,
+                    // which matches the behaviour resulting from clicking the osu! cookie in that scenario.
+                    SelectAndRun(Beatmap.Value.BeatmapInfo, OnStart);
+                    return true;
+
                 case GlobalAction.IncreaseModSpeed:
                     return modSpeedHotkeyHandler.ChangeSpeed(0.05, flattenedMods);
 
@@ -993,14 +1066,15 @@ namespace osu.Game.Screens.SelectV2
         private CancellationTokenSource? onlineLookupCancellation;
         private Task<APIBeatmapSet?>? currentOnlineLookup;
 
-        private void fetchOnlineInfo()
+        private void fetchOnlineInfo(bool force = false)
         {
             var beatmapSetInfo = Beatmap.Value.BeatmapSetInfo;
 
-            if (lastLookupResult.Value?.Result?.OnlineID == beatmapSetInfo.OnlineID)
+            if (lastLookupResult.Value?.Result?.OnlineID == beatmapSetInfo.OnlineID && !force)
                 return;
 
             onlineLookupCancellation?.Cancel();
+            onlineLookupCancellation = null;
 
             if (beatmapSetInfo.OnlineID < 0)
             {
@@ -1010,7 +1084,7 @@ namespace osu.Game.Screens.SelectV2
 
             lastLookupResult.Value = BeatmapSetLookupResult.InProgress();
             onlineLookupCancellation = new CancellationTokenSource();
-            currentOnlineLookup = onlineLookupSource.GetBeatmapSetAsync(beatmapSetInfo.OnlineID);
+            currentOnlineLookup = onlineLookupSource.GetBeatmapSetAsync(beatmapSetInfo.OnlineID, onlineLookupCancellation.Token);
             currentOnlineLookup.ContinueWith(t =>
             {
                 if (t.IsCompletedSuccessfully)
diff --git a/osu.Game/Skinning/Components/ArgonJudgementCounter.cs b/osu.Game/Skinning/Components/ArgonJudgementCounter.cs
new file mode 100644
index 0000000000..84973aab3e
--- /dev/null
+++ b/osu.Game/Skinning/Components/ArgonJudgementCounter.cs
@@ -0,0 +1,74 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+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.Game.Graphics;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Play.HUD.JudgementCounter;
+using osuTK.Graphics;
+
+namespace osu.Game.Skinning.Components
+{
+    public sealed partial class ArgonJudgementCounter : VisibilityContainer
+    {
+        public readonly JudgementCount Result;
+
+        public IBindable<float> WireframeOpacity => textComponent.WireframeOpacity;
+
+        public IBindable<int?> WireframeDigits { get; } = new Bindable<int?>();
+
+        public IBindable<bool> ShowLabel => textComponent.ShowLabel;
+
+        private readonly ArgonCounterTextComponent textComponent;
+        private readonly BindableInt displayedValue = new BindableInt();
+
+        [Resolved]
+        private OsuColour colours { get; set; } = null!;
+
+        public ArgonJudgementCounter(JudgementCount result)
+        {
+            Result = result;
+
+            AutoSizeAxes = Axes.Both;
+            AddInternal(textComponent = new ArgonCounterTextComponent(Anchor.TopLeft, result.DisplayName.ToUpper()));
+        }
+
+        private void updateWireframe()
+        {
+            textComponent.WireframeTemplate = new string('#', WireframeDigits.Value ?? Math.Max(2, textComponent.Text.ToString().Length));
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            WireframeDigits.BindValueChanged(_ => updateWireframe());
+
+            displayedValue.BindTo(Result.ResultCount);
+            displayedValue.BindValueChanged(v =>
+            {
+                textComponent.Text = v.NewValue.ToString();
+                updateWireframe();
+            }, true);
+
+            var result = Result.Types.First();
+            textComponent.LabelColour.Value = getJudgementColor(result);
+            textComponent.ShowLabel.BindValueChanged(v => textComponent.TextColour.Value = !v.NewValue ? getJudgementColor(result) : Color4.White, true);
+        }
+
+        private Color4 getJudgementColor(HitResult result)
+        {
+            return result.IsBasic() ? colours.ForHitResult(result) : !result.IsBonus() ? colours.PurpleLight : colours.PurpleLighter;
+        }
+
+        protected override void PopIn() => this.FadeIn(JudgementCounterDisplay.TRANSFORM_DURATION, Easing.OutQuint);
+        protected override void PopOut() => this.FadeOut();
+    }
+}
diff --git a/osu.Game/Skinning/Components/ArgonJudgementCounterDisplay.cs b/osu.Game/Skinning/Components/ArgonJudgementCounterDisplay.cs
new file mode 100644
index 0000000000..885b3922f2
--- /dev/null
+++ b/osu.Game/Skinning/Components/ArgonJudgementCounterDisplay.cs
@@ -0,0 +1,170 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Localisation;
+using osu.Game.Configuration;
+using osu.Game.Localisation.HUD;
+using osu.Game.Localisation.SkinComponents;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD.JudgementCounter;
+using osuTK;
+
+namespace osu.Game.Skinning.Components
+{
+    [UsedImplicitly]
+    public partial class ArgonJudgementCounterDisplay : CompositeDrawable, ISerialisableDrawable
+    {
+        [Resolved]
+        private JudgementCountController judgementCountController { get; set; } = null!;
+
+        [SettingSource("Wireframe opacity", "Controls the opacity of the wireframes behind the digits.")]
+        public BindableFloat WireframeOpacity { get; } = new BindableFloat(0.25f)
+        {
+            Precision = 0.01f,
+            MinValue = 0,
+            MaxValue = 1,
+        };
+
+        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.ShowLabel))]
+        public Bindable<bool> ShowLabel { get; } = new BindableBool(true);
+
+        [SettingSource(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.ShowMaxJudgement))]
+        public BindableBool ShowMaxJudgement { get; } = new BindableBool(true);
+
+        [SettingSource(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.JudgementDisplayMode))]
+        public Bindable<DisplayMode> Mode { get; } = new Bindable<DisplayMode>();
+
+        [SettingSource(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.FlowDirection))]
+        public Bindable<Direction> FlowDirection { get; } = new Bindable<Direction>();
+
+        private readonly Bindable<int?> wireframeDigits = new Bindable<int?>();
+
+        protected FillFlowContainer<ArgonJudgementCounter> CounterFlow = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AutoSizeAxes = Axes.Both;
+            InternalChild = CounterFlow = new FillFlowContainer<ArgonJudgementCounter>
+            {
+                Direction = getFillDirection(FlowDirection.Value),
+                Spacing = new Vector2(16),
+                AutoSizeAxes = Axes.Both,
+            };
+
+            foreach (var counter in judgementCountController.Counters)
+            {
+                counter.ResultCount.BindValueChanged(_ => updateWireframeDigits());
+                ArgonJudgementCounter counterComponent = new ArgonJudgementCounter(counter)
+                {
+                    WireframeOpacity = { BindTarget = WireframeOpacity },
+                    WireframeDigits = { BindTarget = wireframeDigits },
+                    ShowLabel = { BindTarget = ShowLabel },
+                };
+                CounterFlow.Add(counterComponent);
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            Mode.BindValueChanged(_ => updateVisibility());
+            ShowMaxJudgement.BindValueChanged(_ => updateVisibility(), true);
+            FlowDirection.BindValueChanged(_ => updateFlowDirection(), true);
+        }
+
+        private void updateVisibility()
+        {
+            for (int i = 0; i < CounterFlow.Children.Count; i++)
+            {
+                ArgonJudgementCounter counter = CounterFlow.Children[i];
+
+                if (shouldBeVisible(i, counter))
+                    counter.Show();
+                else
+                    counter.Hide();
+            }
+
+            updateWireframeDigits();
+        }
+
+        private void updateFlowDirection()
+        {
+            CounterFlow.Direction = getFillDirection(FlowDirection.Value);
+            updateWireframeDigits();
+        }
+
+        private void updateWireframeDigits()
+        {
+            var visibleCounters = CounterFlow.Children.Where(counter => counter.State.Value == Visibility.Visible).ToArray();
+
+            if (visibleCounters.Length == 0)
+                return;
+
+            wireframeDigits.Value = FlowDirection.Value == Direction.Vertical
+                ? Math.Max(2, visibleCounters.Max(counter => counter.Result.ResultCount.Value).ToString().Length)
+                : null;
+        }
+
+        private bool shouldBeVisible(int index, ArgonJudgementCounter counter)
+        {
+            if (index == 0 && !ShowMaxJudgement.Value)
+                return false;
+
+            var hitResult = counter.Result.Types.First();
+            if (hitResult.IsBasic())
+                return true;
+
+            switch (Mode.Value)
+            {
+                case DisplayMode.Simple:
+                    return false;
+
+                case DisplayMode.Normal:
+                    return !hitResult.IsBonus();
+
+                case DisplayMode.All:
+                    return true;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(Mode), Mode.Value, null);
+            }
+        }
+
+        private FillDirection getFillDirection(Direction flow)
+        {
+            switch (flow)
+            {
+                case Direction.Horizontal:
+                    return FillDirection.Horizontal;
+
+                case Direction.Vertical:
+                    return FillDirection.Vertical;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(flow), flow, null);
+            }
+        }
+
+        public enum DisplayMode
+        {
+            [LocalisableDescription(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.JudgementDisplayModeSimple))]
+            Simple,
+
+            [LocalisableDescription(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.JudgementDisplayModeNormal))]
+            Normal,
+
+            [LocalisableDescription(typeof(JudgementCounterDisplayStrings), nameof(JudgementCounterDisplayStrings.JudgementDisplayModeAll))]
+            All
+        }
+
+        public bool UsesFixedAnchor { get; set; }
+    }
+}
diff --git a/osu.Game/Skinning/LegacyRankDisplay.cs b/osu.Game/Skinning/LegacyRankDisplay.cs
index 7c2f8ffdef..64376f0dbd 100644
--- a/osu.Game/Skinning/LegacyRankDisplay.cs
+++ b/osu.Game/Skinning/LegacyRankDisplay.cs
@@ -34,10 +34,12 @@ namespace osu.Game.Skinning
         private SkinnableSound rankDownSample = null!;
         private SkinnableSound rankUpSample = null!;
 
-        private Bindable<double?> lastSamplePlaybackTime = null!;
+        private Bindable<double?> lastSamplePlayback = null!;
+        private double lastChangeTime;
 
-        private IBindable<ScoreRank> rank = null!;
-        private ScoreRank lastRank;
+        private ScoreRank? displayedRank;
+
+        private const int time_between_changes = 1500;
 
         public LegacyRankDisplay()
         {
@@ -62,51 +64,69 @@ namespace osu.Game.Skinning
             if (skinEditor != null)
                 PlaySamples.Value = false;
 
-            lastSamplePlaybackTime = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
+            lastSamplePlayback = statics.GetBindable<double?>(Static.LastRankChangeSamplePlaybackTime);
         }
 
         protected override void LoadComplete()
         {
-            rank = scoreProcessor.Rank.GetBoundCopy();
-            rank.BindValueChanged(r =>
+            base.LoadComplete();
+
+            updateRank(scoreProcessor.Rank.Value);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            var currentRank = scoreProcessor.Rank.Value;
+
+            if (currentRank == displayedRank)
+                return;
+
+            if (Time.Current - lastChangeTime >= time_between_changes || scoreProcessor.HasCompleted.Value || currentRank == ScoreRank.F)
+                updateRank(currentRank);
+        }
+
+        private void updateRank(ScoreRank rank)
+        {
+            var texture = source.GetTexture($"ranking-{rank}-small");
+
+            rankDisplay.Texture = texture;
+
+            if (texture != null && displayedRank != null)
             {
-                var texture = source.GetTexture($"ranking-{r.NewValue}-small");
-
-                rankDisplay.Texture = texture;
-
-                if (texture != null)
+                var transientRank = new Sprite
                 {
-                    var transientRank = new Sprite
-                    {
-                        Texture = texture,
-                        Blending = BlendingParameters.Additive,
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        BypassAutoSizeAxes = Axes.Both,
-                    };
-                    AddInternal(transientRank);
-                    transientRank.FadeOutFromOne(500, Easing.Out)
-                                 .ScaleTo(new Vector2(1.625f), 500, Easing.Out)
-                                 .Expire();
-                }
+                    Texture = texture,
+                    Blending = BlendingParameters.Additive,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    BypassAutoSizeAxes = Axes.Both,
+                };
 
-                bool enoughTimeElapsed = !lastSamplePlaybackTime.Value.HasValue || Time.Current - lastSamplePlaybackTime.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
+                AddInternal(transientRank);
 
-                // Don't play rank-down sfx on quit/retry
-                if (r.NewValue != r.OldValue && r.NewValue > ScoreRank.F && PlaySamples.Value && enoughTimeElapsed)
-                {
-                    if (r.NewValue > lastRank)
-                        rankUpSample.Play();
-                    else
-                        rankDownSample.Play();
+                transientRank.FadeOutFromOne(500, Easing.Out)
+                             .ScaleTo(new Vector2(1.625f), 500, Easing.Out)
+                             .Expire();
+            }
 
-                    lastSamplePlaybackTime.Value = Time.Current;
-                }
+            // Check sample time separately to ensure two copies of the rank display don't both play samples on a change.
+            bool enoughSampleTimeElapsed = !lastSamplePlayback.Value.HasValue || Time.Current - lastSamplePlayback.Value >= OsuGameBase.SAMPLE_DEBOUNCE_TIME;
 
-                lastRank = r.NewValue;
-            }, true);
+            // Also don't play rank-down sfx on quit/retry/initial update.
+            if (displayedRank != null && rank > ScoreRank.F && PlaySamples.Value && enoughSampleTimeElapsed)
+            {
+                if (rank > displayedRank)
+                    rankUpSample.Play();
+                else
+                    rankDownSample.Play();
 
-            FinishTransforms(true);
+                lastSamplePlayback.Value = Time.Current;
+            }
+
+            displayedRank = rank;
+            lastChangeTime = Time.Current;
         }
     }
 }
diff --git a/osu.Game/Skinning/LegacySkin.cs b/osu.Game/Skinning/LegacySkin.cs
index b648299787..11b3b5c71d 100644
--- a/osu.Game/Skinning/LegacySkin.cs
+++ b/osu.Game/Skinning/LegacySkin.cs
@@ -145,8 +145,10 @@ namespace osu.Game.Skinning
                     return SkinUtils.As<TValue>(new Bindable<float>(existing.ColumnWidth[maniaLookup.ColumnIndex.Value]));
 
                 case LegacyManiaSkinConfigurationLookups.WidthForNoteHeightScale:
-                    Debug.Assert(maniaLookup.ColumnIndex != null);
-                    return SkinUtils.As<TValue>(new Bindable<float>(existing.WidthForNoteHeightScale));
+                    float width = existing.WidthForNoteHeightScale;
+                    if (width <= 0)
+                        width = existing.MinimumColumnWidth;
+                    return SkinUtils.As<TValue>(new Bindable<float>(width));
 
                 case LegacyManiaSkinConfigurationLookups.HitPosition:
                     return SkinUtils.As<TValue>(new Bindable<float>(existing.HitPosition));
diff --git a/osu.Game/Skinning/RealmBackedResourceStore.cs b/osu.Game/Skinning/RealmBackedResourceStore.cs
index f41bd89b7a..0932485349 100644
--- a/osu.Game/Skinning/RealmBackedResourceStore.cs
+++ b/osu.Game/Skinning/RealmBackedResourceStore.cs
@@ -53,13 +53,8 @@ namespace osu.Game.Skinning
             }
         }
 
-        private string? getPathForFile(string filename)
-        {
-            if (fileToStoragePathMapping.Value.TryGetValue(filename.ToLowerInvariant(), out string? path))
-                return path;
-
-            return null;
-        }
+        private string? getPathForFile(string filename) =>
+            fileToStoragePathMapping.Value.GetValueOrDefault(filename.ToLowerInvariant());
 
         private void invalidateCache() => fileToStoragePathMapping = new Lazy<Dictionary<string, string>>(initialiseFileCache);
 
diff --git a/osu.Game/Skinning/RetroSkin.cs b/osu.Game/Skinning/RetroSkin.cs
new file mode 100644
index 0000000000..abeab9ab17
--- /dev/null
+++ b/osu.Game/Skinning/RetroSkin.cs
@@ -0,0 +1,58 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.IO.Stores;
+using osu.Game.Extensions;
+using osu.Game.IO;
+
+namespace osu.Game.Skinning
+{
+    /// <summary>
+    /// A skin that looks like osu!stable as it was around 2008.
+    /// </summary>
+    /// <remarks>
+    /// "Around 2008" was chosen as the cutoff for this skin because that's when the look of core gameplay settled into its final design (until <see cref="DefaultLegacySkin"/>). Skin elements from later versions of osu! were preferred as long as they only fixed bugs or applied minor tweaks to 2008 elements.
+    /// </remarks>
+    public class RetroSkin : LegacySkin
+    {
+        public static SkinInfo CreateInfo() => new SkinInfo
+        {
+            ID = Skinning.SkinInfo.RETRO_SKIN,
+            Name = "osu! \"retro\" (2008)",
+            Creator = "team osu!",
+            Protected = true,
+            InstantiationInfo = typeof(RetroSkin).GetInvariantInstantiationInfo(),
+        };
+
+        public RetroSkin(IStorageResourceProvider resources)
+            : this(CreateInfo(), resources)
+        {
+        }
+
+        [UsedImplicitly(ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature)]
+        public RetroSkin(SkinInfo skin, IStorageResourceProvider resources)
+            : base(
+                skin,
+                resources,
+                new NamespacedResourceStore<byte[]>(resources.Resources, "Skins/Retro")
+            )
+        {
+        }
+
+        public override Texture? GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT)
+        {
+            // Retro taiko hit explosions use osu textures
+            if (componentName.StartsWith("taiko-hit", StringComparison.Ordinal))
+                componentName = componentName.Substring(6);
+
+            // Retro taiko slider has no fail variant, but it needs to exist to avoid displaying nothing
+            if (componentName == "taiko-slider-fail")
+                componentName = "taiko-slider";
+
+            return base.GetTexture(componentName, wrapModeS, wrapModeT);
+        }
+    }
+}
diff --git a/osu.Game/Skinning/SkinInfo.cs b/osu.Game/Skinning/SkinInfo.cs
index 9763d3b57e..4c9c16e721 100644
--- a/osu.Game/Skinning/SkinInfo.cs
+++ b/osu.Game/Skinning/SkinInfo.cs
@@ -20,6 +20,7 @@ namespace osu.Game.Skinning
         internal static readonly Guid ARGON_SKIN = new Guid("CFFA69DE-B3E3-4DEE-8563-3C4F425C05D0");
         internal static readonly Guid ARGON_PRO_SKIN = new Guid("9FC9CF5D-0F16-4C71-8256-98868321AC43");
         internal static readonly Guid CLASSIC_SKIN = new Guid("81F02CD3-EEC6-4865-AC23-FAE26A386187");
+        internal static readonly Guid RETRO_SKIN = new Guid("0555C76A-CC6B-4BB4-9548-DF76BA72EF25");
         internal static readonly Guid RANDOM_SKIN = new Guid("D39DFEFB-477C-4372-B1EA-2BCEA5FB8908");
 
         [PrimaryKey]
diff --git a/osu.Game/Skinning/SkinManager.cs b/osu.Game/Skinning/SkinManager.cs
index 1be6f1bc4a..e92d0d3d49 100644
--- a/osu.Game/Skinning/SkinManager.cs
+++ b/osu.Game/Skinning/SkinManager.cs
@@ -64,6 +64,8 @@ namespace osu.Game.Skinning
 
         private Skin trianglesSkin { get; }
 
+        private Skin retroSkin { get; }
+
         public override bool PauseImports
         {
             get => base.PauseImports;
@@ -91,6 +93,7 @@ namespace osu.Game.Skinning
 
             var defaultSkins = new[]
             {
+                retroSkin = new RetroSkin(this),
                 DefaultClassicSkin = new DefaultLegacySkin(this),
                 trianglesSkin = new TrianglesSkin(this),
                 argonSkin = new ArgonSkin(this),
@@ -369,6 +372,9 @@ namespace osu.Game.Skinning
             {
                 if (guid == SkinInfo.CLASSIC_SKIN)
                     skinInfo = DefaultClassicSkin.SkinInfo;
+
+                if (guid == SkinInfo.RETRO_SKIN)
+                    skinInfo = retroSkin.SkinInfo;
             }
 
             CurrentSkinInfo.Value = skinInfo ?? trianglesSkin.SkinInfo;
diff --git a/osu.Game/Skinning/SkinnableContainer.cs b/osu.Game/Skinning/SkinnableContainer.cs
index aad95ca779..720699e708 100644
--- a/osu.Game/Skinning/SkinnableContainer.cs
+++ b/osu.Game/Skinning/SkinnableContainer.cs
@@ -21,6 +21,11 @@ namespace osu.Game.Skinning
     /// </remarks>
     public partial class SkinnableContainer : SkinReloadableDrawable, ISerialisableDrawableContainer
     {
+        /// <summary>
+        /// Invoked when the skinnable components of this container finish loading.
+        /// </summary>
+        public event Action<Drawable>? OnComponentsLoaded;
+
         private Container? content;
 
         /// <summary>
@@ -67,6 +72,7 @@ namespace osu.Game.Skinning
                 AddInternal(wrapper);
                 components.AddRange(wrapper.Children.OfType<ISerialisableDrawable>());
                 ComponentsLoaded = true;
+                OnComponentsLoaded?.Invoke(this);
             }, (cancellationSource = new CancellationTokenSource()).Token);
         }
 
@@ -106,5 +112,12 @@ namespace osu.Game.Skinning
 
             Reload();
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            OnComponentsLoaded = null;
+        }
     }
 }
diff --git a/osu.Game/Skinning/SkinnableSprite.cs b/osu.Game/Skinning/SkinnableSprite.cs
index 49ce7e48ab..25bc32eaf2 100644
--- a/osu.Game/Skinning/SkinnableSprite.cs
+++ b/osu.Game/Skinning/SkinnableSprite.cs
@@ -122,6 +122,7 @@ namespace osu.Game.Skinning
                        || skin.GetType() == typeof(ArgonProSkin)
                        || skin.GetType() == typeof(ArgonSkin)
                        || skin.GetType() == typeof(DefaultLegacySkin)
+                       || skin.GetType() == typeof(RetroSkin)
                        || skin.GetType() == typeof(LegacySkin);
             }
         }
diff --git a/osu.Game/Tests/Visual/EditorSavingTestScene.cs b/osu.Game/Tests/Visual/EditorSavingTestScene.cs
index d2b216caa8..8d27618c00 100644
--- a/osu.Game/Tests/Visual/EditorSavingTestScene.cs
+++ b/osu.Game/Tests/Visual/EditorSavingTestScene.cs
@@ -77,7 +77,7 @@ namespace osu.Game.Tests.Visual
             SoloSongSelect songSelect = null;
 
             PushAndConfirm(() => songSelect = new SoloSongSelect());
-            AddUntilStep("wait for carousel load", () => songSelect.CarouselItemsPresented);
+            AddUntilStep("wait for carousel load", () => songSelect.CarouselItemsPresented && !songSelect.IsFiltering);
 
             AddStep("Present same beatmap", () => Game.PresentBeatmap(Game.BeatmapManager.QueryBeatmapSet(set => set.ID == beatmapSetGuid)!.Value, beatmap => beatmap.ID == beatmapGuid));
             AddUntilStep("Wait for beatmap selected", () => Game.Beatmap.Value.BeatmapInfo.ID == beatmapGuid);
diff --git a/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestScene.cs b/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestScene.cs
index ac587d3bb2..316e90d7d3 100644
--- a/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestScene.cs
+++ b/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestScene.cs
@@ -24,12 +24,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         public bool RoomJoined => MultiplayerClient.RoomJoined;
 
-        protected Room CreateDefaultRoom()
+        protected Room CreateDefaultRoom(MatchType type = MatchType.HeadToHead)
         {
             return new Room
             {
                 Name = "test name",
-                Type = MatchType.HeadToHead,
+                Type = type,
                 Playlist =
                 [
                     new PlaylistItem(new TestBeatmap(Ruleset.Value).BeatmapInfo)
diff --git a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
index 3843460add..bd16c36eec 100644
--- a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
+++ b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
@@ -14,8 +14,11 @@ using osu.Game.Beatmaps;
 using osu.Game.Online;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Matchmaking;
+using osu.Game.Online.Matchmaking.Events;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.Countdown;
+using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets.Mods;
@@ -73,6 +76,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private long lastPlaylistItemId;
         private int lastCountdownId;
 
+        private readonly Dictionary<int, long> matchmakingUserPicks = new Dictionary<int, long>();
+
         private readonly TestRoomRequestsHandler apiRequestHandler;
 
         public TestMultiplayerClient(TestRoomRequestsHandler? apiRequestHandler = null)
@@ -245,6 +250,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 Host = localUser
             };
 
+            await changeMatchType(ServerRoom.Settings.MatchType).ConfigureAwait(false);
             await updatePlaylistOrder(ServerRoom).ConfigureAwait(false);
             await updateCurrentItem(ServerRoom, false).ConfigureAwait(false);
 
@@ -257,10 +263,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
         protected override void OnRoomJoined()
         {
             Debug.Assert(ServerRoom != null);
-
-            // emulate the server sending this after the join room. scheduler required to make sure the join room event is fired first (in Join).
-            changeMatchType(ServerRoom.Settings.MatchType).WaitSafely();
-
             RoomJoined = true;
         }
 
@@ -385,7 +387,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
             return Task.CompletedTask;
         }
 
-        public override async Task SendMatchRequest(MatchUserRequest request)
+        public override Task SendMatchRequest(MatchUserRequest request)
+            => SendUserMatchRequest(api.LocalUser.Value.OnlineID, request);
+
+        public async Task SendUserMatchRequest(int userId, MatchUserRequest request)
         {
             request = clone(request);
 
@@ -403,28 +408,57 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     if (targetTeam != null)
                     {
                         userState.TeamID = targetTeam.ID;
-                        await ((IMultiplayerClient)this).MatchUserStateChanged(clone(LocalUser.UserID), clone(userState)).ConfigureAwait(false);
+                        await ((IMultiplayerClient)this).MatchUserStateChanged(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);
+                    await StartCountdown(new MatchStartCountdown { TimeRemaining = startCountdown.Duration }).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);
+                    await StopCountdown(ServerRoom.ActiveCountdowns.First(c => c.ID == stopCountdown.ID)).ConfigureAwait(false);
+                    break;
+
+                case MatchmakingAvatarActionRequest avatarAction:
+                    await ((IMultiplayerClient)this).MatchEvent(new MatchmakingAvatarActionEvent
+                    {
+                        UserId = userId,
+                        Action = avatarAction.Action
+                    }).ConfigureAwait(false);
                     break;
             }
         }
 
+        public async Task StartCountdown(MultiplayerCountdown countdown)
+        {
+            countdown.ID = ++lastCountdownId;
+            countdown = clone(countdown);
+
+            Debug.Assert(ServerRoom != null);
+            Debug.Assert(LocalUser != null);
+
+            if (countdown.IsExclusive)
+            {
+                MultiplayerCountdown? existingCountdown = ServerRoom.ActiveCountdowns.FirstOrDefault(c => c.GetType() == countdown.GetType());
+                if (existingCountdown != null)
+                    await StopCountdown(existingCountdown).ConfigureAwait(false);
+            }
+
+            ServerRoom.ActiveCountdowns.Add(countdown);
+            await ((IMultiplayerClient)this).MatchEvent(clone(new CountdownStartedEvent(ServerRoom.ActiveCountdowns[^1]))).ConfigureAwait(false);
+        }
+
+        public async Task StopCountdown(MultiplayerCountdown countdown)
+        {
+            Debug.Assert(ServerRoom != null);
+            Debug.Assert(LocalUser != null);
+
+            ServerRoom.ActiveCountdowns.Remove(ServerRoom.ActiveCountdowns.First(c => c.ID == countdown.ID));
+            await ((IMultiplayerClient)this).MatchEvent(clone(new CountdownStoppedEvent(countdown.ID))).ConfigureAwait(false);
+        }
+
         public override Task StartMatch()
         {
             Debug.Assert(ServerRoom != null);
@@ -508,7 +542,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             if (item == null)
                 throw new InvalidOperationException("Item does not exist in the room.");
 
-            if (item == currentItem)
+            if (item.Equals(currentItem))
                 throw new InvalidOperationException("The room's current item cannot be removed.");
 
             if (item.OwnerID != userId)
@@ -568,6 +602,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
                         await ((IMultiplayerClient)this).MatchUserStateChanged(clone(user.UserID), clone(user.MatchState)).ConfigureAwait(false);
                     }
 
+                    break;
+
+                case MatchType.Matchmaking:
+                    ServerRoom.MatchState = new MatchmakingRoomState();
+                    await ((IMultiplayerClient)this).MatchRoomStateChanged(clone(ServerRoom.MatchState)).ConfigureAwait(false);
+
+                    foreach (var user in ServerRoom.Users)
+                    {
+                        user.MatchState = null;
+                        await ((IMultiplayerClient)this).MatchUserStateChanged(clone(user.UserID), clone(user.MatchState)).ConfigureAwait(false);
+                    }
+
                     break;
             }
         }
@@ -718,6 +764,97 @@ namespace osu.Game.Tests.Visual.Multiplayer
             return Task.CompletedTask;
         }
 
+        public async Task ChangeMatchRoomState(MatchRoomState state)
+        {
+            Debug.Assert(ServerRoom != null);
+
+            ServerRoom.MatchState = state;
+            await ((IMultiplayerClient)this).MatchRoomStateChanged(clone(ServerRoom.MatchState)).ConfigureAwait(false);
+        }
+
+        public override Task<MatchmakingPool[]> GetMatchmakingPools()
+        {
+            return Task.FromResult<MatchmakingPool[]>(
+            [
+                new MatchmakingPool { Id = 0, RulesetId = 0 },
+                new MatchmakingPool { Id = 1, RulesetId = 1 },
+                new MatchmakingPool { Id = 2, RulesetId = 2 },
+                new MatchmakingPool { Id = 3, RulesetId = 3, Variant = 4 },
+                new MatchmakingPool { Id = 4, RulesetId = 3, Variant = 7 },
+            ]);
+        }
+
+        public override Task MatchmakingJoinLobby()
+        {
+            return Task.CompletedTask;
+        }
+
+        public override Task MatchmakingLeaveLobby()
+        {
+            return Task.CompletedTask;
+        }
+
+        public override async Task MatchmakingJoinQueue(int poolId)
+        {
+            await ((IMatchmakingClient)this).MatchmakingQueueJoined().ConfigureAwait(false);
+            await ((IMatchmakingClient)this).MatchmakingQueueStatusChanged(new MatchmakingQueueStatus.Searching()).ConfigureAwait(false);
+        }
+
+        public override async Task MatchmakingLeaveQueue()
+        {
+            await ((IMatchmakingClient)this).MatchmakingQueueLeft().ConfigureAwait(false);
+        }
+
+        public override Task MatchmakingAcceptInvitation()
+        {
+            return Task.CompletedTask;
+        }
+
+        public override Task MatchmakingDeclineInvitation()
+        {
+            return Task.CompletedTask;
+        }
+
+        public override Task MatchmakingToggleSelection(long playlistItemId)
+            => MatchmakingToggleUserSelection(api.LocalUser.Value.OnlineID, playlistItemId);
+
+        public override Task MatchmakingSkipToNextStage()
+            => Task.CompletedTask;
+
+        public async Task MatchmakingToggleUserSelection(int userId, long playlistItemId)
+        {
+            if (matchmakingUserPicks.TryGetValue(userId, out long existingId))
+            {
+                if (existingId == playlistItemId)
+                    return;
+
+                await ((IMatchmakingClient)this).MatchmakingItemDeselected(clone(userId), clone(existingId)).ConfigureAwait(false);
+            }
+
+            matchmakingUserPicks[userId] = playlistItemId;
+
+            await ((IMatchmakingClient)this).MatchmakingItemSelected(clone(userId), clone(playlistItemId)).ConfigureAwait(false);
+        }
+
+        public async Task MatchmakingChangeStage(MatchmakingStage stage, Action<MatchmakingRoomState>? prepare = null)
+        {
+            MatchmakingRoomState state = clone((MatchmakingRoomState)ServerRoom!.MatchState!);
+
+            state.Stage = stage;
+
+            if (stage == MatchmakingStage.RoundWarmupTime)
+                state.CurrentRound++;
+
+            prepare?.Invoke(state);
+
+            await ChangeMatchRoomState(state).ConfigureAwait(false);
+            await StartCountdown(new MatchmakingStageCountdown
+            {
+                Stage = stage,
+                TimeRemaining = TimeSpan.FromSeconds(10)
+            }).ConfigureAwait(false);
+        }
+
         #region API Room Handling
 
         public IReadOnlyList<Room> ServerSideRooms
diff --git a/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs b/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs
index 914d187864..c687815270 100644
--- a/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs
+++ b/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs
@@ -95,7 +95,7 @@ namespace osu.Game.Tests.Visual.OnlinePlay
         /// </remarks>
         protected virtual OnlinePlayTestSceneDependencies CreateOnlinePlayDependencies() => new OnlinePlayTestSceneDependencies();
 
-        protected Room[] GenerateRooms(int count, RulesetInfo? ruleset = null, bool withPassword = false, bool withSpotlightRooms = false)
+        protected Room[] GenerateRooms(int count, RulesetInfo? ruleset = null, bool withPassword = false, bool withPinnedRooms = false)
         {
             Room[] rooms = new Room[count];
 
@@ -110,10 +110,10 @@ namespace osu.Game.Tests.Visual.OnlinePlay
                     Name = $@"Room {currentRoomId}",
                     Host = new APIUser { Username = @"Host" },
                     Duration = TimeSpan.FromSeconds(10),
-                    Category = withSpotlightRooms && i % 2 == 0 ? RoomCategory.Spotlight : RoomCategory.Normal,
                     Password = withPassword ? @"password" : null,
                     PlaylistItemStats = new Room.RoomPlaylistItemStats { RulesetIDs = [ruleset.OnlineID] },
-                    Playlist = [new PlaylistItem(new BeatmapInfo { Metadata = new BeatmapMetadata() }) { RulesetID = ruleset.OnlineID }]
+                    Playlist = [new PlaylistItem(new BeatmapInfo { Metadata = new BeatmapMetadata() }) { RulesetID = ruleset.OnlineID }],
+                    Pinned = withPinnedRooms && i % 2 == 0,
                 };
             }
 
diff --git a/osu.Game/Tests/Visual/ScreenTestScene.cs b/osu.Game/Tests/Visual/ScreenTestScene.cs
index f780b1a8f8..42199faa4d 100644
--- a/osu.Game/Tests/Visual/ScreenTestScene.cs
+++ b/osu.Game/Tests/Visual/ScreenTestScene.cs
@@ -7,7 +7,9 @@ using osu.Framework.Bindables;
 using osu.Framework.Development;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Logging;
+using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Graphics;
 using osu.Game.Overlays;
@@ -32,7 +34,7 @@ namespace osu.Game.Tests.Visual
         protected DialogOverlay DialogOverlay { get; private set; }
 
         [Cached]
-        private ScreenFooter footer;
+        protected ScreenFooter Footer { get; private set; }
 
         protected ScreenTestScene()
         {
@@ -43,17 +45,32 @@ namespace osu.Game.Tests.Visual
                     Name = nameof(ScreenTestScene),
                     RelativeSizeAxes = Axes.Both
                 },
-                content = new Container { RelativeSizeAxes = Axes.Both },
+                new PopoverContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        content = new Container { RelativeSizeAxes = Axes.Both },
+                        Footer = new ScreenFooter(),
+                    }
+                },
                 overlayContent = new Container
                 {
                     RelativeSizeAxes = Axes.Both,
                     Child = DialogOverlay = new DialogOverlay()
                 },
-                footer = new ScreenFooter(),
             });
 
-            Stack.ScreenPushed += (_, newScreen) => Logger.Log($"{nameof(ScreenTestScene)} screen changed → {newScreen}");
-            Stack.ScreenExited += (_, newScreen) => Logger.Log($"{nameof(ScreenTestScene)} screen changed ← {newScreen}");
+            Stack.ScreenPushed += (oldScreen, newScreen) =>
+            {
+                updateFooter(oldScreen, newScreen);
+                Logger.Log($"{nameof(ScreenTestScene)} screen changed → {newScreen}");
+            };
+            Stack.ScreenExited += (oldScreen, newScreen) =>
+            {
+                updateFooter(oldScreen, newScreen);
+                Logger.Log($"{nameof(ScreenTestScene)} screen changed ← {newScreen}");
+            };
         }
 
         protected void LoadScreen(OsuScreen screen) => Stack.Push(screen);
@@ -79,6 +96,39 @@ namespace osu.Game.Tests.Visual
             });
         }
 
+        private void updateFooter(IScreen? _, IScreen? newScreen)
+        {
+            if (newScreen is OsuScreen osuScreen && osuScreen.ShowFooter)
+            {
+                Footer.Show();
+
+                if (osuScreen.IsLoaded)
+                    updateFooterButtons();
+                else
+                {
+                    // ensure the current buttons are immediately disabled on screen change (so they can't be pressed).
+                    Footer.SetButtons(Array.Empty<ScreenFooterButton>());
+
+                    osuScreen.OnLoadComplete += _ => updateFooterButtons();
+                }
+
+                void updateFooterButtons()
+                {
+                    var buttons = osuScreen.CreateFooterButtons();
+
+                    osuScreen.LoadComponentsAgainstScreenDependencies(buttons);
+
+                    Footer.SetButtons(buttons);
+                    Footer.Show();
+                }
+            }
+            else
+            {
+                Footer.Hide();
+                Footer.SetButtons(Array.Empty<ScreenFooterButton>());
+            }
+        }
+
         #region IOverlayManager
 
         IBindable<OverlayActivation> IOverlayManager.OverlayActivationMode { get; } = new Bindable<OverlayActivation>(OverlayActivation.All);
diff --git a/osu.Game/Tests/Visual/SkinnableTestScene.cs b/osu.Game/Tests/Visual/SkinnableTestScene.cs
index c9acfa0ee5..b0bfeb0719 100644
--- a/osu.Game/Tests/Visual/SkinnableTestScene.cs
+++ b/osu.Game/Tests/Visual/SkinnableTestScene.cs
@@ -34,7 +34,7 @@ namespace osu.Game.Tests.Visual
         private Skin legacySkin;
         private Skin argonSkin;
         private Skin specialSkin;
-        private Skin oldSkin;
+        private Skin retroSkin;
 
         [Resolved]
         private GameHost host { get; set; }
@@ -54,7 +54,7 @@ namespace osu.Game.Tests.Visual
             metricsSkin = new TestLegacySkin(new SkinInfo { Name = "metrics-skin" }, new NamespacedResourceStore<byte[]>(dllStore, "Resources/metrics_skin"), this, true);
             legacySkin = new DefaultLegacySkin(this);
             specialSkin = new TestLegacySkin(new SkinInfo { Name = "special-skin" }, new NamespacedResourceStore<byte[]>(dllStore, "Resources/special_skin"), this, true);
-            oldSkin = new TestLegacySkin(new SkinInfo { Name = "old-skin" }, new NamespacedResourceStore<byte[]>(dllStore, "Resources/old_skin"), this, true);
+            retroSkin = new RetroSkin(this);
         }
 
         private readonly List<Drawable> createdDrawables = new List<Drawable>();
@@ -70,7 +70,7 @@ namespace osu.Game.Tests.Visual
             Cell(2).Child = createProvider(metricsSkin, creationFunction, beatmap);
             Cell(3).Child = createProvider(legacySkin, creationFunction, beatmap);
             Cell(4).Child = createProvider(specialSkin, creationFunction, beatmap);
-            Cell(5).Child = createProvider(oldSkin, creationFunction, beatmap);
+            Cell(5).Child = createProvider(retroSkin, creationFunction, beatmap);
         }
 
         protected IEnumerable<Drawable> CreatedDrawables => createdDrawables;
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index eac86a9c02..185b1cc4f1 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -144,8 +144,9 @@ namespace osu.Game.Utils
         /// Returns a gamefield-space quad surrounding the provided hit objects.
         /// </summary>
         /// <param name="hitObjects">The hit objects to calculate a quad for.</param>
-        public static Quad GetSurroundingQuad(IEnumerable<IHasPosition> hitObjects) =>
-            GetSurroundingQuad(enumerateStartAndEndPositions(hitObjects));
+        /// <param name="startAndEndOnly">Whether to only include the start and end positions of the slider, or include every control point in the slider.</param>
+        public static Quad GetSurroundingQuad(IEnumerable<IHasPosition> hitObjects, bool startAndEndOnly = false) =>
+            GetSurroundingQuad(startAndEndOnly ? enumerateStartAndEndPositions(hitObjects) : enumeratePositions(hitObjects));
 
         /// <summary>
         /// Returns the points that make up the convex hull of the provided points.
@@ -202,7 +203,7 @@ namespace osu.Game.Utils
         }
 
         public static List<Vector2> GetConvexHull(IEnumerable<IHasPosition> hitObjects) =>
-            GetConvexHull(enumerateStartAndEndPositions(hitObjects));
+            GetConvexHull(enumeratePositions(hitObjects));
 
         private static IEnumerable<Vector2> enumerateStartAndEndPositions(IEnumerable<IHasPosition> hitObjects) =>
             hitObjects.SelectMany(h =>
@@ -220,6 +221,17 @@ namespace osu.Game.Utils
                 return new[] { h.Position };
             });
 
+        private static IEnumerable<Vector2> enumeratePositions(IEnumerable<IHasPosition> hitObjects) =>
+            hitObjects.SelectMany(h =>
+            {
+                if (h is IHasPath path)
+                {
+                    return path.Path.ControlPoints.Select(p => h.Position + p.Position);
+                }
+
+                return new[] { h.Position };
+            });
+
         #region Welzl helpers
 
         // Function to check whether a point lies inside or on the boundaries of the circle
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index d440d886fb..6457d1cccd 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -35,8 +35,8 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="20.1.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2025.826.0" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2025.821.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2025.930.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2025.1001.0" />
     <PackageReference Include="Sentry" Version="5.1.1" />
     <!-- Held back due to 0.34.0 failing AOT compilation on ZstdSharp.dll dependency. -->
     <PackageReference Include="SharpCompress" Version="0.39.0" />
diff --git a/osu.iOS.props b/osu.iOS.props
index 7545031cf3..d945420306 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.826.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2025.930.0" />
   </ItemGroup>
 </Project>