diff --git a/CodeAnalysis/BannedSymbols.txt b/CodeAnalysis/BannedSymbols.txt
index 550f7c8e11..08b79fc2c0 100644
--- a/CodeAnalysis/BannedSymbols.txt
+++ b/CodeAnalysis/BannedSymbols.txt
@@ -18,3 +18,6 @@ M:Humanizer.InflectorExtensions.Pascalize(System.String);Humanizer's .Pascalize(
 M:Humanizer.InflectorExtensions.Camelize(System.String);Humanizer's .Camelize() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToCamelCase() instead.
 M:Humanizer.InflectorExtensions.Underscore(System.String);Humanizer's .Underscore() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToSnakeCase() instead.
 M:Humanizer.InflectorExtensions.Kebaberize(System.String);Humanizer's .Kebaberize() extension method changes behaviour depending on CultureInfo.CurrentCulture. Use StringDehumanizeExtensions.ToKebabCase() instead.
+M:osuTK.MathHelper.Clamp(System.Int32,System.Int32,System.Int32)~System.Int32;Use Math.Clamp() instead.
+M:osuTK.MathHelper.Clamp(System.Single,System.Single,System.Single)~System.Single;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
+M:osuTK.MathHelper.Clamp(System.Double,System.Double,System.Double)~System.Double;This osuTK helper has unsafe semantics when one of the bounds provided is NaN. Use Math.Clamp() instead.
diff --git a/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Beatmaps/PippidonBeatmapConverter.cs b/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Beatmaps/PippidonBeatmapConverter.cs
index 0a4fa84ce1..dd8337abee 100644
--- a/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Beatmaps/PippidonBeatmapConverter.cs
+++ b/Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Beatmaps/PippidonBeatmapConverter.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 System.Threading;
@@ -9,7 +10,6 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Pippidon.Objects;
 using osu.Game.Rulesets.Pippidon.UI;
-using osuTK;
 
 namespace osu.Game.Rulesets.Pippidon.Beatmaps
 {
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Pippidon.Beatmaps
             };
         }
 
-        private int getLane(HitObject hitObject) => (int)MathHelper.Clamp(
+        private int getLane(HitObject hitObject) => (int)Math.Clamp(
             (getUsablePosition(hitObject) - minPosition) / (maxPosition - minPosition) * PippidonPlayfield.LANE_COUNT, 0, PippidonPlayfield.LANE_COUNT - 1);
 
         private float getUsablePosition(HitObject h) => (h as IHasYPosition)?.Y ?? ((IHasXPosition)h).X;
diff --git a/osu.Android.props b/osu.Android.props
index d49acd7b27..8f219ea426 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.220.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.311.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.
diff --git a/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs b/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
index a327e6d4c9..a5713feda3 100644
--- a/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
+++ b/osu.Game.Rulesets.Catch.Tests/Editor/CatchPlacementBlueprintTestScene.cs
@@ -22,6 +22,8 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
 {
     public abstract partial class CatchPlacementBlueprintTestScene : PlacementBlueprintTestScene
     {
+        protected sealed override Ruleset CreateRuleset() => new CatchRuleset();
+
         protected const double TIME_SNAP = 100;
 
         protected DrawableCatchHitObject LastObject;
diff --git a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyAttributes.cs b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyAttributes.cs
index 5c64643fd4..82c3cfe735 100644
--- a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyAttributes.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 
@@ -10,15 +9,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 {
     public class CatchDifficultyAttributes : DifficultyAttributes
     {
-        /// <summary>
-        /// The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("approach_rate")]
-        public double ApproachRate { get; set; }
-
         public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
         {
             foreach (var v in base.ToDatabaseAttributes())
@@ -26,7 +16,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // Todo: osu!catch should not output star rating in the 'aim' attribute.
             yield return (ATTRIB_ID_AIM, StarRating);
-            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
         }
 
         public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -34,7 +23,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             base.FromDatabaseAttributes(values, onlineInfo);
 
             StarRating = values[ATTRIB_ID_AIM];
-            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
         }
     }
 }
diff --git a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
index 7d21409ee8..14a8ff31c5 100644
--- a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Difficulty.Preprocessing;
@@ -23,7 +24,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         private float halfCatcherWidth;
 
-        public override int Version => 20220701;
+        public override int Version => 20250306;
 
         public CatchDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
@@ -35,14 +36,10 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             if (beatmap.HitObjects.Count == 0)
                 return new CatchDifficultyAttributes { Mods = mods };
 
-            // this is the same as osu!, so there's potential to share the implementation... maybe
-            double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
-
             CatchDifficultyAttributes attributes = new CatchDifficultyAttributes
             {
-                StarRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier,
+                StarRating = Math.Sqrt(skills.OfType<Movement>().Single().DifficultyValue()) * difficulty_multiplier,
                 Mods = mods,
-                ApproachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0,
                 MaxCombo = beatmap.GetMaxCombo(),
             };
 
diff --git a/osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs b/osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs
index 55232a9598..62a9fe250e 100644
--- a/osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs
@@ -3,6 +3,9 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Scoring;
@@ -50,7 +53,19 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             if (catchAttributes.MaxCombo > 0)
                 value *= Math.Min(Math.Pow(score.MaxCombo, 0.8) / Math.Pow(catchAttributes.MaxCombo, 0.8), 1.0);
 
-            double approachRate = catchAttributes.ApproachRate;
+            var difficulty = score.BeatmapInfo!.Difficulty.Clone();
+
+            score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
+
+            var track = new TrackVirtual(10000);
+            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
+            double clockRate = track.Rate;
+
+            // this is the same as osu!, so there's potential to share the implementation... maybe
+            double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+
+            double approachRate = preempt > 1200.0 ? -(preempt - 1800.0) / 120.0 : -(preempt - 1200.0) / 150.0 + 5.0;
+
             double approachRateFactor = 1.0;
             if (approachRate > 9.0)
                 approachRateFactor += 0.1 * (approachRate - 9.0); // 10% for each AR above 9
diff --git a/osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs b/osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs
index 54b85f1745..559e9dafa0 100644
--- a/osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs
@@ -26,7 +26,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         private float? lastPlayerPosition;
         private float lastDistanceMoved;
+        private float lastExactDistanceMoved;
         private double lastStrainTime;
+        private bool isInBuzzSection;
 
         /// <summary>
         /// The speed multiplier applied to the player's catcher.
@@ -59,6 +61,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
             float distanceMoved = playerPosition - lastPlayerPosition.Value;
 
+            // For the exact position we consider that the catcher is in the correct position for both objects
+            float exactDistanceMoved = catchCurrent.NormalizedPosition - lastPlayerPosition.Value;
+
             double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catcherSpeedMultiplier);
 
             double distanceAddition = (Math.Pow(Math.Abs(distanceMoved), 1.3) / 510);
@@ -92,12 +97,30 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
                     playerPosition = catchCurrent.NormalizedPosition;
                 }
 
-                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20) * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
+                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash) / 20)
+                                                        * Math.Pow((Math.Min(catchCurrent.StrainTime * catcherSpeedMultiplier, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
+            }
+
+            // There is an edge case where horizontal back and forth sliders create "buzz" patterns which are repeated "movements" with a distance lower than
+            // the platter's width but high enough to be considered a movement due to the absolute_player_positioning_error and normalized_hitobject_radius offsets
+            // We are detecting this exact scenario. The first back and forth is counted but all subsequent ones are nullified.
+            // To achieve that, we need to store the exact distances (distance ignoring absolute_player_positioning_error and normalized_hitobject_radius)
+            if (Math.Abs(exactDistanceMoved) <= HalfCatcherWidth * 2 && exactDistanceMoved == -lastExactDistanceMoved && catchCurrent.StrainTime == lastStrainTime)
+            {
+                if (isInBuzzSection)
+                    distanceAddition = 0;
+                else
+                    isInBuzzSection = true;
+            }
+            else
+            {
+                isInBuzzSection = false;
             }
 
             lastPlayerPosition = playerPosition;
             lastDistanceMoved = distanceMoved;
             lastStrainTime = catchCurrent.StrainTime;
+            lastExactDistanceMoved = exactDistanceMoved;
 
             return distanceAddition / weightedStrainTime;
         }
diff --git a/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/SelectionEditablePath.cs b/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/SelectionEditablePath.cs
index 26b26641d3..654ef006a5 100644
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/SelectionEditablePath.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/Components/SelectionEditablePath.cs
@@ -143,7 +143,7 @@ namespace osu.Game.Rulesets.Catch.Edit.Blueprints.Components
         {
             base.UpdateHitObjectFromPath(hitObject);
 
-            if (hitObject.Path.ControlPoints.Count <= 1 || !hitObject.Path.HasValidLength)
+            if (hitObject.Path.ControlPoints.Count <= 1 || !hitObject.Path.HasValidLengthForPlacement)
                 EditorBeatmap?.Remove(hitObject);
         }
     }
diff --git a/osu.Game.Rulesets.Catch/Skinning/Argon/ArgonBananaPiece.cs b/osu.Game.Rulesets.Catch/Skinning/Argon/ArgonBananaPiece.cs
index 8cdb490922..810dc7eed5 100644
--- a/osu.Game.Rulesets.Catch/Skinning/Argon/ArgonBananaPiece.cs
+++ b/osu.Game.Rulesets.Catch/Skinning/Argon/ArgonBananaPiece.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 osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -110,7 +111,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Argon
 
             double duration = ObjectState.HitObject.StartTime - ObjectState.DisplayStartTime;
 
-            fadeContent.Alpha = MathHelper.Clamp(
+            fadeContent.Alpha = Math.Clamp(
                 Interpolation.ValueAt(
                     Time.Current, 1f, 0f,
                     ObjectState.DisplayStartTime + duration * lens_flare_start,
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs b/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
index 0f913a6a7d..83070c3e29 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs
@@ -22,6 +22,8 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public abstract partial class ManiaPlacementBlueprintTestScene : PlacementBlueprintTestScene
     {
+        protected sealed override Ruleset CreateRuleset() => new ManiaRuleset();
+
         private readonly Column column;
 
         [Cached(typeof(IReadOnlyList<Mod>))]
diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs
index d9ba721646..ebaa8bcea2 100644
--- a/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs
+++ b/osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs
@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             {
                 keyCount.Current.Value = 8;
             });
-            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
             AddStep("refuse", () => InputManager.Key(Key.Number2));
             AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
 
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             {
                 keyCount.Current.Value = 8;
             });
-            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().Single().CurrentDialog, Is.InstanceOf<ReloadEditorDialog>);
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().Single().CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
             AddStep("acquiesce", () => InputManager.Key(Key.Number1));
             AddUntilStep("beatmap became 8K", () => Game.Beatmap.Value.BeatmapInfo.Difficulty.CircleSize, () => Is.EqualTo(8));
         }
diff --git a/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyAttributes.cs b/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyAttributes.cs
index db60e757e1..512d98f713 100644
--- a/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyAttributes.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
-using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 
@@ -10,22 +9,12 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 {
     public class ManiaDifficultyAttributes : DifficultyAttributes
     {
-        /// <summary>
-        /// The hit window for a GREAT hit inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods do not affect the hit window at all in osu-stable.
-        /// </remarks>
-        [JsonProperty("great_hit_window")]
-        public double GreatHitWindow { get; set; }
-
         public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
         {
             foreach (var v in base.ToDatabaseAttributes())
                 yield return v;
 
             yield return (ATTRIB_ID_DIFFICULTY, StarRating);
-            yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
         }
 
         public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -33,7 +22,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             base.FromDatabaseAttributes(values, onlineInfo);
 
             StarRating = values[ATTRIB_ID_DIFFICULTY];
-            GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs b/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
index ff9aa4aa7b..06b8018f2b 100644
--- a/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs
@@ -27,7 +27,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private const double difficulty_multiplier = 0.018;
 
         private readonly bool isForCurrentRuleset;
-        private readonly double originalOverallDifficulty;
 
         public override int Version => 20241007;
 
@@ -35,7 +34,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             : base(ruleset, beatmap)
         {
             isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.MatchesOnlineID(ruleset);
-            originalOverallDifficulty = beatmap.BeatmapInfo.Difficulty.OverallDifficulty;
         }
 
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -48,11 +46,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
             ManiaDifficultyAttributes attributes = new ManiaDifficultyAttributes
             {
-                StarRating = skills[0].DifficultyValue() * difficulty_multiplier,
+                StarRating = skills.OfType<Strain>().Single().DifficultyValue() * difficulty_multiplier,
                 Mods = mods,
-                // In osu-stable mania, rate-adjustment mods don't affect the hit window.
-                // This is done the way it is to introduce fractional differences in order to match osu-stable for the time being.
-                GreatHitWindow = Math.Ceiling((int)(getHitWindow300(mods) * clockRate) / clockRate),
                 MaxCombo = beatmap.HitObjects.Sum(maxComboForObject),
             };
 
@@ -124,29 +119,5 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                 }).ToArray();
             }
         }
-
-        private double getHitWindow300(Mod[] mods)
-        {
-            if (isForCurrentRuleset)
-            {
-                double od = Math.Min(10.0, Math.Max(0, 10.0 - originalOverallDifficulty));
-                return applyModAdjustments(34 + 3 * od, mods);
-            }
-
-            if (Math.Round(originalOverallDifficulty) > 4)
-                return applyModAdjustments(34, mods);
-
-            return applyModAdjustments(47, mods);
-
-            static double applyModAdjustments(double value, Mod[] mods)
-            {
-                if (mods.Any(m => m is ManiaModHardRock))
-                    value /= 1.4;
-                else if (mods.Any(m => m is ManiaModEasy))
-                    value *= 1.4;
-
-                return value;
-            }
-        }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs b/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
index 48e59877df..a5c3c2264c 100644
--- a/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
+++ b/osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs
@@ -134,7 +134,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
 
             updatingKeyCount = true;
 
-            editor.Reload().ContinueWith(t =>
+            editor.SaveAndReload().ContinueWith(t =>
             {
                 if (!t.GetResultSafely())
                 {
diff --git a/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableBarLine.cs b/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableBarLine.cs
index 25fed1a84c..c9fc0763a8 100644
--- a/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableBarLine.cs
+++ b/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableBarLine.cs
@@ -26,9 +26,10 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             : base(barLine)
         {
             RelativeSizeAxes = Axes.X;
+            Height = 1;
         }
 
-        [BackgroundDependencyLoader]
+        [BackgroundDependencyLoader(true)]
         private void load()
         {
             AddInternal(new SkinnableDrawable(new ManiaSkinComponentLookup(ManiaSkinComponents.BarLine), _ => new DefaultBarLine())
@@ -36,8 +37,6 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             });
-
-            Major.BindValueChanged(major => Height = major.NewValue ? 1.7f : 1.2f, true);
         }
 
         protected override void OnApply()
diff --git a/osu.Game.Rulesets.Mania/Skinning/Default/DefaultBarLine.cs b/osu.Game.Rulesets.Mania/Skinning/Default/DefaultBarLine.cs
index ef75e9df11..05fba1241f 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Default/DefaultBarLine.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Default/DefaultBarLine.cs
@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Default
         [BackgroundDependencyLoader]
         private void load(DrawableHitObject drawableHitObject)
         {
-            RelativeSizeAxes = Axes.Both;
+            RelativeSizeAxes = Axes.X;
 
             // Avoid flickering due to no anti-aliasing of boxes by default.
             var edgeSmoothness = new Vector2(0.3f);
@@ -75,6 +75,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Default
 
         private void updateMajor(ValueChangedEvent<bool> major)
         {
+            Height = major.NewValue ? 1.7f : 1.2f;
+
             mainLine.Alpha = major.NewValue ? 0.5f : 0.2f;
             leftAnchor.Alpha = rightAnchor.Alpha = major.NewValue ? mainLine.Alpha * 0.3f : 0;
         }
diff --git a/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBarLine.cs b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBarLine.cs
new file mode 100644
index 0000000000..ce48c49b2e
--- /dev/null
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/LegacyBarLine.cs
@@ -0,0 +1,38 @@
+// 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.Skinning;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Mania.Skinning.Legacy
+{
+    public partial class LegacyBarLine : CompositeDrawable
+    {
+        [BackgroundDependencyLoader]
+        private void load(ISkinSource skin)
+        {
+            float skinHeight = skin.GetManiaSkinConfig<float>(LegacyManiaSkinConfigurationLookups.BarLineHeight)?.Value ?? 1;
+
+            RelativeSizeAxes = Axes.X;
+            Height = 1.2f * skinHeight;
+            Colour = skin.GetManiaSkinConfig<Color4>(LegacyManiaSkinConfigurationLookups.BarLineColour)?.Value ?? Color4.White;
+
+            // Avoid flickering due to no anti-aliasing of boxes by default.
+            var edgeSmoothness = new Vector2(0.3f);
+
+            AddInternal(new Box
+            {
+                Name = "Bar line",
+                EdgeSmoothness = edgeSmoothness,
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.BottomCentre,
+                RelativeSizeAxes = Axes.Both,
+            });
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs b/osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs
index 76af569b95..c321fcda87 100644
--- a/osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs
+++ b/osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs
@@ -163,7 +163,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                             return new LegacyStageForeground();
 
                         case ManiaSkinComponents.BarLine:
-                            return null; // Not yet implemented.
+                            return new LegacyBarLine();
 
                         default:
                             throw new UnsupportedSkinComponentException(lookup);
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs
index a105d860bf..5bce97d7b8 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs
@@ -13,6 +13,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public partial class TestSceneHitCirclePlacementBlueprint : PlacementBlueprintTestScene
     {
+        protected sealed override Ruleset CreateRuleset() => new OsuRuleset();
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableHitCircle((HitCircle)hitObject);
         protected override HitObjectPlacementBlueprint CreateBlueprint() => new HitCirclePlacementBlueprint();
     }
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
index 5831cc0a8a..8835254c48 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
@@ -23,6 +23,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public partial class TestSceneSliderPlacementBlueprint : PlacementBlueprintTestScene
     {
+        protected sealed override Ruleset CreateRuleset() => new OsuRuleset();
+
         [SetUp]
         public void Setup() => Schedule(() =>
         {
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
index d7b5cc73be..18834ef847 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs
@@ -13,6 +13,8 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public partial class TestSceneSpinnerPlacementBlueprint : PlacementBlueprintTestScene
     {
+        protected sealed override Ruleset CreateRuleset() => new OsuRuleset();
+
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSpinner((Spinner)hitObject);
 
         protected override HitObjectPlacementBlueprint CreateBlueprint() => new SpinnerPlacementBlueprint();
diff --git a/osu.Game.Rulesets.Osu.Tests/OsuDifficultyCalculatorTest.cs b/osu.Game.Rulesets.Osu.Tests/OsuDifficultyCalculatorTest.cs
index efda3fa369..defd02b830 100644
--- a/osu.Game.Rulesets.Osu.Tests/OsuDifficultyCalculatorTest.cs
+++ b/osu.Game.Rulesets.Osu.Tests/OsuDifficultyCalculatorTest.cs
@@ -15,22 +15,22 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu.Tests";
 
-        [TestCase(6.7171144000821119d, 239, "diffcalc-test")]
-        [TestCase(1.4485749025771304d, 54, "zero-length-sliders")]
-        [TestCase(0.42630400627180914d, 4, "very-fast-slider")]
+        [TestCase(6.7331304290522747d, 239, "diffcalc-test")]
+        [TestCase(1.4602604078137214d, 54, "zero-length-sliders")]
+        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
         [TestCase(0.14143808967817237d, 2, "nan-slider")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(8.9825709931204205d, 239, "diffcalc-test")]
-        [TestCase(1.7550169162648608d, 54, "zero-length-sliders")]
-        [TestCase(0.55231632896800109d, 4, "very-fast-slider")]
+        [TestCase(9.6779746353001634d, 239, "diffcalc-test")]
+        [TestCase(1.7691451263718989d, 54, "zero-length-sliders")]
+        [TestCase(0.55785578988249407d, 4, "very-fast-slider")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModDoubleTime());
 
-        [TestCase(6.7171144000821119d, 239, "diffcalc-test")]
-        [TestCase(1.4485749025771304d, 54, "zero-length-sliders")]
-        [TestCase(0.42630400627180914d, 4, "very-fast-slider")]
+        [TestCase(6.7331304290522747d, 239, "diffcalc-test")]
+        [TestCase(1.4602604078137214d, 54, "zero-length-sliders")]
+        [TestCase(0.43052813047866129d, 4, "very-fast-slider")]
         public void TestClassicMod(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new OsuModClassic());
 
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/AimEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/AimEvaluator.cs
index 9816f6d0a4..d1c92ed6a7 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/AimEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/AimEvaluator.cs
@@ -12,9 +12,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
     public static class AimEvaluator
     {
         private const double wide_angle_multiplier = 1.5;
-        private const double acute_angle_multiplier = 1.95;
+        private const double acute_angle_multiplier = 2.6;
         private const double slider_multiplier = 1.35;
         private const double velocity_change_multiplier = 0.75;
+        private const double wiggle_multiplier = 1.02;
 
         /// <summary>
         /// Evaluates the difficulty of aiming the current object, based on:
@@ -64,16 +65,16 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             double acuteAngleBonus = 0;
             double sliderBonus = 0;
             double velocityChangeBonus = 0;
+            double wiggleBonus = 0;
 
             double aimStrain = currVelocity; // Start strain with regular velocity.
 
             if (Math.Max(osuCurrObj.StrainTime, osuLastObj.StrainTime) < 1.25 * Math.Min(osuCurrObj.StrainTime, osuLastObj.StrainTime)) // If rhythms are the same.
             {
-                if (osuCurrObj.Angle != null && osuLastObj.Angle != null && osuLastLastObj.Angle != null)
+                if (osuCurrObj.Angle != null && osuLastObj.Angle != null)
                 {
                     double currAngle = osuCurrObj.Angle.Value;
                     double lastAngle = osuLastObj.Angle.Value;
-                    double lastLastAngle = osuLastLastObj.Angle.Value;
 
                     // Rewarding angles, take the smaller velocity as base.
                     double angleBonus = Math.Min(currVelocity, prevVelocity);
@@ -81,20 +82,27 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                     wideAngleBonus = calcWideAngleBonus(currAngle);
                     acuteAngleBonus = calcAcuteAngleBonus(currAngle);
 
-                    if (DifficultyCalculationUtils.MillisecondsToBPM(osuCurrObj.StrainTime, 2) < 300) // Only buff deltaTime exceeding 300 bpm 1/2.
-                        acuteAngleBonus = 0;
-                    else
-                    {
-                        acuteAngleBonus *= calcAcuteAngleBonus(lastAngle) // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
-                                           * Math.Min(angleBonus, diameter * 1.25 / osuCurrObj.StrainTime) // The maximum velocity we buff is equal to 125 / strainTime
-                                           * Math.Pow(Math.Sin(Math.PI / 2 * Math.Min(1, (100 - osuCurrObj.StrainTime) / 25)), 2) // scale buff from 150 bpm 1/4 to 200 bpm 1/4
-                                           * Math.Pow(Math.Sin(Math.PI / 2 * (Math.Clamp(osuCurrObj.LazyJumpDistance, radius, diameter) - radius) / radius), 2); // Buff distance exceeding radius up to diameter.
-                    }
+                    // Penalize angle repetition.
+                    wideAngleBonus *= 1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3));
+                    acuteAngleBonus *= 0.08 + 0.92 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastAngle), 3)));
 
-                    // Penalize wide angles if they're repeated, reducing the penalty as the lastAngle gets more acute.
-                    wideAngleBonus *= angleBonus * (1 - Math.Min(wideAngleBonus, Math.Pow(calcWideAngleBonus(lastAngle), 3)));
-                    // Penalize acute angles if they're repeated, reducing the penalty as the lastLastAngle gets more obtuse.
-                    acuteAngleBonus *= 0.5 + 0.5 * (1 - Math.Min(acuteAngleBonus, Math.Pow(calcAcuteAngleBonus(lastLastAngle), 3)));
+                    // Apply full wide angle bonus for distance more than one diameter
+                    wideAngleBonus *= angleBonus * DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, 0, diameter);
+
+                    // Apply acute angle bonus for BPM above 300 1/2 and distance more than one diameter
+                    acuteAngleBonus *= angleBonus *
+                                       DifficultyCalculationUtils.Smootherstep(DifficultyCalculationUtils.MillisecondsToBPM(osuCurrObj.StrainTime, 2), 300, 400) *
+                                       DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, diameter, diameter * 2);
+
+                    // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
+                    // https://www.desmos.com/calculator/dp0v0nvowc
+                    wiggleBonus = angleBonus
+                                  * DifficultyCalculationUtils.Smootherstep(osuCurrObj.LazyJumpDistance, radius, diameter)
+                                  * Math.Pow(DifficultyCalculationUtils.ReverseLerp(osuCurrObj.LazyJumpDistance, diameter * 3, diameter), 1.8)
+                                  * DifficultyCalculationUtils.Smootherstep(currAngle, double.DegreesToRadians(110), double.DegreesToRadians(60))
+                                  * DifficultyCalculationUtils.Smootherstep(osuLastObj.LazyJumpDistance, radius, diameter)
+                                  * Math.Pow(DifficultyCalculationUtils.ReverseLerp(osuLastObj.LazyJumpDistance, diameter * 3, diameter), 1.8)
+                                  * DifficultyCalculationUtils.Smootherstep(lastAngle, double.DegreesToRadians(110), double.DegreesToRadians(60));
                 }
             }
 
@@ -122,6 +130,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                 sliderBonus = osuLastObj.TravelDistance / osuLastObj.TravelTime;
             }
 
+            aimStrain += wiggleBonus * wiggle_multiplier;
+
             // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
             aimStrain += Math.Max(acuteAngleBonus * acute_angle_multiplier, wideAngleBonus * wide_angle_multiplier + velocityChangeBonus * velocity_change_multiplier);
 
@@ -132,8 +142,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             return aimStrain;
         }
 
-        private static double calcWideAngleBonus(double angle) => Math.Pow(Math.Sin(3.0 / 4 * (Math.Min(5.0 / 6 * Math.PI, Math.Max(Math.PI / 6, angle)) - Math.PI / 6)), 2);
+        private static double calcWideAngleBonus(double angle) => DifficultyCalculationUtils.Smoothstep(angle, double.DegreesToRadians(40), double.DegreesToRadians(140));
 
-        private static double calcAcuteAngleBonus(double angle) => 1 - calcWideAngleBonus(angle);
+        private static double calcAcuteAngleBonus(double angle) => DifficultyCalculationUtils.Smoothstep(angle, double.DegreesToRadians(140), double.DegreesToRadians(40));
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/FlashlightEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/FlashlightEvaluator.cs
index 5cb5a8f934..9d05f0b074 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/FlashlightEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/FlashlightEvaluator.cs
@@ -52,12 +52,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
                 var currentObj = (OsuDifficultyHitObject)current.Previous(i);
                 var currentHitObject = (OsuHitObject)(currentObj.BaseObject);
 
+                cumulativeStrainTime += lastObj.StrainTime;
+
                 if (!(currentObj.BaseObject is Spinner))
                 {
                     double jumpDistance = (osuHitObject.StackedPosition - currentHitObject.StackedEndPosition).Length;
 
-                    cumulativeStrainTime += lastObj.StrainTime;
-
                     // We want to nerf objects that can be easily seen within the Flashlight circle radius.
                     if (i == 0)
                         smallDistNerf = Math.Min(1.0, jumpDistance / 75.0);
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs
index a5f6468f17..769220ece0 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs
@@ -2,9 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
@@ -14,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
         private const double single_spacing_threshold = OsuDifficultyHitObject.NORMALISED_DIAMETER * 1.25; // 1.25 circles distance between centers
         private const double min_speed_bonus = 200; // 200 BPM 1/4th
         private const double speed_balancing_factor = 40;
-        private const double distance_multiplier = 0.94;
+        private const double distance_multiplier = 0.9;
 
         /// <summary>
         /// Evaluates the difficulty of tapping the current object, based on:
@@ -24,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
         /// <item><description>and how easily they can be cheesed.</description></item>
         /// </list>
         /// </summary>
-        public static double EvaluateDifficultyOf(DifficultyHitObject current)
+        public static double EvaluateDifficultyOf(DifficultyHitObject current, IReadOnlyList<Mod> mods)
         {
             if (current.BaseObject is Spinner)
                 return 0;
@@ -56,6 +60,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
             // Max distance bonus is 1 * `distance_multiplier` at single_spacing_threshold
             double distanceBonus = Math.Pow(distance / single_spacing_threshold, 3.95) * distance_multiplier;
 
+            if (mods.OfType<OsuModAutopilot>().Any())
+                distanceBonus = 0;
+
             // Base difficulty with all bonuses
             double difficulty = (1 + speedBonus + distanceBonus) * 1000 / strainTime;
 
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
index a3c0209a08..f7d8c649c1 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
@@ -8,6 +8,7 @@ using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
 {
@@ -19,6 +20,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         [JsonProperty("aim_difficulty")]
         public double AimDifficulty { get; set; }
 
+        /// <summary>
+        /// The number of <see cref="Slider"/>s weighted by difficulty.
+        /// </summary>
+        [JsonProperty("aim_difficult_slider_count")]
+        public double AimDifficultSliderCount { get; set; }
+
         /// <summary>
         /// The difficulty corresponding to the speed skill.
         /// </summary>
@@ -52,24 +59,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         [JsonProperty("speed_difficult_strain_count")]
         public double SpeedDifficultStrainCount { get; set; }
 
-        /// <summary>
-        /// The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("approach_rate")]
-        public double ApproachRate { get; set; }
-
-        /// <summary>
-        /// The perceived overall difficulty inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the overall difficulty value, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("overall_difficulty")]
-        public double OverallDifficulty { get; set; }
-
         /// <summary>
         /// The beatmap's drain rate. This doesn't scale with rate-adjusting mods.
         /// </summary>
@@ -97,8 +86,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             yield return (ATTRIB_ID_AIM, AimDifficulty);
             yield return (ATTRIB_ID_SPEED, SpeedDifficulty);
-            yield return (ATTRIB_ID_OVERALL_DIFFICULTY, OverallDifficulty);
-            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
             yield return (ATTRIB_ID_DIFFICULTY, StarRating);
 
             if (ShouldSerializeFlashlightDifficulty())
@@ -109,6 +96,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             yield return (ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT, AimDifficultStrainCount);
             yield return (ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT, SpeedDifficultStrainCount);
             yield return (ATTRIB_ID_SPEED_NOTE_COUNT, SpeedNoteCount);
+            yield return (ATTRIB_ID_AIM_DIFFICULT_SLIDER_COUNT, AimDifficultSliderCount);
         }
 
         public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values, IBeatmapOnlineInfo onlineInfo)
@@ -117,14 +105,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             AimDifficulty = values[ATTRIB_ID_AIM];
             SpeedDifficulty = values[ATTRIB_ID_SPEED];
-            OverallDifficulty = values[ATTRIB_ID_OVERALL_DIFFICULTY];
-            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
             StarRating = values[ATTRIB_ID_DIFFICULTY];
             FlashlightDifficulty = values.GetValueOrDefault(ATTRIB_ID_FLASHLIGHT);
             SliderFactor = values[ATTRIB_ID_SLIDER_FACTOR];
             AimDifficultStrainCount = values[ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT];
             SpeedDifficultStrainCount = values[ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT];
             SpeedNoteCount = values[ATTRIB_ID_SPEED_NOTE_COUNT];
+            AimDifficultSliderCount = values[ATTRIB_ID_AIM_DIFFICULT_SLIDER_COUNT];
             DrainRate = onlineInfo.DrainRate;
             HitCircleCount = onlineInfo.CircleCount;
             SliderCount = onlineInfo.SliderCount;
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index 575e03051c..eb2cb95972 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -15,8 +15,6 @@ using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Difficulty.Skills;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Scoring;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
 {
@@ -24,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
     {
         private const double difficulty_multiplier = 0.0675;
 
-        public override int Version => 20241007;
+        public override int Version => 20250306;
 
         public OsuDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
@@ -36,20 +34,22 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             if (beatmap.HitObjects.Count == 0)
                 return new OsuDifficultyAttributes { Mods = mods };
 
-            double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier;
-            double aimRatingNoSliders = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
-            double speedRating = Math.Sqrt(skills[2].DifficultyValue()) * difficulty_multiplier;
-            double speedNotes = ((Speed)skills[2]).RelevantNoteCount();
-
-            double flashlightRating = 0.0;
-
-            if (mods.Any(h => h is OsuModFlashlight))
-                flashlightRating = Math.Sqrt(skills[3].DifficultyValue()) * difficulty_multiplier;
+            var aim = skills.OfType<Aim>().Single(a => a.IncludeSliders);
+            double aimRating = Math.Sqrt(aim.DifficultyValue()) * difficulty_multiplier;
+            double aimDifficultyStrainCount = aim.CountTopWeightedStrains();
+            double difficultSliders = aim.GetDifficultSliders();
 
+            var aimWithoutSliders = skills.OfType<Aim>().Single(a => !a.IncludeSliders);
+            double aimRatingNoSliders = Math.Sqrt(aimWithoutSliders.DifficultyValue()) * difficulty_multiplier;
             double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
 
-            double aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountTopWeightedStrains();
-            double speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountTopWeightedStrains();
+            var speed = skills.OfType<Speed>().Single();
+            double speedRating = Math.Sqrt(speed.DifficultyValue()) * difficulty_multiplier;
+            double speedNotes = speed.RelevantNoteCount();
+            double speedDifficultyStrainCount = speed.CountTopWeightedStrains();
+
+            var flashlight = skills.OfType<Flashlight>().SingleOrDefault();
+            double flashlightRating = flashlight == null ? 0.0 : Math.Sqrt(flashlight.DifficultyValue()) * difficulty_multiplier;
 
             if (mods.Any(m => m is OsuModTouchDevice))
             {
@@ -63,6 +63,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 speedRating = 0.0;
                 flashlightRating *= 0.7;
             }
+            else if (mods.Any(h => h is OsuModAutopilot))
+            {
+                speedRating *= 0.5;
+                aimRating = 0.0;
+                flashlightRating *= 0.4;
+            }
 
             double baseAimPerformance = OsuStrainSkill.DifficultyToPerformance(aimRating);
             double baseSpeedPerformance = OsuStrainSkill.DifficultyToPerformance(speedRating);
@@ -82,31 +88,24 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 ? Math.Cbrt(OsuPerformanceCalculator.PERFORMANCE_BASE_MULTIPLIER) * 0.027 * (Math.Cbrt(100000 / Math.Pow(2, 1 / 1.1) * basePerformance) + 4)
                 : 0;
 
-            double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
             double drainRate = beatmap.Difficulty.DrainRate;
 
             int hitCirclesCount = beatmap.HitObjects.Count(h => h is HitCircle);
             int sliderCount = beatmap.HitObjects.Count(h => h is Slider);
             int spinnerCount = beatmap.HitObjects.Count(h => h is Spinner);
 
-            HitWindows hitWindows = new OsuHitWindows();
-            hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
-
-            double hitWindowGreat = hitWindows.WindowFor(HitResult.Great) / clockRate;
-
             OsuDifficultyAttributes attributes = new OsuDifficultyAttributes
             {
                 StarRating = starRating,
                 Mods = mods,
                 AimDifficulty = aimRating,
+                AimDifficultSliderCount = difficultSliders,
                 SpeedDifficulty = speedRating,
                 SpeedNoteCount = speedNotes,
                 FlashlightDifficulty = flashlightRating,
                 SliderFactor = sliderFactor,
                 AimDifficultStrainCount = aimDifficultyStrainCount,
                 SpeedDifficultStrainCount = speedDifficultyStrainCount,
-                ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
-                OverallDifficulty = (80 - hitWindowGreat) / 6,
                 DrainRate = drainRate,
                 MaxCombo = beatmap.GetMaxCombo(),
                 HitCircleCount = hitCirclesCount,
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceAttributes.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceAttributes.cs
index 0aeaf7669f..de4491a31b 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceAttributes.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceAttributes.cs
@@ -24,6 +24,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         [JsonProperty("effective_miss_count")]
         public double EffectiveMissCount { get; set; }
 
+        [JsonProperty("speed_deviation")]
+        public double? SpeedDeviation { get; set; }
+
         public override IEnumerable<PerformanceDisplayAttribute> GetAttributesForDisplay()
         {
             foreach (var attribute in base.GetAttributesForDisplay())
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 31b00dba2b..a667d12a44 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -4,9 +4,15 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Skills;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 
@@ -40,6 +46,15 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         /// </summary>
         private double effectiveMissCount;
 
+        private double clockRate;
+        private double greatHitWindow;
+        private double okHitWindow;
+        private double mehHitWindow;
+        private double overallDifficulty;
+        private double approachRate;
+
+        private double? speedDeviation;
+
         public OsuPerformanceCalculator()
             : base(new OsuRuleset())
         {
@@ -61,6 +76,26 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             countSliderTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
             effectiveMissCount = countMiss;
 
+            var difficulty = score.BeatmapInfo!.Difficulty.Clone();
+
+            score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
+
+            var track = new TrackVirtual(10000);
+            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
+            clockRate = track.Rate;
+
+            HitWindows hitWindows = new OsuHitWindows();
+            hitWindows.SetDifficulty(difficulty.OverallDifficulty);
+
+            greatHitWindow = hitWindows.WindowFor(HitResult.Great) / clockRate;
+            okHitWindow = hitWindows.WindowFor(HitResult.Ok) / clockRate;
+            mehHitWindow = hitWindows.WindowFor(HitResult.Meh) / clockRate;
+
+            double preempt = IBeatmapDifficultyInfo.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+
+            overallDifficulty = (80 - greatHitWindow) / 6;
+            approachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5;
+
             if (osuAttributes.SliderCount > 0)
             {
                 if (usingClassicSliderAccuracy)
@@ -103,17 +138,20 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 // https://www.desmos.com/calculator/bc9eybdthb
                 // we use OD13.3 as maximum since it's the value at which great hitwidow becomes 0
                 // this is well beyond currently maximum achievable OD which is 12.17 (DTx2 + DA with OD11)
-                double okMultiplier = Math.Max(0.0, osuAttributes.OverallDifficulty > 0.0 ? 1 - Math.Pow(osuAttributes.OverallDifficulty / 13.33, 1.8) : 1.0);
-                double mehMultiplier = Math.Max(0.0, osuAttributes.OverallDifficulty > 0.0 ? 1 - Math.Pow(osuAttributes.OverallDifficulty / 13.33, 5) : 1.0);
+                double okMultiplier = Math.Max(0.0, overallDifficulty > 0.0 ? 1 - Math.Pow(overallDifficulty / 13.33, 1.8) : 1.0);
+                double mehMultiplier = Math.Max(0.0, overallDifficulty > 0.0 ? 1 - Math.Pow(overallDifficulty / 13.33, 5) : 1.0);
 
                 // As we're adding Oks and Mehs to an approximated number of combo breaks the result can be higher than total hits in specific scenarios (which breaks some calculations) so we need to clamp it.
                 effectiveMissCount = Math.Min(effectiveMissCount + countOk * okMultiplier + countMeh * mehMultiplier, totalHits);
             }
 
+            speedDeviation = calculateSpeedDeviation(osuAttributes);
+
             double aimValue = computeAimValue(score, osuAttributes);
             double speedValue = computeSpeedValue(score, osuAttributes);
             double accuracyValue = computeAccuracyValue(score, osuAttributes);
             double flashlightValue = computeFlashlightValue(score, osuAttributes);
+
             double totalValue =
                 Math.Pow(
                     Math.Pow(aimValue, 1.1) +
@@ -129,13 +167,40 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 Accuracy = accuracyValue,
                 Flashlight = flashlightValue,
                 EffectiveMissCount = effectiveMissCount,
+                SpeedDeviation = speedDeviation,
                 Total = totalValue
             };
         }
 
         private double computeAimValue(ScoreInfo score, OsuDifficultyAttributes attributes)
         {
-            double aimValue = OsuStrainSkill.DifficultyToPerformance(attributes.AimDifficulty);
+            if (score.Mods.Any(h => h is OsuModAutopilot))
+                return 0.0;
+
+            double aimDifficulty = attributes.AimDifficulty;
+
+            if (attributes.SliderCount > 0 && attributes.AimDifficultSliderCount > 0)
+            {
+                double estimateImproperlyFollowedDifficultSliders;
+
+                if (usingClassicSliderAccuracy)
+                {
+                    // When the score is considered classic (regardless if it was made on old client or not) we consider all missing combo to be dropped difficult sliders
+                    int maximumPossibleDroppedSliders = totalImperfectHits;
+                    estimateImproperlyFollowedDifficultSliders = Math.Clamp(Math.Min(maximumPossibleDroppedSliders, attributes.MaxCombo - scoreMaxCombo), 0, attributes.AimDifficultSliderCount);
+                }
+                else
+                {
+                    // We add tick misses here since they too mean that the player didn't follow the slider properly
+                    // We however aren't adding misses here because missing slider heads has a harsh penalty by itself and doesn't mean that the rest of the slider wasn't followed properly
+                    estimateImproperlyFollowedDifficultSliders = Math.Clamp(countSliderEndsDropped + countSliderTickMiss, 0, attributes.AimDifficultSliderCount);
+                }
+
+                double sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateImproperlyFollowedDifficultSliders / attributes.AimDifficultSliderCount, 3) + attributes.SliderFactor;
+                aimDifficulty *= sliderNerfFactor;
+            }
+
+            double aimValue = OsuStrainSkill.DifficultyToPerformance(aimDifficulty);
 
             double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
                                  (totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
@@ -145,10 +210,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 aimValue *= calculateMissPenalty(effectiveMissCount, attributes.AimDifficultStrainCount);
 
             double approachRateFactor = 0.0;
-            if (attributes.ApproachRate > 10.33)
-                approachRateFactor = 0.3 * (attributes.ApproachRate - 10.33);
-            else if (attributes.ApproachRate < 8.0)
-                approachRateFactor = 0.05 * (8.0 - attributes.ApproachRate);
+            if (approachRate > 10.33)
+                approachRateFactor = 0.3 * (approachRate - 10.33);
+            else if (approachRate < 8.0)
+                approachRateFactor = 0.05 * (8.0 - approachRate);
 
             if (score.Mods.Any(h => h is OsuModRelax))
                 approachRateFactor = 0.0;
@@ -160,43 +225,19 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             else if (score.Mods.Any(m => m is OsuModHidden || m is OsuModTraceable))
             {
                 // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-                aimValue *= 1.0 + 0.04 * (12.0 - attributes.ApproachRate);
-            }
-
-            // We assume 15% of sliders in a map are difficult since there's no way to tell from the performance calculator.
-            double estimateDifficultSliders = attributes.SliderCount * 0.15;
-
-            if (attributes.SliderCount > 0)
-            {
-                double estimateImproperlyFollowedDifficultSliders;
-
-                if (usingClassicSliderAccuracy)
-                {
-                    // When the score is considered classic (regardless if it was made on old client or not) we consider all missing combo to be dropped difficult sliders
-                    int maximumPossibleDroppedSliders = totalImperfectHits;
-                    estimateImproperlyFollowedDifficultSliders = Math.Clamp(Math.Min(maximumPossibleDroppedSliders, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
-                }
-                else
-                {
-                    // We add tick misses here since they too mean that the player didn't follow the slider properly
-                    // We however aren't adding misses here because missing slider heads has a harsh penalty by itself and doesn't mean that the rest of the slider wasn't followed properly
-                    estimateImproperlyFollowedDifficultSliders = Math.Clamp(countSliderEndsDropped + countSliderTickMiss, 0, estimateDifficultSliders);
-                }
-
-                double sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateImproperlyFollowedDifficultSliders / estimateDifficultSliders, 3) + attributes.SliderFactor;
-                aimValue *= sliderNerfFactor;
+                aimValue *= 1.0 + 0.04 * (12.0 - approachRate);
             }
 
             aimValue *= accuracy;
             // It is important to consider accuracy difficulty when scaling with accuracy.
-            aimValue *= 0.98 + Math.Pow(attributes.OverallDifficulty, 2) / 2500;
+            aimValue *= 0.98 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 2500;
 
             return aimValue;
         }
 
         private double computeSpeedValue(ScoreInfo score, OsuDifficultyAttributes attributes)
         {
-            if (score.Mods.Any(h => h is OsuModRelax))
+            if (score.Mods.Any(h => h is OsuModRelax) || speedDeviation == null)
                 return 0.0;
 
             double speedValue = OsuStrainSkill.DifficultyToPerformance(attributes.SpeedDifficulty);
@@ -209,8 +250,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 speedValue *= calculateMissPenalty(effectiveMissCount, attributes.SpeedDifficultStrainCount);
 
             double approachRateFactor = 0.0;
-            if (attributes.ApproachRate > 10.33)
-                approachRateFactor = 0.3 * (attributes.ApproachRate - 10.33);
+            if (approachRate > 10.33)
+                approachRateFactor = 0.3 * (approachRate - 10.33);
+
+            if (score.Mods.Any(h => h is OsuModAutopilot))
+                approachRateFactor = 0.0;
 
             speedValue *= 1.0 + approachRateFactor * lengthBonus; // Buff for longer maps with high AR.
 
@@ -222,21 +266,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             else if (score.Mods.Any(m => m is OsuModHidden || m is OsuModTraceable))
             {
                 // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-                speedValue *= 1.0 + 0.04 * (12.0 - attributes.ApproachRate);
+                speedValue *= 1.0 + 0.04 * (12.0 - approachRate);
             }
 
+            double speedHighDeviationMultiplier = calculateSpeedHighDeviationNerf(attributes);
+            speedValue *= speedHighDeviationMultiplier;
+
             // Calculate accuracy assuming the worst case scenario
-            double relevantTotalDiff = totalHits - attributes.SpeedNoteCount;
+            double relevantTotalDiff = Math.Max(0, totalHits - attributes.SpeedNoteCount);
             double relevantCountGreat = Math.Max(0, countGreat - relevantTotalDiff);
             double relevantCountOk = Math.Max(0, countOk - Math.Max(0, relevantTotalDiff - countGreat));
             double relevantCountMeh = Math.Max(0, countMeh - Math.Max(0, relevantTotalDiff - countGreat - countOk));
             double relevantAccuracy = attributes.SpeedNoteCount == 0 ? 0 : (relevantCountGreat * 6.0 + relevantCountOk * 2.0 + relevantCountMeh) / (attributes.SpeedNoteCount * 6.0);
 
             // Scale the speed value with accuracy and OD.
-            speedValue *= (0.95 + Math.Pow(attributes.OverallDifficulty, 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - attributes.OverallDifficulty) / 2);
-
-            // Scale the speed value with # of 50s to punish doubletapping.
-            speedValue *= Math.Pow(0.99, countMeh < totalHits / 500.0 ? 0 : countMeh - totalHits / 500.0);
+            speedValue *= (0.95 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - overallDifficulty) / 2);
 
             return speedValue;
         }
@@ -253,7 +297,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 amountHitObjectsWithAccuracy += attributes.SliderCount;
 
             if (amountHitObjectsWithAccuracy > 0)
-                betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countOk * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
+                betterAccuracyPercentage = ((countGreat - Math.Max(totalHits - amountHitObjectsWithAccuracy, 0)) * 6 + countOk * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
             else
                 betterAccuracyPercentage = 0;
 
@@ -263,7 +307,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             // Lots of arbitrary values from testing.
             // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution.
-            double accuracyValue = Math.Pow(1.52163, attributes.OverallDifficulty) * Math.Pow(betterAccuracyPercentage, 24) * 2.83;
+            double accuracyValue = Math.Pow(1.52163, overallDifficulty) * Math.Pow(betterAccuracyPercentage, 24) * 2.83;
 
             // Bonus for many hitcircles - it's harder to keep good accuracy up for longer.
             accuracyValue *= Math.Min(1.15, Math.Pow(amountHitObjectsWithAccuracy / 1000.0, 0.3));
@@ -300,17 +344,117 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             // Scale the flashlight value with accuracy _slightly_.
             flashlightValue *= 0.5 + accuracy / 2.0;
             // It is important to also consider accuracy difficulty when doing that.
-            flashlightValue *= 0.98 + Math.Pow(attributes.OverallDifficulty, 2) / 2500;
+            flashlightValue *= 0.98 + Math.Pow(Math.Max(0, overallDifficulty), 2) / 2500;
 
             return flashlightValue;
         }
 
+        /// <summary>
+        /// Estimates player's deviation on speed notes using <see cref="calculateDeviation"/>, assuming worst-case.
+        /// Treats all speed notes as hit circles.
+        /// </summary>
+        private double? calculateSpeedDeviation(OsuDifficultyAttributes attributes)
+        {
+            if (totalSuccessfulHits == 0)
+                return null;
+
+            // Calculate accuracy assuming the worst case scenario
+            double speedNoteCount = attributes.SpeedNoteCount;
+            speedNoteCount += (totalHits - attributes.SpeedNoteCount) * 0.1;
+
+            // Assume worst case: all mistakes were on speed notes
+            double relevantCountMiss = Math.Min(countMiss, speedNoteCount);
+            double relevantCountMeh = Math.Min(countMeh, speedNoteCount - relevantCountMiss);
+            double relevantCountOk = Math.Min(countOk, speedNoteCount - relevantCountMiss - relevantCountMeh);
+            double relevantCountGreat = Math.Max(0, speedNoteCount - relevantCountMiss - relevantCountMeh - relevantCountOk);
+
+            return calculateDeviation(attributes, relevantCountGreat, relevantCountOk, relevantCountMeh, relevantCountMiss);
+        }
+
+        /// <summary>
+        /// Estimates the player's tap deviation based on the OD, given number of greats, oks, mehs and misses,
+        /// assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the same map with the same settings
+        /// will always return the same deviation. Misses are ignored because they are usually due to misaiming.
+        /// Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
+        /// </summary>
+        private double? calculateDeviation(OsuDifficultyAttributes attributes, double relevantCountGreat, double relevantCountOk, double relevantCountMeh, double relevantCountMiss)
+        {
+            if (relevantCountGreat + relevantCountOk + relevantCountMeh <= 0)
+                return null;
+
+            double objectCount = relevantCountGreat + relevantCountOk + relevantCountMeh + relevantCountMiss;
+
+            // The probability that a player hits a circle is unknown, but we can estimate it to be
+            // the number of greats on circles divided by the number of circles, and then add one
+            // to the number of circles as a bias correction.
+            double n = Math.Max(1, objectCount - relevantCountMiss - relevantCountMeh);
+            const double z = 2.32634787404; // 99% critical value for the normal distribution (one-tailed).
+
+            // Proportion of greats hit on circles, ignoring misses and 50s.
+            double p = relevantCountGreat / n;
+
+            // We can be 99% confident that p is at least this value.
+            double pLowerBound = (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4);
+
+            // Compute the deviation assuming greats and oks are normally distributed, and mehs are uniformly distributed.
+            // Begin with greats and oks first. Ignoring mehs, we can be 99% confident that the deviation is not higher than:
+            double deviation = greatHitWindow / (Math.Sqrt(2) * DifficultyCalculationUtils.ErfInv(pLowerBound));
+
+            double randomValue = Math.Sqrt(2 / Math.PI) * okHitWindow * Math.Exp(-0.5 * Math.Pow(okHitWindow / deviation, 2))
+                                 / (deviation * DifficultyCalculationUtils.Erf(okHitWindow / (Math.Sqrt(2) * deviation)));
+
+            deviation *= Math.Sqrt(1 - randomValue);
+
+            // Value deviation approach as greatCount approaches 0
+            double limitValue = okHitWindow / Math.Sqrt(3);
+
+            // If precision is not enough to compute true deviation - use limit value
+            if (pLowerBound == 0 || randomValue >= 1 || deviation > limitValue)
+                deviation = limitValue;
+
+            // Then compute the variance for mehs.
+            double mehVariance = (mehHitWindow * mehHitWindow + okHitWindow * mehHitWindow + okHitWindow * okHitWindow) / 3;
+
+            // Find the total deviation.
+            deviation = Math.Sqrt(((relevantCountGreat + relevantCountOk) * Math.Pow(deviation, 2) + relevantCountMeh * mehVariance) / (relevantCountGreat + relevantCountOk + relevantCountMeh));
+
+            return deviation;
+        }
+
+        // Calculates multiplier for speed to account for improper tapping based on the deviation and speed difficulty
+        // https://www.desmos.com/calculator/dmogdhzofn
+        private double calculateSpeedHighDeviationNerf(OsuDifficultyAttributes attributes)
+        {
+            if (speedDeviation == null)
+                return 0;
+
+            double speedValue = OsuStrainSkill.DifficultyToPerformance(attributes.SpeedDifficulty);
+
+            // Decides a point where the PP value achieved compared to the speed deviation is assumed to be tapped improperly. Any PP above this point is considered "excess" speed difficulty.
+            // This is used to cause PP above the cutoff to scale logarithmically towards the original speed value thus nerfing the value.
+            double excessSpeedDifficultyCutoff = 100 + 220 * Math.Pow(22 / speedDeviation.Value, 6.5);
+
+            if (speedValue <= excessSpeedDifficultyCutoff)
+                return 1.0;
+
+            const double scale = 50;
+            double adjustedSpeedValue = scale * (Math.Log((speedValue - excessSpeedDifficultyCutoff) / scale + 1) + excessSpeedDifficultyCutoff / scale);
+
+            // 220 UR and less are considered tapped correctly to ensure that normal scores will be punished as little as possible
+            double lerp = 1 - DifficultyCalculationUtils.ReverseLerp(speedDeviation.Value, 22.0, 27.0);
+            adjustedSpeedValue = double.Lerp(adjustedSpeedValue, speedValue, lerp);
+
+            return adjustedSpeedValue / speedValue;
+        }
+
         // Miss penalty assumes that a player will miss on the hardest parts of a map,
         // so we use the amount of relatively difficult sections to adjust miss penalty
         // to make it more punishing on maps with lower amount of hard sections.
         private double calculateMissPenalty(double missCount, double difficultStrainCount) => 0.96 / ((missCount / (4 * Math.Pow(Math.Log(difficultStrainCount), 0.94))) + 1);
         private double getComboScalingFactor(OsuDifficultyAttributes attributes) => attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(attributes.MaxCombo, 0.8), 1.0);
+
         private int totalHits => countGreat + countOk + countMeh + countMiss;
+        private int totalSuccessfulHits => countGreat + countOk + countMeh;
         private int totalImperfectHits => countOk + countMeh + countMiss;
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
index faf91e4652..6f1b680211 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
@@ -2,9 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Evaluators;
+using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 {
@@ -13,19 +16,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// </summary>
     public class Aim : OsuStrainSkill
     {
-        public Aim(Mod[] mods, bool withSliders)
+        public readonly bool IncludeSliders;
+
+        public Aim(Mod[] mods, bool includeSliders)
             : base(mods)
         {
-            this.withSliders = withSliders;
+            IncludeSliders = includeSliders;
         }
 
-        private readonly bool withSliders;
-
         private double currentStrain;
 
-        private double skillMultiplier => 25.18;
+        private double skillMultiplier => 25.6;
         private double strainDecayBase => 0.15;
 
+        private readonly List<double> sliderStrains = new List<double>();
+
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
 
         protected override double CalculateInitialStrain(double time, DifficultyHitObject current) => currentStrain * strainDecay(time - current.Previous(0).StartTime);
@@ -33,9 +38,26 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
         protected override double StrainValueAt(DifficultyHitObject current)
         {
             currentStrain *= strainDecay(current.DeltaTime);
-            currentStrain += AimEvaluator.EvaluateDifficultyOf(current, withSliders) * skillMultiplier;
+            currentStrain += AimEvaluator.EvaluateDifficultyOf(current, IncludeSliders) * skillMultiplier;
+
+            if (current.BaseObject is Slider)
+            {
+                sliderStrains.Add(currentStrain);
+            }
 
             return currentStrain;
         }
+
+        public double GetDifficultSliders()
+        {
+            if (sliderStrains.Count == 0)
+                return 0;
+
+            double maxSliderStrain = sliderStrains.Max();
+            if (maxSliderStrain == 0)
+                return 0;
+
+            return sliderStrains.Sum(strain => 1.0 / (1.0 + Math.Exp(-(strain / maxSliderStrain * 12.0 - 6.0))));
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
index d2c4bbb618..bdeea0e918 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// </summary>
     public class Speed : OsuStrainSkill
     {
-        private double skillMultiplier => 1.430;
+        private double skillMultiplier => 1.46;
         private double strainDecayBase => 0.3;
 
         private double currentStrain;
@@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
         protected override double StrainValueAt(DifficultyHitObject current)
         {
             currentStrain *= strainDecay(((OsuDifficultyHitObject)current).StrainTime);
-            currentStrain += SpeedEvaluator.EvaluateDifficultyOf(current) * skillMultiplier;
+            currentStrain += SpeedEvaluator.EvaluateDifficultyOf(current, Mods) * skillMultiplier;
 
             currentRhythm = RhythmEvaluator.EvaluateDifficultyOf(current);
 
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCircleOverlapMarker.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCircleOverlapMarker.cs
index 8ed9d0476a..7a5b01ce79 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCircleOverlapMarker.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCircleOverlapMarker.cs
@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -76,7 +77,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
             if (hasReachedObject && showHitMarkers.Value)
             {
                 float alpha = Interpolation.ValueAt(editorTime, 0, 1f, hitObjectTime, hitObjectTime + FADE_OUT_EXTENSION, Easing.In);
-                float ringScale = MathHelper.Clamp(Interpolation.ValueAt(editorTime, 0, 1f, hitObjectTime, hitObjectTime + FADE_OUT_EXTENSION / 2, Easing.OutQuint), 0, 1);
+                float ringScale = Math.Clamp(Interpolation.ValueAt(editorTime, 0, 1f, hitObjectTime, hitObjectTime + FADE_OUT_EXTENSION / 2, Easing.OutQuint), 0, 1);
 
                 ring.Scale = new Vector2(1 + 0.1f * ringScale);
                 content.Alpha = 0.9f * (1 - alpha);
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 bc3d27fd68..5ae9b194be 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
@@ -484,7 +484,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             // Snap the path to the current beat divisor before checking length validity.
             hitObject.SnapTo(distanceSnapProvider);
 
-            if (!hitObject.Path.HasValidLength)
+            if (!hitObject.Path.HasValidLengthForPlacement)
             {
                 for (int i = 0; i < hitObject.Path.ControlPoints.Count; i++)
                     hitObject.Path.ControlPoints[i].Position = oldControlPoints[i];
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
index a747d4fce8..d934eb5a9e 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs
@@ -58,7 +58,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         private readonly IncrementalBSplineBuilder bSplineBuilder = new IncrementalBSplineBuilder { Degree = 4 };
 
-        protected override bool IsValidForPlacement => HitObject.Path.HasValidLength;
+        protected override bool IsValidForPlacement => HitObject.Path.HasValidLengthForPlacement;
 
         public SliderPlacementBlueprint()
             : base(new Slider())
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
index 39c0681dba..d6150f85db 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
@@ -270,14 +270,14 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             if (adjustVelocity)
             {
                 proposedVelocity = proposedDistance / oldDuration;
-                proposedDistance = MathHelper.Clamp(proposedDistance, 0.1 * oldDuration, 10 * oldDuration);
+                proposedDistance = Math.Clamp(proposedDistance, 0.1 * oldDuration, 10 * oldDuration);
             }
             else
             {
                 double minDistance = distanceSnapProvider?.GetBeatSnapDistance() * oldVelocityMultiplier ?? 1;
                 // Add a small amount to the proposed distance to make it easier to snap to the full length of the slider.
                 proposedDistance = distanceSnapProvider?.FindSnappedDistance((float)proposedDistance + 1, HitObject.StartTime, HitObject) ?? proposedDistance;
-                proposedDistance = MathHelper.Clamp(proposedDistance, minDistance, HitObject.Path.CalculatedDistance);
+                proposedDistance = Math.Clamp(proposedDistance, minDistance, HitObject.Path.CalculatedDistance);
             }
 
             if (Precision.AlmostEquals(proposedDistance, HitObject.Path.Distance) && Precision.AlmostEquals(proposedVelocity, HitObject.SliderVelocityMultiplier))
@@ -476,7 +476,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             HitObject.SnapTo(distanceSnapProvider);
 
             // If there are 0 or 1 remaining control points, or the slider has an invalid length, it is in a degenerate form and should be deleted
-            if (controlPoints.Count <= 1 || !HitObject.Path.HasValidLength)
+            if (controlPoints.Count <= 1 || !HitObject.Path.HasValidLengthForPlacement)
             {
                 placementHandler?.Delete(HitObject);
                 return;
@@ -626,7 +626,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
         {
-            if (BodyPiece.ReceivePositionalInputAt(screenSpacePos) && (IsSelected || DrawableObject.Body.Alpha > 0))
+            if (BodyPiece.ReceivePositionalInputAt(screenSpacePos) && (IsSelected || DrawableObject.Body.Alpha > 0 || DrawableObject.HeadCircle.Alpha > 0))
                 return true;
 
             if (ControlPointVisualiser == null)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapProvider.cs b/osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapProvider.cs
index 3c0889d027..45ce3206d2 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapProvider.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapProvider.cs
@@ -1,10 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Linq;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
 
@@ -14,7 +16,9 @@ namespace osu.Game.Rulesets.Osu.Edit
     {
         public override double ReadCurrentDistanceSnap(HitObject before, HitObject after)
         {
-            float expectedDistance = DurationToDistance(after.StartTime - before.GetEndTime(), before.StartTime);
+            var lastObjectWithVelocity = EditorBeatmap.HitObjects.TakeWhile(ho => ho != after).OfType<IHasSliderVelocity>().LastOrDefault();
+
+            float expectedDistance = DurationToDistance(after.StartTime - before.GetEndTime(), before.StartTime, lastObjectWithVelocity);
             float actualDistance = Vector2.Distance(((OsuHitObject)before).EndPosition, ((OsuHitObject)after).Position);
 
             return actualDistance / expectedDistance;
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
index 6220fa66b1..991d42c7b4 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         public BindableFloat Spacing { get; } = new BindableFloat(4f)
         {
             MinValue = 4f,
-            MaxValue = 128f,
+            MaxValue = 256f,
             Precision = 0.01f,
         };
 
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index e3ab95c402..9a5d3c3bc1 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -180,7 +180,7 @@ namespace osu.Game.Rulesets.Osu.Edit
             Quad scaledQuad = GeometryUtils.GetSurroundingQuad(new OsuHitObject[] { slider });
             (bool xInBounds, bool yInBounds) = isQuadInBounds(scaledQuad);
 
-            if (xInBounds && yInBounds && slider.Path.HasValidLength)
+            if (xInBounds && yInBounds && slider.Path.HasValidLengthForPlacement)
                 return;
 
             for (int i = 0; i < slider.Path.ControlPoints.Count; i++)
@@ -263,12 +263,12 @@ namespace osu.Game.Rulesets.Osu.Edit
                 {
                     case Axes.X:
                         (sLowerBound, sUpperBound) = computeBounds(lowerBounds - b, upperBounds - b, a);
-                        s.X = MathHelper.Clamp(s.X, sLowerBound, sUpperBound);
+                        s.X = Math.Clamp(s.X, sLowerBound, sUpperBound);
                         break;
 
                     case Axes.Y:
                         (sLowerBound, sUpperBound) = computeBounds(lowerBounds - a, upperBounds - a, b);
-                        s.Y = MathHelper.Clamp(s.Y, sLowerBound, sUpperBound);
+                        s.Y = Math.Clamp(s.Y, sLowerBound, sUpperBound);
                         break;
 
                     case Axes.Both:
@@ -276,11 +276,11 @@ namespace osu.Game.Rulesets.Osu.Edit
                         // Therefore the ratio s.X / s.Y will be maintained
                         (sLowerBound, sUpperBound) = computeBounds(lowerBounds, upperBounds, a * s.X + b * s.Y);
                         s.X = s.X < 0
-                            ? MathHelper.Clamp(s.X, s.X * sUpperBound, s.X * sLowerBound)
-                            : MathHelper.Clamp(s.X, s.X * sLowerBound, s.X * sUpperBound);
+                            ? Math.Clamp(s.X, s.X * sUpperBound, s.X * sLowerBound)
+                            : Math.Clamp(s.X, s.X * sLowerBound, s.X * sUpperBound);
                         s.Y = s.Y < 0
-                            ? MathHelper.Clamp(s.Y, s.Y * sUpperBound, s.Y * sLowerBound)
-                            : MathHelper.Clamp(s.Y, s.Y * sLowerBound, s.Y * sUpperBound);
+                            ? Math.Clamp(s.Y, s.Y * sUpperBound, s.Y * sLowerBound)
+                            : Math.Clamp(s.Y, s.Y * sLowerBound, s.Y * sUpperBound);
                         break;
                 }
 
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs
index f2cb8794b5..04d6afc925 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.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.Diagnostics;
 using System.Linq;
@@ -127,8 +128,11 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             if (relativeCheckbox.Current.Value)
             {
-                (xBindable.MinValue, xBindable.MaxValue) = (0 - initialSurroundingQuad.TopLeft.X, OsuPlayfield.BASE_SIZE.X - initialSurroundingQuad.BottomRight.X);
-                (yBindable.MinValue, yBindable.MaxValue) = (0 - initialSurroundingQuad.TopLeft.Y, OsuPlayfield.BASE_SIZE.Y - initialSurroundingQuad.BottomRight.Y);
+                xBindable.MinValue = 0 - Math.Max(initialSurroundingQuad.TopLeft.X, 0);
+                xBindable.MaxValue = OsuPlayfield.BASE_SIZE.X - Math.Min(initialSurroundingQuad.BottomRight.X, OsuPlayfield.BASE_SIZE.X);
+
+                yBindable.MinValue = 0 - Math.Max(initialSurroundingQuad.TopLeft.Y, 0);
+                yBindable.MaxValue = OsuPlayfield.BASE_SIZE.Y - Math.Min(initialSurroundingQuad.BottomRight.Y, OsuPlayfield.BASE_SIZE.Y);
 
                 xBindable.Default = yBindable.Default = 0;
 
@@ -146,8 +150,21 @@ namespace osu.Game.Rulesets.Osu.Edit
 
                 var quadRelativeToPosition = new RectangleF(initialSurroundingQuad.Location - initialPosition, initialSurroundingQuad.Size);
 
-                (xBindable.MinValue, xBindable.MaxValue) = (0 - quadRelativeToPosition.TopLeft.X, OsuPlayfield.BASE_SIZE.X - quadRelativeToPosition.BottomRight.X);
-                (yBindable.MinValue, yBindable.MaxValue) = (0 - quadRelativeToPosition.TopLeft.Y, OsuPlayfield.BASE_SIZE.Y - quadRelativeToPosition.BottomRight.Y);
+                if (initialSurroundingQuad.Width < OsuPlayfield.BASE_SIZE.X)
+                {
+                    xBindable.MinValue = 0 - quadRelativeToPosition.TopLeft.X;
+                    xBindable.MaxValue = OsuPlayfield.BASE_SIZE.X - quadRelativeToPosition.BottomRight.X;
+                }
+                else
+                    xBindable.MinValue = xBindable.MaxValue = initialPosition.X;
+
+                if (initialSurroundingQuad.Height < OsuPlayfield.BASE_SIZE.Y)
+                {
+                    yBindable.MinValue = 0 - quadRelativeToPosition.TopLeft.Y;
+                    yBindable.MaxValue = OsuPlayfield.BASE_SIZE.Y - quadRelativeToPosition.BottomRight.Y;
+                }
+                else
+                    yBindable.MinValue = yBindable.MaxValue = initialPosition.Y;
 
                 xBindable.Default = initialPosition.X;
                 yBindable.Default = initialPosition.Y;
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs b/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs
index f35b1abc42..10282ff988 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs
@@ -3,7 +3,6 @@
 
 using System.Linq;
 using osu.Framework.Bindables;
-using osu.Framework.Graphics;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -63,13 +62,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         private partial class ApproachRateSettingsControl : DifficultyAdjustSettingsControl
         {
-            protected override RoundedSliderBar<float> CreateSlider(BindableNumber<float> current) =>
-                new ApproachRateSlider
-                {
-                    RelativeSizeAxes = Axes.X,
-                    Current = current,
-                    KeyboardStep = 0.1f,
-                };
+            protected override RoundedSliderBar<float> CreateSlider(BindableNumber<float> current) => new ApproachRateSlider();
 
             /// <summary>
             /// A slider bar with more detailed approach rate info for its given value
diff --git a/osu.Game.Rulesets.Taiko.Tests/TaikoDifficultyCalculatorTest.cs b/osu.Game.Rulesets.Taiko.Tests/TaikoDifficultyCalculatorTest.cs
index 09d6540f72..76b86eb4d6 100644
--- a/osu.Game.Rulesets.Taiko.Tests/TaikoDifficultyCalculatorTest.cs
+++ b/osu.Game.Rulesets.Taiko.Tests/TaikoDifficultyCalculatorTest.cs
@@ -14,13 +14,13 @@ namespace osu.Game.Rulesets.Taiko.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Taiko";
 
-        [TestCase(3.0920212594351191d, 200, "diffcalc-test")]
-        [TestCase(3.0920212594351191d, 200, "diffcalc-test-strong")]
+        [TestCase(3.305554470092722d, 200, "diffcalc-test")]
+        [TestCase(3.305554470092722d, 200, "diffcalc-test-strong")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(4.0789820318081444d, 200, "diffcalc-test")]
-        [TestCase(4.0789820318081444d, 200, "diffcalc-test-strong")]
+        [TestCase(4.4472572672057815d, 200, "diffcalc-test")]
+        [TestCase(4.4472572672057815d, 200, "diffcalc-test-strong")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new TaikoModDoubleTime());
 
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ColourEvaluator.cs b/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ColourEvaluator.cs
index 25428c8b2f..b715dfc37a 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ColourEvaluator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ColourEvaluator.cs
@@ -10,45 +10,82 @@ using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour.Data;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
 {
-    public class ColourEvaluator
+    public static class ColourEvaluator
     {
         /// <summary>
-        /// Evaluate the difficulty of the first note of a <see cref="MonoStreak"/>.
+        /// Calculates a consistency penalty based on the number of consecutive consistent intervals,
+        /// considering the delta time between each colour sequence.
         /// </summary>
-        public static double EvaluateDifficultyOf(MonoStreak monoStreak)
+        /// <param name="hitObject">The current hitObject to consider.</param>
+        /// <param name="threshold"> The allowable margin of error for determining whether ratios are consistent.</param>
+        /// <param name="maxObjectsToCheck">The maximum objects to check per count of consistent ratio.</param>
+        private static double consistentRatioPenalty(TaikoDifficultyHitObject hitObject, double threshold = 0.01, int maxObjectsToCheck = 64)
         {
-            return DifficultyCalculationUtils.Logistic(exponent: Math.E * monoStreak.Index - 2 * Math.E) * EvaluateDifficultyOf(monoStreak.Parent) * 0.5;
+            int consistentRatioCount = 0;
+            double totalRatioCount = 0.0;
+
+            TaikoDifficultyHitObject current = hitObject;
+
+            for (int i = 0; i < maxObjectsToCheck; i++)
+            {
+                // Break if there is no valid previous object
+                if (current.Index <= 1)
+                    break;
+
+                var previousHitObject = (TaikoDifficultyHitObject)current.Previous(1);
+
+                double currentRatio = current.RhythmData.Ratio;
+                double previousRatio = previousHitObject.RhythmData.Ratio;
+
+                // A consistent interval is defined as the percentage difference between the two rhythmic ratios with the margin of error.
+                if (Math.Abs(1 - currentRatio / previousRatio) <= threshold)
+                {
+                    consistentRatioCount++;
+                    totalRatioCount += currentRatio;
+                    break;
+                }
+
+                // Move to the previous object
+                current = previousHitObject;
+            }
+
+            // Ensure no division by zero
+            double ratioPenalty = 1 - totalRatioCount / (consistentRatioCount + 1) * 0.80;
+
+            return ratioPenalty;
         }
 
         /// <summary>
-        /// Evaluate the difficulty of the first note of a <see cref="AlternatingMonoPattern"/>.
+        /// Evaluate the difficulty of the first hitobject within a colour streak.
         /// </summary>
-        public static double EvaluateDifficultyOf(AlternatingMonoPattern alternatingMonoPattern)
-        {
-            return DifficultyCalculationUtils.Logistic(exponent: Math.E * alternatingMonoPattern.Index - 2 * Math.E) * EvaluateDifficultyOf(alternatingMonoPattern.Parent);
-        }
-
-        /// <summary>
-        /// Evaluate the difficulty of the first note of a <see cref="RepeatingHitPatterns"/>.
-        /// </summary>
-        public static double EvaluateDifficultyOf(RepeatingHitPatterns repeatingHitPattern)
-        {
-            return 2 * (1 - DifficultyCalculationUtils.Logistic(exponent: Math.E * repeatingHitPattern.RepetitionInterval - 2 * Math.E));
-        }
-
         public static double EvaluateDifficultyOf(DifficultyHitObject hitObject)
         {
-            TaikoDifficultyHitObjectColour colour = ((TaikoDifficultyHitObject)hitObject).Colour;
+            var taikoObject = (TaikoDifficultyHitObject)hitObject;
+            TaikoColourData colourData = taikoObject.ColourData;
             double difficulty = 0.0d;
 
-            if (colour.MonoStreak?.FirstHitObject == hitObject) // Difficulty for MonoStreak
-                difficulty += EvaluateDifficultyOf(colour.MonoStreak);
-            if (colour.AlternatingMonoPattern?.FirstHitObject == hitObject) // Difficulty for AlternatingMonoPattern
-                difficulty += EvaluateDifficultyOf(colour.AlternatingMonoPattern);
-            if (colour.RepeatingHitPattern?.FirstHitObject == hitObject) // Difficulty for RepeatingHitPattern
-                difficulty += EvaluateDifficultyOf(colour.RepeatingHitPattern);
+            if (colourData.MonoStreak?.FirstHitObject == hitObject) // Difficulty for MonoStreak
+                difficulty += evaluateMonoStreakDifficulty(colourData.MonoStreak);
+
+            if (colourData.AlternatingMonoPattern?.FirstHitObject == hitObject) // Difficulty for AlternatingMonoPattern
+                difficulty += evaluateAlternatingMonoPatternDifficulty(colourData.AlternatingMonoPattern);
+
+            if (colourData.RepeatingHitPattern?.FirstHitObject == hitObject) // Difficulty for RepeatingHitPattern
+                difficulty += evaluateRepeatingHitPatternsDifficulty(colourData.RepeatingHitPattern);
+
+            double consistencyPenalty = consistentRatioPenalty(taikoObject);
+            difficulty *= consistencyPenalty;
 
             return difficulty;
         }
+
+        private static double evaluateMonoStreakDifficulty(MonoStreak monoStreak) =>
+            DifficultyCalculationUtils.Logistic(exponent: Math.E * monoStreak.Index - 2 * Math.E) * evaluateAlternatingMonoPatternDifficulty(monoStreak.Parent) * 0.5;
+
+        private static double evaluateAlternatingMonoPatternDifficulty(AlternatingMonoPattern alternatingMonoPattern) =>
+            DifficultyCalculationUtils.Logistic(exponent: Math.E * alternatingMonoPattern.Index - 2 * Math.E) * evaluateRepeatingHitPatternsDifficulty(alternatingMonoPattern.Parent);
+
+        private static double evaluateRepeatingHitPatternsDifficulty(RepeatingHitPatterns repeatingHitPattern) =>
+            2 * (1 - DifficultyCalculationUtils.Logistic(exponent: Math.E * repeatingHitPattern.RepetitionInterval - 2 * Math.E));
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ReadingEvaluator.cs b/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ReadingEvaluator.cs
new file mode 100644
index 0000000000..5871979613
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/ReadingEvaluator.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;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
+{
+    public static class ReadingEvaluator
+    {
+        private readonly struct VelocityRange
+        {
+            public double Min { get; }
+            public double Max { get; }
+            public double Center => (Max + Min) / 2;
+            public double Range => Max - Min;
+
+            public VelocityRange(double min, double max)
+            {
+                Min = min;
+                Max = max;
+            }
+        }
+
+        /// <summary>
+        /// Calculates the influence of higher slider velocities on hitobject difficulty.
+        /// The bonus is determined based on the EffectiveBPM, shifting within a defined range
+        /// between the upper and lower boundaries to reflect how increased slider velocity impacts difficulty.
+        /// </summary>
+        /// <param name="noteObject">The hit object to evaluate.</param>
+        /// <returns>The reading difficulty value for the given hit object.</returns>
+        public static double EvaluateDifficultyOf(TaikoDifficultyHitObject noteObject)
+        {
+            var highVelocity = new VelocityRange(480, 640);
+            var midVelocity = new VelocityRange(360, 480);
+
+            // Apply a cap to prevent outlier values on maps that exceed the editor's parameters.
+            double effectiveBPM = Math.Max(1.0, noteObject.EffectiveBPM);
+
+            double midVelocityDifficulty = 0.5 * DifficultyCalculationUtils.Logistic(effectiveBPM, midVelocity.Center, 1.0 / (midVelocity.Range / 10));
+
+            // Expected DeltaTime is the DeltaTime this note would need to be spaced equally to a base slider velocity 1/4 note.
+            double expectedDeltaTime = 21000.0 / effectiveBPM;
+            double objectDensity = expectedDeltaTime / Math.Max(1.0, noteObject.DeltaTime);
+
+            // High density is penalised at high velocity as it is generally considered easier to read. See https://www.desmos.com/calculator/u63f3ntdsi
+            double densityPenalty = DifficultyCalculationUtils.Logistic(objectDensity, 0.925, 15);
+
+            double highVelocityDifficulty = (1.0 - 0.33 * densityPenalty)
+                                            * DifficultyCalculationUtils.Logistic(effectiveBPM, highVelocity.Center + 8 * densityPenalty, (1.0 + 0.5 * densityPenalty) / (highVelocity.Range / 10));
+
+            return midVelocityDifficulty + highVelocityDifficulty;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/RhythmEvaluator.cs
new file mode 100644
index 0000000000..3b3aea07f3
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -0,0 +1,156 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm.Data;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
+{
+    public class RhythmEvaluator
+    {
+        /// <summary>
+        /// Evaluate the difficulty of a hitobject considering its interval change.
+        /// </summary>
+        public static double EvaluateDifficultyOf(DifficultyHitObject hitObject, double hitWindow)
+        {
+            TaikoRhythmData rhythmData = ((TaikoDifficultyHitObject)hitObject).RhythmData;
+            double difficulty = 0.0d;
+
+            double sameRhythm = 0;
+            double samePattern = 0;
+            double intervalPenalty = 0;
+
+            if (rhythmData.SameRhythmGroupedHitObjects?.FirstHitObject == hitObject) // Difficulty for SameRhythmGroupedHitObjects
+            {
+                sameRhythm += 10.0 * evaluateDifficultyOf(rhythmData.SameRhythmGroupedHitObjects, hitWindow);
+                intervalPenalty = repeatedIntervalPenalty(rhythmData.SameRhythmGroupedHitObjects, hitWindow);
+            }
+
+            if (rhythmData.SamePatternsGroupedHitObjects?.FirstHitObject == hitObject) // Difficulty for SamePatternsGroupedHitObjects
+                samePattern += 1.15 * ratioDifficulty(rhythmData.SamePatternsGroupedHitObjects.IntervalRatio);
+
+            difficulty += Math.Max(sameRhythm, samePattern) * intervalPenalty;
+
+            return difficulty;
+        }
+
+        private static double evaluateDifficultyOf(SameRhythmHitObjectGrouping sameRhythmGroupedHitObjects, double hitWindow)
+        {
+            double intervalDifficulty = ratioDifficulty(sameRhythmGroupedHitObjects.HitObjectIntervalRatio);
+            double? previousInterval = sameRhythmGroupedHitObjects.Previous?.HitObjectInterval;
+
+            intervalDifficulty *= repeatedIntervalPenalty(sameRhythmGroupedHitObjects, hitWindow);
+
+            // If a previous interval exists and there are multiple hit objects in the sequence:
+            if (previousInterval != null && sameRhythmGroupedHitObjects.HitObjects.Count > 1)
+            {
+                double expectedDurationFromPrevious = (double)previousInterval * sameRhythmGroupedHitObjects.HitObjects.Count;
+                double durationDifference = sameRhythmGroupedHitObjects.Duration - expectedDurationFromPrevious;
+
+                if (durationDifference > 0)
+                {
+                    intervalDifficulty *= DifficultyCalculationUtils.Logistic(
+                        durationDifference / hitWindow,
+                        midpointOffset: 0.7,
+                        multiplier: 1.0,
+                        maxValue: 1);
+                }
+            }
+
+            // Penalise patterns that can be hit within a single hit window.
+            intervalDifficulty *= DifficultyCalculationUtils.Logistic(
+                sameRhythmGroupedHitObjects.Duration / hitWindow,
+                midpointOffset: 0.6,
+                multiplier: 1,
+                maxValue: 1);
+
+            return Math.Pow(intervalDifficulty, 0.75);
+        }
+
+        /// <summary>
+        /// Determines if the changes in hit object intervals is consistent based on a given threshold.
+        /// </summary>
+        private static double repeatedIntervalPenalty(SameRhythmHitObjectGrouping sameRhythmGroupedHitObjects, double hitWindow, double threshold = 0.1)
+        {
+            double longIntervalPenalty = sameInterval(sameRhythmGroupedHitObjects, 3);
+
+            double shortIntervalPenalty = sameRhythmGroupedHitObjects.HitObjects.Count < 6
+                ? sameInterval(sameRhythmGroupedHitObjects, 4)
+                : 1.0; // Returns a non-penalty if there are 6 or more notes within an interval.
+
+            // The duration penalty is based on hit object duration relative to hitWindow.
+            double durationPenalty = Math.Max(1 - sameRhythmGroupedHitObjects.Duration * 2 / hitWindow, 0.5);
+
+            return Math.Min(longIntervalPenalty, shortIntervalPenalty) * durationPenalty;
+
+            double sameInterval(SameRhythmHitObjectGrouping startObject, int intervalCount)
+            {
+                List<double?> intervals = new List<double?>();
+                var currentObject = startObject;
+
+                for (int i = 0; i < intervalCount && currentObject != null; i++)
+                {
+                    intervals.Add(currentObject.HitObjectInterval);
+                    currentObject = currentObject.Previous;
+                }
+
+                intervals.RemoveAll(interval => interval == null);
+
+                if (intervals.Count < intervalCount)
+                    return 1.0; // No penalty if there aren't enough valid intervals.
+
+                for (int i = 0; i < intervals.Count; i++)
+                {
+                    for (int j = i + 1; j < intervals.Count; j++)
+                    {
+                        double ratio = intervals[i]!.Value / intervals[j]!.Value;
+                        if (Math.Abs(1 - ratio) <= threshold) // If any two intervals are similar, apply a penalty.
+                            return 0.80;
+                    }
+                }
+
+                return 1.0; // No penalty if all intervals are different.
+            }
+        }
+
+        /// <summary>
+        /// Calculates the difficulty of a given ratio using a combination of periodic penalties and bonuses.
+        /// </summary>
+        private static double ratioDifficulty(double ratio, int terms = 8)
+        {
+            double difficulty = 0;
+
+            // Validate the ratio by ensuring it is a normal number in cases where maps breach regular mapping conditions.
+            ratio = double.IsNormal(ratio) ? ratio : 0;
+
+            for (int i = 1; i <= terms; ++i)
+            {
+                difficulty += termPenalty(ratio, i, 4, 1);
+            }
+
+            difficulty += terms / (1 + ratio);
+
+            // Give bonus to near-1 ratios
+            difficulty += DifficultyCalculationUtils.BellCurve(ratio, 1, 0.5);
+
+            // Penalize ratios that are VERY near 1
+            difficulty -= DifficultyCalculationUtils.BellCurve(ratio, 1, 0.3);
+
+            difficulty = Math.Max(difficulty, 0);
+            difficulty /= Math.Sqrt(8);
+
+            return difficulty;
+        }
+
+        /// <summary>
+        /// Multiplier for a given denominator term.
+        /// </summary>
+        private static double termPenalty(double ratio, int denominator, double power, double multiplier) =>
+            -multiplier * Math.Pow(Math.Cos(denominator * Math.PI * ratio), power);
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/StaminaEvaluator.cs b/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/StaminaEvaluator.cs
index 84d5de4c63..32ed8ec189 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/StaminaEvaluator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Evaluators/StaminaEvaluator.cs
@@ -8,43 +8,8 @@ using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
 {
-    public class StaminaEvaluator
+    public static class StaminaEvaluator
     {
-        /// <summary>
-        /// Applies a speed bonus dependent on the time since the last hit performed using this finger.
-        /// </summary>
-        /// <param name="interval">The interval between the current and previous note hit using the same finger.</param>
-        private static double speedBonus(double interval)
-        {
-            // Interval is capped at a very small value to prevent infinite values.
-            interval = Math.Max(interval, 1);
-
-            return 30 / interval;
-        }
-
-        /// <summary>
-        /// Determines the number of fingers available to hit the current <see cref="TaikoDifficultyHitObject"/>.
-        /// Any mono notes that is more than 300ms apart from a colour change will be considered to have more than 2
-        /// fingers available, since players can hit the same key with multiple fingers.
-        /// </summary>
-        private static int availableFingersFor(TaikoDifficultyHitObject hitObject)
-        {
-            DifficultyHitObject? previousColourChange = hitObject.Colour.PreviousColourChange;
-            DifficultyHitObject? nextColourChange = hitObject.Colour.NextColourChange;
-
-            if (previousColourChange != null && hitObject.StartTime - previousColourChange.StartTime < 300)
-            {
-                return 2;
-            }
-
-            if (nextColourChange != null && nextColourChange.StartTime - hitObject.StartTime < 300)
-            {
-                return 2;
-            }
-
-            return 4;
-        }
-
         /// <summary>
         /// Evaluates the minimum mechanical stamina required to play the current object. This is calculated using the
         /// maximum possible interval between two hits using the same key, by alternating available fingers for each colour.
@@ -59,17 +24,51 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Evaluators
             // Find the previous hit object hit by the current finger, which is n notes prior, n being the number of
             // available fingers.
             TaikoDifficultyHitObject taikoCurrent = (TaikoDifficultyHitObject)current;
-            TaikoDifficultyHitObject? keyPrevious = taikoCurrent.PreviousMono(availableFingersFor(taikoCurrent) - 1);
-
-            if (keyPrevious == null)
-            {
-                // There is no previous hit object hit by the current finger
-                return 0.0;
-            }
+            TaikoDifficultyHitObject? taikoPrevious = current.Previous(1) as TaikoDifficultyHitObject;
+            TaikoDifficultyHitObject? previousMono = taikoCurrent.PreviousMono(availableFingersFor(taikoCurrent) - 1);
 
             double objectStrain = 0.5; // Add a base strain to all objects
-            objectStrain += speedBonus(taikoCurrent.StartTime - keyPrevious.StartTime);
+            if (taikoPrevious == null) return objectStrain;
+
+            if (previousMono != null)
+                objectStrain += speedBonus(taikoCurrent.StartTime - previousMono.StartTime) + 0.5 * speedBonus(taikoCurrent.StartTime - taikoPrevious.StartTime);
+
             return objectStrain;
         }
+
+        /// <summary>
+        /// Applies a speed bonus dependent on the time since the last hit performed using this finger.
+        /// </summary>
+        /// <param name="interval">The interval between the current and previous note hit using the same finger.</param>
+        private static double speedBonus(double interval)
+        {
+            // Interval is capped at a very small value to prevent infinite values.
+            interval = Math.Max(interval, 1);
+
+            return 20 / interval;
+        }
+
+        /// <summary>
+        /// Determines the number of fingers available to hit the current <see cref="TaikoDifficultyHitObject"/>.
+        /// Any mono notes that is more than 300ms apart from a colour change will be considered to have more than 2
+        /// fingers available, since players can hit the same key with multiple fingers.
+        /// </summary>
+        private static int availableFingersFor(TaikoDifficultyHitObject hitObject)
+        {
+            DifficultyHitObject? previousColourChange = hitObject.ColourData.PreviousColourChange;
+            DifficultyHitObject? nextColourChange = hitObject.ColourData.NextColourChange;
+
+            if (previousColourChange != null && hitObject.StartTime - previousColourChange.StartTime < 300)
+            {
+                return 2;
+            }
+
+            if (nextColourChange != null && nextColourChange.StartTime - hitObject.StartTime < 300)
+            {
+                return 2;
+            }
+
+            return 8;
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoDifficultyHitObjectColour.cs b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoColourData.cs
similarity index 96%
rename from osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoDifficultyHitObjectColour.cs
rename to osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoColourData.cs
index abf6fb3672..81201b6584 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoDifficultyHitObjectColour.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoColourData.cs
@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour
     /// <summary>
     /// Stores colour compression information for a <see cref="TaikoDifficultyHitObject"/>.
     /// </summary>
-    public class TaikoDifficultyHitObjectColour
+    public class TaikoColourData
     {
         /// <summary>
         /// The <see cref="MonoStreak"/> that encodes this note.
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoColourDifficultyPreprocessor.cs b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoColourDifficultyPreprocessor.cs
index 18a299ae92..3c6ef7c53c 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoColourDifficultyPreprocessor.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Colour/TaikoColourDifficultyPreprocessor.cs
@@ -14,8 +14,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour
     public static class TaikoColourDifficultyPreprocessor
     {
         /// <summary>
-        /// Processes and encodes a list of <see cref="TaikoDifficultyHitObject"/>s into a list of <see cref="TaikoDifficultyHitObjectColour"/>s,
-        /// assigning the appropriate <see cref="TaikoDifficultyHitObjectColour"/>s to each <see cref="TaikoDifficultyHitObject"/>.
+        /// Processes and encodes a list of <see cref="TaikoDifficultyHitObject"/>s into a list of <see cref="TaikoColourData"/>s,
+        /// assigning the appropriate <see cref="TaikoColourData"/>s to each <see cref="TaikoDifficultyHitObject"/>.
         /// </summary>
         public static void ProcessAndAssign(List<DifficultyHitObject> hitObjects)
         {
@@ -41,9 +41,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour
 
                         foreach (var hitObject in monoStreak.HitObjects)
                         {
-                            hitObject.Colour.RepeatingHitPattern = repeatingHitPattern;
-                            hitObject.Colour.AlternatingMonoPattern = monoPattern;
-                            hitObject.Colour.MonoStreak = monoStreak;
+                            hitObject.ColourData.RepeatingHitPattern = repeatingHitPattern;
+                            hitObject.ColourData.AlternatingMonoPattern = monoPattern;
+                            hitObject.ColourData.MonoStreak = monoStreak;
                         }
                     }
                 }
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/Data/SamePatternsGroupedHitObjects.cs b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/Data/SamePatternsGroupedHitObjects.cs
new file mode 100644
index 0000000000..938cb4670f
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/Data/SamePatternsGroupedHitObjects.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.Collections.Generic;
+using System.Linq;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm.Data
+{
+    /// <summary>
+    /// Represents <see cref="SameRhythmHitObjectGrouping"/> grouped by their <see cref="SameRhythmHitObjectGrouping.StartTime"/>'s interval.
+    /// </summary>
+    public class SamePatternsGroupedHitObjects
+    {
+        public IReadOnlyList<SameRhythmHitObjectGrouping> Groups { get; }
+
+        public SamePatternsGroupedHitObjects? Previous { get; }
+
+        /// <summary>
+        /// The <see cref="SameRhythmHitObjectGrouping.Interval"/> between groups <see cref="SameRhythmHitObjectGrouping"/>.
+        /// If there is only one group, this will have the value of the first group's <see cref="SameRhythmHitObjectGrouping.Interval"/>.
+        /// </summary>
+        public double GroupInterval => Groups.Count > 1 ? Groups[1].Interval : Groups[0].Interval;
+
+        /// <summary>
+        /// The ratio of <see cref="GroupInterval"/> between this and the previous <see cref="SamePatternsGroupedHitObjects"/>. In the
+        /// case where there is no previous <see cref="SamePatternsGroupedHitObjects"/>, this will have a value of 1.
+        /// </summary>
+        public double IntervalRatio => GroupInterval / Previous?.GroupInterval ?? 1.0d;
+
+        public TaikoDifficultyHitObject FirstHitObject => Groups[0].FirstHitObject;
+
+        public IEnumerable<TaikoDifficultyHitObject> AllHitObjects => Groups.SelectMany(hitObject => hitObject.HitObjects);
+
+        public SamePatternsGroupedHitObjects(SamePatternsGroupedHitObjects? previous, List<SameRhythmHitObjectGrouping> groups)
+        {
+            Previous = previous;
+            Groups = groups;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/Data/SameRhythmHitObjectGrouping.cs b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/Data/SameRhythmHitObjectGrouping.cs
new file mode 100644
index 0000000000..9caa9b9958
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/Data/SameRhythmHitObjectGrouping.cs
@@ -0,0 +1,63 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Difficulty.Utils;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm.Data
+{
+    /// <summary>
+    /// Represents a group of <see cref="TaikoDifficultyHitObject"/>s with no rhythm variation.
+    /// </summary>
+    public class SameRhythmHitObjectGrouping : IHasInterval
+    {
+        public readonly List<TaikoDifficultyHitObject> HitObjects;
+
+        public TaikoDifficultyHitObject FirstHitObject => HitObjects[0];
+
+        public readonly SameRhythmHitObjectGrouping? Previous;
+
+        /// <summary>
+        /// <see cref="DifficultyHitObject.StartTime"/> of the first hit object.
+        /// </summary>
+        public double StartTime => HitObjects[0].StartTime;
+
+        /// <summary>
+        /// The interval between the first and final hit object within this group.
+        /// </summary>
+        public double Duration => HitObjects[^1].StartTime - HitObjects[0].StartTime;
+
+        /// <summary>
+        /// The interval in ms of each hit object in this <see cref="SameRhythmHitObjectGrouping"/>. This is only defined if there is
+        /// more than two hit objects in this <see cref="SameRhythmHitObjectGrouping"/>.
+        /// </summary>
+        public readonly double? HitObjectInterval;
+
+        /// <summary>
+        /// The ratio of <see cref="HitObjectInterval"/> between this and the previous <see cref="SameRhythmHitObjectGrouping"/>. In the
+        /// case where one or both of the <see cref="HitObjectInterval"/> is undefined, this will have a value of 1.
+        /// </summary>
+        public readonly double HitObjectIntervalRatio;
+
+        /// <inheritdoc/>
+        public double Interval { get; }
+
+        public SameRhythmHitObjectGrouping(SameRhythmHitObjectGrouping? previous, List<TaikoDifficultyHitObject> hitObjects)
+        {
+            Previous = previous;
+            HitObjects = hitObjects;
+
+            // Calculate the average interval between hitobjects, or null if there are fewer than two
+            HitObjectInterval = HitObjects.Count < 2 ? null : Duration / (HitObjects.Count - 1);
+
+            // Calculate the ratio between this group's interval and the previous group's interval
+            HitObjectIntervalRatio = Previous?.HitObjectInterval != null && HitObjectInterval != null
+                ? HitObjectInterval.Value / Previous.HitObjectInterval.Value
+                : 1;
+
+            // Calculate the interval from the previous group's start time
+            Interval = Previous != null ? StartTime - Previous.StartTime : double.PositiveInfinity;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/TaikoDifficultyHitObjectRhythm.cs b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/TaikoDifficultyHitObjectRhythm.cs
deleted file mode 100644
index a273d7e2ea..0000000000
--- a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/TaikoDifficultyHitObjectRhythm.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm
-{
-    /// <summary>
-    /// Represents a rhythm change in a taiko map.
-    /// </summary>
-    public class TaikoDifficultyHitObjectRhythm
-    {
-        /// <summary>
-        /// The difficulty multiplier associated with this rhythm change.
-        /// </summary>
-        public readonly double Difficulty;
-
-        /// <summary>
-        /// The ratio of current <see cref="osu.Game.Rulesets.Difficulty.Preprocessing.DifficultyHitObject.DeltaTime"/>
-        /// to previous <see cref="osu.Game.Rulesets.Difficulty.Preprocessing.DifficultyHitObject.DeltaTime"/> for the rhythm change.
-        /// A <see cref="Ratio"/> above 1 indicates a slow-down; a <see cref="Ratio"/> below 1 indicates a speed-up.
-        /// </summary>
-        public readonly double Ratio;
-
-        /// <summary>
-        /// Creates an object representing a rhythm change.
-        /// </summary>
-        /// <param name="numerator">The numerator for <see cref="Ratio"/>.</param>
-        /// <param name="denominator">The denominator for <see cref="Ratio"/></param>
-        /// <param name="difficulty">The difficulty multiplier associated with this rhythm change.</param>
-        public TaikoDifficultyHitObjectRhythm(int numerator, int denominator, double difficulty)
-        {
-            Ratio = numerator / (double)denominator;
-            Difficulty = difficulty;
-        }
-    }
-}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/TaikoRhythmData.cs b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/TaikoRhythmData.cs
new file mode 100644
index 0000000000..247fb06dc0
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/TaikoRhythmData.cs
@@ -0,0 +1,79 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm.Data;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm
+{
+    /// <summary>
+    /// Stores rhythm data for a <see cref="TaikoDifficultyHitObject"/>.
+    /// </summary>
+    public class TaikoRhythmData
+    {
+        /// <summary>
+        /// The group of hit objects with consistent rhythm that this object belongs to.
+        /// </summary>
+        public SameRhythmHitObjectGrouping? SameRhythmGroupedHitObjects;
+
+        /// <summary>
+        /// The larger pattern of rhythm groups that this object is part of.
+        /// </summary>
+        public SamePatternsGroupedHitObjects? SamePatternsGroupedHitObjects;
+
+        /// <summary>
+        /// The ratio of current <see cref="Rulesets.Difficulty.Preprocessing.DifficultyHitObject.DeltaTime"/>
+        /// to previous <see cref="Rulesets.Difficulty.Preprocessing.DifficultyHitObject.DeltaTime"/> for the rhythm change.
+        /// A <see cref="Ratio"/> above 1 indicates a slow-down; a <see cref="Ratio"/> below 1 indicates a speed-up.
+        /// </summary>
+        /// <remarks>
+        /// This is snapped to the closest matching <see cref="common_ratios"/>.
+        /// </remarks>
+        public readonly double Ratio;
+
+        /// <summary>
+        /// Initialises a new instance of <see cref="TaikoRhythmData"/>s,
+        /// calculating the closest rhythm change and its associated difficulty for the current hit object.
+        /// </summary>
+        /// <param name="current">The current <see cref="TaikoDifficultyHitObject"/> being processed.</param>
+        public TaikoRhythmData(TaikoDifficultyHitObject current)
+        {
+            var previous = current.Previous(0);
+
+            if (previous == null)
+            {
+                Ratio = 1;
+                return;
+            }
+
+            double actualRatio = current.DeltaTime / previous.DeltaTime;
+            double closestRatio = common_ratios.MinBy(r => Math.Abs(r - actualRatio));
+
+            Ratio = closestRatio;
+        }
+
+        /// <summary>
+        /// List of most common rhythm changes in taiko maps. Based on how each object's interval compares to the previous object.
+        /// </summary>
+        /// <remarks>
+        /// The general guidelines for the values are:
+        /// <list type="bullet">
+        /// <item>rhythm changes with ratio closer to 1 (that are <i>not</i> 1) are harder to play,</item>
+        /// <item>speeding up is <i>generally</i> harder than slowing down (with exceptions of rhythm changes requiring a hand switch).</item>
+        /// </list>
+        /// </remarks>
+        private static readonly double[] common_ratios =
+        [
+            1.0 / 1,
+            2.0 / 1,
+            1.0 / 2,
+            3.0 / 1,
+            1.0 / 3,
+            3.0 / 2,
+            2.0 / 3,
+            5.0 / 4,
+            4.0 / 5
+        ];
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/TaikoRhythmDifficultyPreprocessor.cs b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/TaikoRhythmDifficultyPreprocessor.cs
new file mode 100644
index 0000000000..5bc0fdbc03
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/Rhythm/TaikoRhythmDifficultyPreprocessor.cs
@@ -0,0 +1,52 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm.Data;
+using osu.Game.Rulesets.Taiko.Difficulty.Utils;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm
+{
+    public static class TaikoRhythmDifficultyPreprocessor
+    {
+        public static void ProcessAndAssign(List<TaikoDifficultyHitObject> hitObjects)
+        {
+            var rhythmGroups = createSameRhythmGroupedHitObjects(hitObjects);
+
+            foreach (var rhythmGroup in rhythmGroups)
+            {
+                foreach (var hitObject in rhythmGroup.HitObjects)
+                    hitObject.RhythmData.SameRhythmGroupedHitObjects = rhythmGroup;
+            }
+
+            var patternGroups = createSamePatternGroupedHitObjects(rhythmGroups);
+
+            foreach (var patternGroup in patternGroups)
+            {
+                foreach (var hitObject in patternGroup.AllHitObjects)
+                    hitObject.RhythmData.SamePatternsGroupedHitObjects = patternGroup;
+            }
+        }
+
+        private static List<SameRhythmHitObjectGrouping> createSameRhythmGroupedHitObjects(List<TaikoDifficultyHitObject> hitObjects)
+        {
+            var rhythmGroups = new List<SameRhythmHitObjectGrouping>();
+
+            foreach (var grouped in IntervalGroupingUtils.GroupByInterval(hitObjects))
+                rhythmGroups.Add(new SameRhythmHitObjectGrouping(rhythmGroups.LastOrDefault(), grouped));
+
+            return rhythmGroups;
+        }
+
+        private static List<SamePatternsGroupedHitObjects> createSamePatternGroupedHitObjects(List<SameRhythmHitObjectGrouping> rhythmGroups)
+        {
+            var patternGroups = new List<SamePatternsGroupedHitObjects>();
+
+            foreach (var grouped in IntervalGroupingUtils.GroupByInterval(rhythmGroups))
+                patternGroups.Add(new SamePatternsGroupedHitObjects(patternGroups.LastOrDefault(), grouped));
+
+            return patternGroups;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/TaikoDifficultyHitObject.cs b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/TaikoDifficultyHitObject.cs
index 4aaee50c18..f407e13ff1 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/TaikoDifficultyHitObject.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/TaikoDifficultyHitObject.cs
@@ -1,21 +1,23 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Taiko.Difficulty.Evaluators;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm;
+using osu.Game.Rulesets.Taiko.Difficulty.Utils;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
 {
     /// <summary>
     /// Represents a single hit object in taiko difficulty calculation.
     /// </summary>
-    public class TaikoDifficultyHitObject : DifficultyHitObject
+    public class TaikoDifficultyHitObject : DifficultyHitObject, IHasInterval
     {
         /// <summary>
         /// The list of all <see cref="TaikoDifficultyHitObject"/> of the same colour as this <see cref="TaikoDifficultyHitObject"/> in the beatmap.
@@ -38,98 +40,89 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
         public readonly int NoteIndex;
 
         /// <summary>
-        /// The rhythm required to hit this hit object.
+        /// Rhythm data used by <see cref="RhythmEvaluator"/>.
+        /// This is populated via <see cref="TaikoRhythmDifficultyPreprocessor"/>.
         /// </summary>
-        public readonly TaikoDifficultyHitObjectRhythm Rhythm;
+        public readonly TaikoRhythmData RhythmData;
 
         /// <summary>
-        /// Colour data for this hit object. This is used by colour evaluator to calculate colour difficulty, but can be used
-        /// by other skills in the future.
+        /// Colour data used by <see cref="ColourEvaluator"/> and <see cref="StaminaEvaluator"/>.
+        /// This is populated via <see cref="TaikoColourDifficultyPreprocessor"/>.
         /// </summary>
-        public readonly TaikoDifficultyHitObjectColour Colour;
+        public readonly TaikoColourData ColourData;
+
+        /// <summary>
+        /// The adjusted BPM of this hit object, based on its slider velocity and scroll speed.
+        /// </summary>
+        public double EffectiveBPM;
 
         /// <summary>
         /// Creates a new difficulty hit object.
         /// </summary>
         /// <param name="hitObject">The gameplay <see cref="HitObject"/> associated with this difficulty object.</param>
         /// <param name="lastObject">The gameplay <see cref="HitObject"/> preceding <paramref name="hitObject"/>.</param>
-        /// <param name="lastLastObject">The gameplay <see cref="HitObject"/> preceding <paramref name="lastObject"/>.</param>
         /// <param name="clockRate">The rate of the gameplay clock. Modified by speed-changing mods.</param>
         /// <param name="objects">The list of all <see cref="DifficultyHitObject"/>s in the current beatmap.</param>
         /// <param name="centreHitObjects">The list of centre (don) <see cref="DifficultyHitObject"/>s in the current beatmap.</param>
         /// <param name="rimHitObjects">The list of rim (kat) <see cref="DifficultyHitObject"/>s in the current beatmap.</param>
         /// <param name="noteObjects">The list of <see cref="DifficultyHitObject"/>s that is a hit (i.e. not a drumroll or swell) in the current beatmap.</param>
         /// <param name="index">The position of this <see cref="DifficultyHitObject"/> in the <paramref name="objects"/> list.</param>
-        public TaikoDifficultyHitObject(HitObject hitObject, HitObject lastObject, HitObject lastLastObject, double clockRate,
+        /// <param name="controlPointInfo">The control point info of the beatmap.</param>
+        /// <param name="globalSliderVelocity">The global slider velocity of the beatmap.</param>
+        public TaikoDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate,
                                         List<DifficultyHitObject> objects,
                                         List<TaikoDifficultyHitObject> centreHitObjects,
                                         List<TaikoDifficultyHitObject> rimHitObjects,
-                                        List<TaikoDifficultyHitObject> noteObjects, int index)
+                                        List<TaikoDifficultyHitObject> noteObjects, int index,
+                                        ControlPointInfo controlPointInfo,
+                                        double globalSliderVelocity)
             : base(hitObject, lastObject, clockRate, objects, index)
         {
             noteDifficultyHitObjects = noteObjects;
 
-            // Create the Colour object, its properties should be filled in by TaikoDifficultyPreprocessor
-            Colour = new TaikoDifficultyHitObjectColour();
-            Rhythm = getClosestRhythm(lastObject, lastLastObject, clockRate);
+            ColourData = new TaikoColourData();
+            RhythmData = new TaikoRhythmData(this);
 
-            switch ((hitObject as Hit)?.Type)
+            if (hitObject is Hit hit)
             {
-                case HitType.Centre:
-                    MonoIndex = centreHitObjects.Count;
-                    centreHitObjects.Add(this);
-                    monoDifficultyHitObjects = centreHitObjects;
-                    break;
+                switch (hit.Type)
+                {
+                    case HitType.Centre:
+                        MonoIndex = centreHitObjects.Count;
+                        centreHitObjects.Add(this);
+                        monoDifficultyHitObjects = centreHitObjects;
+                        break;
 
-                case HitType.Rim:
-                    MonoIndex = rimHitObjects.Count;
-                    rimHitObjects.Add(this);
-                    monoDifficultyHitObjects = rimHitObjects;
-                    break;
-            }
+                    case HitType.Rim:
+                        MonoIndex = rimHitObjects.Count;
+                        rimHitObjects.Add(this);
+                        monoDifficultyHitObjects = rimHitObjects;
+                        break;
+                }
 
-            if (hitObject is Hit)
-            {
                 NoteIndex = noteObjects.Count;
                 noteObjects.Add(this);
             }
+
+            // Using `hitObject.StartTime` causes floating point error differences
+            double normalisedStartTime = StartTime * clockRate;
+
+            // Retrieve the timing point at the note's start time
+            TimingControlPoint currentControlPoint = controlPointInfo.TimingPointAt(normalisedStartTime);
+
+            // Calculate the slider velocity at the note's start time.
+            double currentSliderVelocity = calculateSliderVelocity(controlPointInfo, globalSliderVelocity, normalisedStartTime, clockRate);
+
+            EffectiveBPM = currentControlPoint.BPM * currentSliderVelocity;
         }
 
         /// <summary>
-        /// List of most common rhythm changes in taiko maps.
+        /// Calculates the slider velocity based on control point info and clock rate.
         /// </summary>
-        /// <remarks>
-        /// The general guidelines for the values are:
-        /// <list type="bullet">
-        /// <item>rhythm changes with ratio closer to 1 (that are <i>not</i> 1) are harder to play,</item>
-        /// <item>speeding up is <i>generally</i> harder than slowing down (with exceptions of rhythm changes requiring a hand switch).</item>
-        /// </list>
-        /// </remarks>
-        private static readonly TaikoDifficultyHitObjectRhythm[] common_rhythms =
+        private static double calculateSliderVelocity(ControlPointInfo controlPointInfo, double globalSliderVelocity, double startTime, double clockRate)
         {
-            new TaikoDifficultyHitObjectRhythm(1, 1, 0.0),
-            new TaikoDifficultyHitObjectRhythm(2, 1, 0.3),
-            new TaikoDifficultyHitObjectRhythm(1, 2, 0.5),
-            new TaikoDifficultyHitObjectRhythm(3, 1, 0.3),
-            new TaikoDifficultyHitObjectRhythm(1, 3, 0.35),
-            new TaikoDifficultyHitObjectRhythm(3, 2, 0.6), // purposefully higher (requires hand switch in full alternating gameplay style)
-            new TaikoDifficultyHitObjectRhythm(2, 3, 0.4),
-            new TaikoDifficultyHitObjectRhythm(5, 4, 0.5),
-            new TaikoDifficultyHitObjectRhythm(4, 5, 0.7)
-        };
-
-        /// <summary>
-        /// Returns the closest rhythm change from <see cref="common_rhythms"/> required to hit this object.
-        /// </summary>
-        /// <param name="lastObject">The gameplay <see cref="HitObject"/> preceding this one.</param>
-        /// <param name="lastLastObject">The gameplay <see cref="HitObject"/> preceding <paramref name="lastObject"/>.</param>
-        /// <param name="clockRate">The rate of the gameplay clock.</param>
-        private TaikoDifficultyHitObjectRhythm getClosestRhythm(HitObject lastObject, HitObject lastLastObject, double clockRate)
-        {
-            double prevLength = (lastObject.StartTime - lastLastObject.StartTime) / clockRate;
-            double ratio = DeltaTime / prevLength;
-
-            return common_rhythms.OrderBy(x => Math.Abs(x.Ratio - ratio)).First();
+            var activeEffectControlPoint = controlPointInfo.EffectPointAt(startTime);
+            return globalSliderVelocity * (activeEffectControlPoint.ScrollSpeed) * clockRate;
         }
 
         public TaikoDifficultyHitObject? PreviousMono(int backwardsIndex) => monoDifficultyHitObjects?.ElementAtOrDefault(MonoIndex - (backwardsIndex + 1));
@@ -139,5 +132,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
         public TaikoDifficultyHitObject? PreviousNote(int backwardsIndex) => noteDifficultyHitObjects.ElementAtOrDefault(NoteIndex - (backwardsIndex + 1));
 
         public TaikoDifficultyHitObject? NextNote(int forwardsIndex) => noteDifficultyHitObjects.ElementAtOrDefault(NoteIndex + (forwardsIndex + 1));
+
+        public double Interval => DeltaTime;
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Skills/Reading.cs b/osu.Game.Rulesets.Taiko/Difficulty/Skills/Reading.cs
new file mode 100644
index 0000000000..7be1107b70
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Skills/Reading.cs
@@ -0,0 +1,48 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Taiko.Difficulty.Evaluators;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Taiko.Objects;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
+{
+    /// <summary>
+    /// Calculates the reading coefficient of taiko difficulty.
+    /// </summary>
+    public class Reading : StrainDecaySkill
+    {
+        protected override double SkillMultiplier => 1.0;
+        protected override double StrainDecayBase => 0.4;
+
+        private double currentStrain;
+
+        public Reading(Mod[] mods)
+            : base(mods)
+        {
+        }
+
+        protected override double StrainValueOf(DifficultyHitObject current)
+        {
+            // Drum Rolls and Swells are exempt.
+            if (current.BaseObject is not Hit)
+            {
+                return 0.0;
+            }
+
+            var taikoObject = (TaikoDifficultyHitObject)current;
+            int index = taikoObject.ColourData.MonoStreak?.HitObjects.IndexOf(taikoObject) ?? 0;
+
+            currentStrain *= DifficultyCalculationUtils.Logistic(index, 4, -1 / 25.0, 0.5) + 0.5;
+
+            currentStrain *= StrainDecayBase;
+            currentStrain += ReadingEvaluator.EvaluateDifficultyOf(taikoObject) * SkillMultiplier;
+
+            return currentStrain;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Skills/Rhythm.cs b/osu.Game.Rulesets.Taiko/Difficulty/Skills/Rhythm.cs
index e76af13686..45d0d0a548 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/Skills/Rhythm.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Skills/Rhythm.cs
@@ -1,13 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Taiko.Objects;
-using osu.Game.Utils;
+using osu.Game.Rulesets.Taiko.Difficulty.Evaluators;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
 {
@@ -16,158 +14,26 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
     /// </summary>
     public class Rhythm : StrainDecaySkill
     {
-        protected override double SkillMultiplier => 10;
-        protected override double StrainDecayBase => 0;
+        protected override double SkillMultiplier => 1.0;
+        protected override double StrainDecayBase => 0.4;
 
-        /// <summary>
-        /// The note-based decay for rhythm strain.
-        /// </summary>
-        /// <remarks>
-        /// <see cref="StrainDecayBase"/> is not used here, as it's time- and not note-based.
-        /// </remarks>
-        private const double strain_decay = 0.96;
+        private readonly double greatHitWindow;
 
-        /// <summary>
-        /// Maximum number of entries in <see cref="rhythmHistory"/>.
-        /// </summary>
-        private const int rhythm_history_max_length = 8;
-
-        /// <summary>
-        /// Contains the last <see cref="rhythm_history_max_length"/> changes in note sequence rhythms.
-        /// </summary>
-        private readonly LimitedCapacityQueue<TaikoDifficultyHitObject> rhythmHistory = new LimitedCapacityQueue<TaikoDifficultyHitObject>(rhythm_history_max_length);
-
-        /// <summary>
-        /// Contains the rolling rhythm strain.
-        /// Used to apply per-note decay.
-        /// </summary>
-        private double currentStrain;
-
-        /// <summary>
-        /// Number of notes since the last rhythm change has taken place.
-        /// </summary>
-        private int notesSinceRhythmChange;
-
-        public Rhythm(Mod[] mods)
+        public Rhythm(Mod[] mods, double greatHitWindow)
             : base(mods)
         {
+            this.greatHitWindow = greatHitWindow;
         }
 
         protected override double StrainValueOf(DifficultyHitObject current)
         {
-            // drum rolls and swells are exempt.
-            if (!(current.BaseObject is Hit))
-            {
-                resetRhythmAndStrain();
-                return 0.0;
-            }
+            double difficulty = RhythmEvaluator.EvaluateDifficultyOf(current, greatHitWindow);
 
-            currentStrain *= strain_decay;
+            // To prevent abuse of exceedingly long intervals between awkward rhythms, we penalise its difficulty.
+            double staminaDifficulty = StaminaEvaluator.EvaluateDifficultyOf(current) - 0.5; // Remove base strain
+            difficulty *= DifficultyCalculationUtils.Logistic(staminaDifficulty, 1 / 15.0, 50.0);
 
-            TaikoDifficultyHitObject hitObject = (TaikoDifficultyHitObject)current;
-            notesSinceRhythmChange += 1;
-
-            // rhythm difficulty zero (due to rhythm not changing) => no rhythm strain.
-            if (hitObject.Rhythm.Difficulty == 0.0)
-            {
-                return 0.0;
-            }
-
-            double objectStrain = hitObject.Rhythm.Difficulty;
-
-            objectStrain *= repetitionPenalties(hitObject);
-            objectStrain *= patternLengthPenalty(notesSinceRhythmChange);
-            objectStrain *= speedPenalty(hitObject.DeltaTime);
-
-            // careful - needs to be done here since calls above read this value
-            notesSinceRhythmChange = 0;
-
-            currentStrain += objectStrain;
-            return currentStrain;
-        }
-
-        /// <summary>
-        /// Returns a penalty to apply to the current hit object caused by repeating rhythm changes.
-        /// </summary>
-        /// <remarks>
-        /// Repetitions of more recent patterns are associated with a higher penalty.
-        /// </remarks>
-        /// <param name="hitObject">The current hit object being considered.</param>
-        private double repetitionPenalties(TaikoDifficultyHitObject hitObject)
-        {
-            double penalty = 1;
-
-            rhythmHistory.Enqueue(hitObject);
-
-            for (int mostRecentPatternsToCompare = 2; mostRecentPatternsToCompare <= rhythm_history_max_length / 2; mostRecentPatternsToCompare++)
-            {
-                for (int start = rhythmHistory.Count - mostRecentPatternsToCompare - 1; start >= 0; start--)
-                {
-                    if (!samePattern(start, mostRecentPatternsToCompare))
-                        continue;
-
-                    int notesSince = hitObject.Index - rhythmHistory[start].Index;
-                    penalty *= repetitionPenalty(notesSince);
-                    break;
-                }
-            }
-
-            return penalty;
-        }
-
-        /// <summary>
-        /// Determines whether the rhythm change pattern starting at <paramref name="start"/> is a repeat of any of the
-        /// <paramref name="mostRecentPatternsToCompare"/>.
-        /// </summary>
-        private bool samePattern(int start, int mostRecentPatternsToCompare)
-        {
-            for (int i = 0; i < mostRecentPatternsToCompare; i++)
-            {
-                if (rhythmHistory[start + i].Rhythm != rhythmHistory[rhythmHistory.Count - mostRecentPatternsToCompare + i].Rhythm)
-                    return false;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Calculates a single rhythm repetition penalty.
-        /// </summary>
-        /// <param name="notesSince">Number of notes since the last repetition of a rhythm change.</param>
-        private static double repetitionPenalty(int notesSince) => Math.Min(1.0, 0.032 * notesSince);
-
-        /// <summary>
-        /// Calculates a penalty based on the number of notes since the last rhythm change.
-        /// Both rare and frequent rhythm changes are penalised.
-        /// </summary>
-        /// <param name="patternLength">Number of notes since the last rhythm change.</param>
-        private static double patternLengthPenalty(int patternLength)
-        {
-            double shortPatternPenalty = Math.Min(0.15 * patternLength, 1.0);
-            double longPatternPenalty = Math.Clamp(2.5 - 0.15 * patternLength, 0.0, 1.0);
-            return Math.Min(shortPatternPenalty, longPatternPenalty);
-        }
-
-        /// <summary>
-        /// Calculates a penalty for objects that do not require alternating hands.
-        /// </summary>
-        /// <param name="deltaTime">Time (in milliseconds) since the last hit object.</param>
-        private double speedPenalty(double deltaTime)
-        {
-            if (deltaTime < 80) return 1;
-            if (deltaTime < 210) return Math.Max(0, 1.4 - 0.005 * deltaTime);
-
-            resetRhythmAndStrain();
-            return 0.0;
-        }
-
-        /// <summary>
-        /// Resets the rolling strain value and <see cref="notesSinceRhythmChange"/> counter.
-        /// </summary>
-        private void resetRhythmAndStrain()
-        {
-            currentStrain = 0.0;
-            notesSinceRhythmChange = 0;
+            return difficulty;
         }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Skills/Stamina.cs b/osu.Game.Rulesets.Taiko/Difficulty/Skills/Stamina.cs
index f6914039f0..0e1f3d41cf 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/Skills/Stamina.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Skills/Stamina.cs
@@ -4,6 +4,7 @@
 using System;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Taiko.Difficulty.Evaluators;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
@@ -18,7 +19,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
         private double skillMultiplier => 1.1;
         private double strainDecayBase => 0.4;
 
-        private readonly bool singleColourStamina;
+        public readonly bool SingleColourStamina;
+        private readonly bool isConvert;
 
         private double currentStrain;
 
@@ -27,10 +29,12 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
         /// </summary>
         /// <param name="mods">Mods for use in skill calculations.</param>
         /// <param name="singleColourStamina">Reads when Stamina is from a single coloured pattern.</param>
-        public Stamina(Mod[] mods, bool singleColourStamina)
+        /// <param name="isConvert">Determines if the currently evaluated beatmap is converted.</param>
+        public Stamina(Mod[] mods, bool singleColourStamina, bool isConvert)
             : base(mods)
         {
-            this.singleColourStamina = singleColourStamina;
+            SingleColourStamina = singleColourStamina;
+            this.isConvert = isConvert;
         }
 
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
@@ -42,14 +46,16 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
 
             // Safely prevents previous strains from shifting as new notes are added.
             var currentObject = current as TaikoDifficultyHitObject;
-            int index = currentObject?.Colour.MonoStreak?.HitObjects.IndexOf(currentObject) ?? 0;
+            int index = currentObject?.ColourData.MonoStreak?.HitObjects.IndexOf(currentObject) ?? 0;
 
-            if (singleColourStamina)
-                return currentStrain / (1 + Math.Exp(-(index - 10) / 2.0));
+            double monolengthBonus = isConvert ? 1 : 1 + Math.Min(Math.Max((index - 5) / 50.0, 0), 0.30);
 
-            return currentStrain;
+            if (SingleColourStamina)
+                return DifficultyCalculationUtils.Logistic(-(index - 10) / 2.0, currentStrain);
+
+            return currentStrain * monolengthBonus;
         }
 
-        protected override double CalculateInitialStrain(double time, DifficultyHitObject current) => singleColourStamina ? 0 : currentStrain * strainDecay(time - current.Previous(0).StartTime);
+        protected override double CalculateInitialStrain(double time, DifficultyHitObject current) => SingleColourStamina ? 0 : currentStrain * strainDecay(time - current.Previous(0).StartTime);
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs
index c8f0448767..b43468ab18 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs
@@ -10,6 +10,24 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 {
     public class TaikoDifficultyAttributes : DifficultyAttributes
     {
+        /// <summary>
+        /// The difficulty corresponding to the rhythm skill.
+        /// </summary>
+        [JsonProperty("rhythm_difficulty")]
+        public double RhythmDifficulty { get; set; }
+
+        /// <summary>
+        /// The difficulty corresponding to the reading skill.
+        /// </summary>
+        [JsonProperty("reading_difficulty")]
+        public double ReadingDifficulty { get; set; }
+
+        /// <summary>
+        /// The difficulty corresponding to the colour skill.
+        /// </summary>
+        [JsonProperty("colour_difficulty")]
+        public double ColourDifficulty { get; set; }
+
         /// <summary>
         /// The difficulty corresponding to the stamina skill.
         /// </summary>
@@ -22,41 +40,14 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         [JsonProperty("mono_stamina_factor")]
         public double MonoStaminaFactor { get; set; }
 
-        /// <summary>
-        /// The difficulty corresponding to the rhythm skill.
-        /// </summary>
-        [JsonProperty("rhythm_difficulty")]
-        public double RhythmDifficulty { get; set; }
+        [JsonProperty("rhythm_difficult_strains")]
+        public double RhythmTopStrains { get; set; }
 
-        /// <summary>
-        /// The difficulty corresponding to the colour skill.
-        /// </summary>
-        [JsonProperty("colour_difficulty")]
-        public double ColourDifficulty { get; set; }
+        [JsonProperty("colour_difficult_strains")]
+        public double ColourTopStrains { get; set; }
 
-        /// <summary>
-        /// The difficulty corresponding to the hardest parts of the map.
-        /// </summary>
-        [JsonProperty("peak_difficulty")]
-        public double PeakDifficulty { get; set; }
-
-        /// <summary>
-        /// The perceived hit window for a GREAT hit inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the hit window, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("great_hit_window")]
-        public double GreatHitWindow { get; set; }
-
-        /// <summary>
-        /// The perceived hit window for an OK hit inclusive of rate-adjusting mods (DT/HT/etc).
-        /// </summary>
-        /// <remarks>
-        /// Rate-adjusting mods don't directly affect the hit window, but have a perceived effect as a result of adjusting audio timing.
-        /// </remarks>
-        [JsonProperty("ok_hit_window")]
-        public double OkHitWindow { get; set; }
+        [JsonProperty("stamina_difficult_strains")]
+        public double StaminaTopStrains { get; set; }
 
         public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
         {
@@ -64,8 +55,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 yield return v;
 
             yield return (ATTRIB_ID_DIFFICULTY, StarRating);
-            yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
-            yield return (ATTRIB_ID_OK_HIT_WINDOW, OkHitWindow);
             yield return (ATTRIB_ID_MONO_STAMINA_FACTOR, MonoStaminaFactor);
         }
 
@@ -74,8 +63,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             base.FromDatabaseAttributes(values, onlineInfo);
 
             StarRating = values[ATTRIB_ID_DIFFICULTY];
-            GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
-            OkHitWindow = values[ATTRIB_ID_OK_HIT_WINDOW];
             MonoStaminaFactor = values[ATTRIB_ID_MONO_STAMINA_FACTOR];
         }
     }
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
index 7f2558c406..e0bc0e177c 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
@@ -8,10 +8,12 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Colour;
+using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing.Rhythm;
 using osu.Game.Rulesets.Taiko.Difficulty.Skills;
 using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.Scoring;
@@ -21,11 +23,17 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
     public class TaikoDifficultyCalculator : DifficultyCalculator
     {
         private const double difficulty_multiplier = 0.084375;
-        private const double rhythm_skill_multiplier = 0.2 * difficulty_multiplier;
+        private const double rhythm_skill_multiplier = 0.65 * difficulty_multiplier;
+        private const double reading_skill_multiplier = 0.100 * difficulty_multiplier;
         private const double colour_skill_multiplier = 0.375 * difficulty_multiplier;
-        private const double stamina_skill_multiplier = 0.375 * difficulty_multiplier;
+        private const double stamina_skill_multiplier = 0.445 * difficulty_multiplier;
 
-        public override int Version => 20241007;
+        private double strainLengthBonus;
+        private double patternMultiplier;
+
+        private bool isConvert;
+
+        public override int Version => 20250306;
 
         public TaikoDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
@@ -34,12 +42,18 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
         protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clockRate)
         {
+            HitWindows hitWindows = new TaikoHitWindows();
+            hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
+
+            isConvert = beatmap.BeatmapInfo.Ruleset.OnlineID == 0;
+
             return new Skill[]
             {
-                new Rhythm(mods),
+                new Rhythm(mods, hitWindows.WindowFor(HitResult.Great) / clockRate),
+                new Reading(mods),
                 new Colour(mods),
-                new Stamina(mods, false),
-                new Stamina(mods, true)
+                new Stamina(mods, false, isConvert),
+                new Stamina(mods, true, isConvert)
             };
         }
 
@@ -53,21 +67,30 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
-            List<DifficultyHitObject> difficultyHitObjects = new List<DifficultyHitObject>();
-            List<TaikoDifficultyHitObject> centreObjects = new List<TaikoDifficultyHitObject>();
-            List<TaikoDifficultyHitObject> rimObjects = new List<TaikoDifficultyHitObject>();
-            List<TaikoDifficultyHitObject> noteObjects = new List<TaikoDifficultyHitObject>();
+            var difficultyHitObjects = new List<DifficultyHitObject>();
+            var centreObjects = new List<TaikoDifficultyHitObject>();
+            var rimObjects = new List<TaikoDifficultyHitObject>();
+            var noteObjects = new List<TaikoDifficultyHitObject>();
 
+            // Generate TaikoDifficultyHitObjects from the beatmap's hit objects.
             for (int i = 2; i < beatmap.HitObjects.Count; i++)
             {
-                difficultyHitObjects.Add(
-                    new TaikoDifficultyHitObject(
-                        beatmap.HitObjects[i], beatmap.HitObjects[i - 1], beatmap.HitObjects[i - 2], clockRate, difficultyHitObjects,
-                        centreObjects, rimObjects, noteObjects, difficultyHitObjects.Count)
-                );
+                difficultyHitObjects.Add(new TaikoDifficultyHitObject(
+                    beatmap.HitObjects[i],
+                    beatmap.HitObjects[i - 1],
+                    clockRate,
+                    difficultyHitObjects,
+                    centreObjects,
+                    rimObjects,
+                    noteObjects,
+                    difficultyHitObjects.Count,
+                    beatmap.ControlPointInfo,
+                    beatmap.Difficulty.SliderMultiplier
+                ));
             }
 
             TaikoColourDifficultyPreprocessor.ProcessAndAssign(difficultyHitObjects);
+            TaikoRhythmDifficultyPreprocessor.ProcessAndAssign(noteObjects);
 
             return difficultyHitObjects;
         }
@@ -77,60 +100,53 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             if (beatmap.HitObjects.Count == 0)
                 return new TaikoDifficultyAttributes { Mods = mods };
 
-            Colour colour = (Colour)skills.First(x => x is Colour);
-            Rhythm rhythm = (Rhythm)skills.First(x => x is Rhythm);
-            Stamina stamina = (Stamina)skills.First(x => x is Stamina);
-            Stamina singleColourStamina = (Stamina)skills.Last(x => x is Stamina);
+            bool isRelax = mods.Any(h => h is TaikoModRelax);
+
+            var rhythm = skills.OfType<Rhythm>().Single();
+            var reading = skills.OfType<Reading>().Single();
+            var colour = skills.OfType<Colour>().Single();
+            var stamina = skills.OfType<Stamina>().Single(s => !s.SingleColourStamina);
+            var singleColourStamina = skills.OfType<Stamina>().Single(s => s.SingleColourStamina);
 
-            double colourRating = colour.DifficultyValue() * colour_skill_multiplier;
             double rhythmRating = rhythm.DifficultyValue() * rhythm_skill_multiplier;
+            double readingRating = reading.DifficultyValue() * reading_skill_multiplier;
+            double colourRating = colour.DifficultyValue() * colour_skill_multiplier;
             double staminaRating = stamina.DifficultyValue() * stamina_skill_multiplier;
             double monoStaminaRating = singleColourStamina.DifficultyValue() * stamina_skill_multiplier;
             double monoStaminaFactor = staminaRating == 0 ? 1 : Math.Pow(monoStaminaRating / staminaRating, 5);
 
-            double combinedRating = combinedDifficultyValue(rhythm, colour, stamina);
+            double colourDifficultStrains = colour.CountTopWeightedStrains();
+            double rhythmDifficultStrains = rhythm.CountTopWeightedStrains();
+            double staminaDifficultStrains = stamina.CountTopWeightedStrains();
+
+            // As we don't have pattern integration in osu!taiko, we apply the other two skills relative to rhythm.
+            patternMultiplier = Math.Pow(staminaRating * colourRating, 0.10);
+
+            strainLengthBonus = 1
+                                + Math.Min(Math.Max((staminaDifficultStrains - 1000) / 3700, 0), 0.15)
+                                + Math.Min(Math.Max((staminaRating - 7.0) / 1.0, 0), 0.05);
+
+            double combinedRating = combinedDifficultyValue(rhythm, reading, colour, stamina, isRelax, isConvert);
             double starRating = rescale(combinedRating * 1.4);
 
-            // TODO: This is temporary measure as we don't detect abuse of multiple-input playstyles of converts within the current system.
-            if (beatmap.BeatmapInfo.Ruleset.OnlineID == 0)
-            {
-                starRating *= 0.925;
-                // For maps with low colour variance and high stamina requirement, multiple inputs are more likely to be abused.
-                if (colourRating < 2 && staminaRating > 8)
-                    starRating *= 0.80;
-            }
-
-            HitWindows hitWindows = new TaikoHitWindows();
-            hitWindows.SetDifficulty(beatmap.Difficulty.OverallDifficulty);
-
             TaikoDifficultyAttributes attributes = new TaikoDifficultyAttributes
             {
                 StarRating = starRating,
                 Mods = mods,
+                RhythmDifficulty = rhythmRating,
+                ReadingDifficulty = readingRating,
+                ColourDifficulty = colourRating,
                 StaminaDifficulty = staminaRating,
                 MonoStaminaFactor = monoStaminaFactor,
-                RhythmDifficulty = rhythmRating,
-                ColourDifficulty = colourRating,
-                PeakDifficulty = combinedRating,
-                GreatHitWindow = hitWindows.WindowFor(HitResult.Great) / clockRate,
-                OkHitWindow = hitWindows.WindowFor(HitResult.Ok) / clockRate,
+                RhythmTopStrains = rhythmDifficultStrains,
+                ColourTopStrains = colourDifficultStrains,
+                StaminaTopStrains = staminaDifficultStrains,
                 MaxCombo = beatmap.GetMaxCombo(),
             };
 
             return attributes;
         }
 
-        /// <summary>
-        /// Applies a final re-scaling of the star rating.
-        /// </summary>
-        /// <param name="sr">The raw star rating value before re-scaling.</param>
-        private double rescale(double sr)
-        {
-            if (sr < 0) return sr;
-
-            return 10.43 * Math.Log(sr / 8 + 1);
-        }
-
         /// <summary>
         /// Returns the combined star rating of the beatmap, calculated using peak strains from all sections of the map.
         /// </summary>
@@ -138,22 +154,24 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         /// For each section, the peak strains of all separate skills are combined into a single peak strain for the section.
         /// The resulting partial rating of the beatmap is a weighted sum of the combined peaks (higher peaks are weighted more).
         /// </remarks>
-        private double combinedDifficultyValue(Rhythm rhythm, Colour colour, Stamina stamina)
+        private double combinedDifficultyValue(Rhythm rhythm, Reading reading, Colour colour, Stamina stamina, bool isRelax, bool isConvert)
         {
             List<double> peaks = new List<double>();
 
-            var colourPeaks = colour.GetCurrentStrainPeaks().ToList();
             var rhythmPeaks = rhythm.GetCurrentStrainPeaks().ToList();
+            var readingPeaks = reading.GetCurrentStrainPeaks().ToList();
+            var colourPeaks = colour.GetCurrentStrainPeaks().ToList();
             var staminaPeaks = stamina.GetCurrentStrainPeaks().ToList();
 
             for (int i = 0; i < colourPeaks.Count; i++)
             {
-                double colourPeak = colourPeaks[i] * colour_skill_multiplier;
-                double rhythmPeak = rhythmPeaks[i] * rhythm_skill_multiplier;
-                double staminaPeak = staminaPeaks[i] * stamina_skill_multiplier;
+                double rhythmPeak = rhythmPeaks[i] * rhythm_skill_multiplier * patternMultiplier;
+                double readingPeak = readingPeaks[i] * reading_skill_multiplier;
+                double colourPeak = isRelax ? 0 : colourPeaks[i] * colour_skill_multiplier; // There is no colour difficulty in relax.
+                double staminaPeak = staminaPeaks[i] * stamina_skill_multiplier * strainLengthBonus;
+                staminaPeak /= isConvert || isRelax ? 1.5 : 1.0; // Available finger count is increased by 150%, thus we adjust accordingly.
 
-                double peak = norm(1.5, colourPeak, staminaPeak);
-                peak = norm(2, peak, rhythmPeak);
+                double peak = DifficultyCalculationUtils.Norm(2, DifficultyCalculationUtils.Norm(1.5, colourPeak, staminaPeak), rhythmPeak, readingPeak);
 
                 // Sections with 0 strain are excluded to avoid worst-case time complexity of the following sort (e.g. /b/2351871).
                 // These sections will not contribute to the difficulty.
@@ -174,10 +192,15 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         }
 
         /// <summary>
-        /// Returns the <i>p</i>-norm of an <i>n</i>-dimensional vector.
+        /// Applies a final re-scaling of the star rating.
         /// </summary>
-        /// <param name="p">The value of <i>p</i> to calculate the norm for.</param>
-        /// <param name="values">The coefficients of the vector.</param>
-        private double norm(double p, params double[] values) => Math.Pow(values.Sum(x => Math.Pow(x, p)), 1 / p);
+        /// <param name="sr">The raw star rating value before re-scaling.</param>
+        private static double rescale(double sr)
+        {
+            if (sr < 0)
+                return sr;
+
+            return 10.43 * Math.Log(sr / 8 + 1);
+        }
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index c672b7a1d9..9e049df87c 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -4,12 +4,15 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Scoring;
 using osu.Game.Scoring;
-using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
 {
@@ -21,6 +24,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         private int countMiss;
         private double? estimatedUnstableRate;
 
+        private double clockRate;
+        private double greatHitWindow;
+
         private double effectiveMissCount;
 
         public TaikoPerformanceCalculator()
@@ -36,7 +42,21 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
             countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
             countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
-            estimatedUnstableRate = computeDeviationUpperBound(taikoAttributes) * 10;
+
+            var track = new TrackVirtual(10000);
+            score.Mods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
+            clockRate = track.Rate;
+
+            var difficulty = score.BeatmapInfo!.Difficulty.Clone();
+
+            score.Mods.OfType<IApplicableToDifficulty>().ForEach(m => m.ApplyToDifficulty(difficulty));
+
+            HitWindows hitWindows = new TaikoHitWindows();
+            hitWindows.SetDifficulty(difficulty.OverallDifficulty);
+
+            greatHitWindow = hitWindows.WindowFor(HitResult.Great) / clockRate;
+
+            estimatedUnstableRate = computeDeviationUpperBound() * 10;
 
             // The effectiveMissCount is calculated by gaining a ratio for totalSuccessfulHits and increasing the miss penalty for shorter object counts lower than 1000.
             if (totalSuccessfulHits > 0)
@@ -73,7 +93,10 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
         private double computeDifficultyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
         {
-            double difficultyValue = Math.Pow(5 * Math.Max(1.0, attributes.StarRating / 0.115) - 4.0, 2.25) / 1150.0;
+            double baseDifficulty = 5 * Math.Max(1.0, attributes.StarRating / 0.110) - 4.0;
+            double difficultyValue = Math.Min(Math.Pow(baseDifficulty, 3) / 69052.51, Math.Pow(baseDifficulty, 2.25) / 1250.0);
+
+            difficultyValue *= 1 + 0.10 * Math.Max(0, attributes.StarRating - 10);
 
             double lengthBonus = 1 + 0.1 * Math.Min(1.0, totalHits / 1500.0);
             difficultyValue *= lengthBonus;
@@ -86,9 +109,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             if (score.Mods.Any(m => m is ModHidden))
                 difficultyValue *= 1.025;
 
-            if (score.Mods.Any(m => m is ModHardRock))
-                difficultyValue *= 1.10;
-
             if (score.Mods.Any(m => m is ModFlashlight<TaikoHitObject>))
                 difficultyValue *= Math.Max(1, 1.050 - Math.Min(attributes.MonoStaminaFactor / 50, 1) * lengthBonus);
 
@@ -97,14 +117,14 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
             // Scale accuracy more harshly on nearly-completely mono (single coloured) speed maps.
             double accScalingExponent = 2 + attributes.MonoStaminaFactor;
-            double accScalingShift = 300 - 100 * attributes.MonoStaminaFactor;
+            double accScalingShift = 500 - 100 * (attributes.MonoStaminaFactor * 3);
 
-            return difficultyValue * Math.Pow(SpecialFunctions.Erf(accScalingShift / (Math.Sqrt(2) * estimatedUnstableRate.Value)), accScalingExponent);
+            return difficultyValue * Math.Pow(DifficultyCalculationUtils.Erf(accScalingShift / (Math.Sqrt(2) * estimatedUnstableRate.Value)), accScalingExponent);
         }
 
         private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes, bool isConvert)
         {
-            if (attributes.GreatHitWindow <= 0 || estimatedUnstableRate == null)
+            if (greatHitWindow <= 0 || estimatedUnstableRate == null)
                 return 0;
 
             double accuracyValue = Math.Pow(70 / estimatedUnstableRate.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
@@ -123,58 +143,23 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         /// and the hit judgements, assuming the player's mean hit error is 0. The estimation is consistent in that
         /// two SS scores on the same map with the same settings will always return the same deviation.
         /// </summary>
-        private double? computeDeviationUpperBound(TaikoDifficultyAttributes attributes)
+        private double? computeDeviationUpperBound()
         {
-            if (totalSuccessfulHits == 0 || attributes.GreatHitWindow <= 0)
+            if (countGreat == 0 || greatHitWindow <= 0)
                 return null;
 
-            double h300 = attributes.GreatHitWindow;
-            double h100 = attributes.OkHitWindow;
-
             const double z = 2.32634787404; // 99% critical value for the normal distribution (one-tailed).
 
-            // The upper bound on deviation, calculated with the ratio of 300s to objects, and the great hit window.
-            double? calcDeviationGreatWindow()
-            {
-                if (countGreat == 0) return null;
+            double n = totalHits;
 
-                double n = totalHits;
+            // Proportion of greats hit.
+            double p = countGreat / n;
 
-                // Proportion of greats hit.
-                double p = countGreat / n;
+            // We can be 99% confident that p is at least this value.
+            double pLowerBound = (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4);
 
-                // We can be 99% confident that p is at least this value.
-                double pLowerBound = (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4);
-
-                // We can be 99% confident that the deviation is not higher than:
-                return h300 / (Math.Sqrt(2) * SpecialFunctions.ErfInv(pLowerBound));
-            }
-
-            // The upper bound on deviation, calculated with the ratio of 300s + 100s to objects, and the good hit window.
-            // This will return a lower value than the first method when the number of 100s is high, but the miss count is low.
-            double? calcDeviationGoodWindow()
-            {
-                if (totalSuccessfulHits == 0) return null;
-
-                double n = totalHits;
-
-                // Proportion of greats + goods hit.
-                double p = totalSuccessfulHits / n;
-
-                // We can be 99% confident that p is at least this value.
-                double pLowerBound = (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4);
-
-                // We can be 99% confident that the deviation is not higher than:
-                return h100 / (Math.Sqrt(2) * SpecialFunctions.ErfInv(pLowerBound));
-            }
-
-            double? deviationGreatWindow = calcDeviationGreatWindow();
-            double? deviationGoodWindow = calcDeviationGoodWindow();
-
-            if (deviationGreatWindow is null)
-                return deviationGoodWindow;
-
-            return Math.Min(deviationGreatWindow.Value, deviationGoodWindow!.Value);
+            // We can be 99% confident that the deviation is not higher than:
+            return greatHitWindow / (Math.Sqrt(2) * DifficultyCalculationUtils.ErfInv(pLowerBound));
         }
 
         private int totalHits => countGreat + countOk + countMeh + countMiss;
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Utils/IHasInterval.cs b/osu.Game.Rulesets.Taiko/Difficulty/Utils/IHasInterval.cs
new file mode 100644
index 0000000000..a42940180c
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Utils/IHasInterval.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.
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Utils
+{
+    /// <summary>
+    /// The interface for objects that provide an interval value.
+    /// </summary>
+    public interface IHasInterval
+    {
+        /// <summary>
+        /// The interval – ie delta time – between this object and a known previous object.
+        /// </summary>
+        double Interval { get; }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/Utils/IntervalGroupingUtils.cs b/osu.Game.Rulesets.Taiko/Difficulty/Utils/IntervalGroupingUtils.cs
new file mode 100644
index 0000000000..5ab58ad4f3
--- /dev/null
+++ b/osu.Game.Rulesets.Taiko/Difficulty/Utils/IntervalGroupingUtils.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 System.Collections.Generic;
+using osu.Framework.Utils;
+
+namespace osu.Game.Rulesets.Taiko.Difficulty.Utils
+{
+    public static class IntervalGroupingUtils
+    {
+        public static List<List<T>> GroupByInterval<T>(IReadOnlyList<T> objects) where T : IHasInterval
+        {
+            var groups = new List<List<T>>();
+
+            int i = 0;
+            while (i < objects.Count)
+                groups.Add(createNextGroup(objects, ref i));
+
+            return groups;
+        }
+
+        private static List<T> createNextGroup<T>(IReadOnlyList<T> objects, ref int i) where T : IHasInterval
+        {
+            const double margin_of_error = 5;
+
+            // This never compares the first two elements in the group.
+            // This sounds wrong but is apparently "as intended" (https://github.com/ppy/osu/pull/31636#discussion_r1942673329)
+            var groupedObjects = new List<T> { objects[i] };
+            i++;
+
+            for (; i < objects.Count - 1; i++)
+            {
+                if (!Precision.AlmostEquals(objects[i].Interval, objects[i + 1].Interval, margin_of_error))
+                {
+                    // When an interval change occurs, include the object with the differing interval in the case it increased
+                    // See https://github.com/ppy/osu/pull/31636#discussion_r1942368372 for rationale.
+                    if (objects[i + 1].Interval > objects[i].Interval + margin_of_error)
+                    {
+                        groupedObjects.Add(objects[i]);
+                        i++;
+                    }
+
+                    return groupedObjects;
+                }
+
+                // No interval change occurred
+                groupedObjects.Add(objects[i]);
+            }
+
+            // Check if the last two objects in the object form a "flat" rhythm pattern within the specified margin of error.
+            // If true, add the current object to the group and increment the index to process the next object.
+            if (objects.Count > 2 && i < objects.Count && Precision.AlmostEquals(objects[^1].Interval, objects[^2].Interval, margin_of_error))
+            {
+                groupedObjects.Add(objects[i]);
+                i++;
+            }
+
+            return groupedObjects;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwellTick.cs b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwellTick.cs
index 04dd01e066..88554ba257 100644
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwellTick.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwellTick.cs
@@ -4,9 +4,7 @@
 #nullable disable
 
 using JetBrains.Annotations;
-using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
-using osu.Game.Rulesets.Taiko.Skinning.Default;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
@@ -25,8 +23,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         {
         }
 
-        protected override void UpdateInitialTransforms() => this.FadeOut();
-
         public void TriggerResult(bool hit)
         {
             HitObject.StartTime = Time.Current;
@@ -43,7 +39,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         public override bool OnPressed(KeyBindingPressEvent<TaikoAction> e) => false;
 
-        protected override SkinnableDrawable CreateMainPiece() => new SkinnableDrawable(new TaikoSkinComponentLookup(TaikoSkinComponents.DrumRollTick),
-            _ => new TickPiece());
+        protected override SkinnableDrawable CreateMainPiece() => null;
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
index 0cf9651965..520ac2ba80 100644
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs
@@ -154,9 +154,13 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             if (MainPiece != null)
                 Content.Remove(MainPiece, true);
 
-            Content.Add(MainPiece = CreateMainPiece());
+            MainPiece = CreateMainPiece();
+
+            if (MainPiece != null)
+                Content.Add(MainPiece);
         }
 
+        [CanBeNull]
         protected abstract SkinnableDrawable CreateMainPiece();
     }
 }
diff --git a/osu.Game.Rulesets.Taiko/UI/TaikoPlayfieldAdjustmentContainer.cs b/osu.Game.Rulesets.Taiko/UI/TaikoPlayfieldAdjustmentContainer.cs
index 6a9e5789de..9f821ee93d 100644
--- a/osu.Game.Rulesets.Taiko/UI/TaikoPlayfieldAdjustmentContainer.cs
+++ b/osu.Game.Rulesets.Taiko/UI/TaikoPlayfieldAdjustmentContainer.cs
@@ -2,8 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Taiko.Beatmaps;
@@ -21,9 +19,6 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         public readonly IBindable<bool> LockPlayfieldAspectRange = new BindableBool(true);
 
-        [Resolved]
-        private OsuGame? osuGame { get; set; }
-
         public TaikoPlayfieldAdjustmentContainer()
         {
             RelativeSizeAxes = Axes.X;
@@ -60,19 +55,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             // Limit the maximum relative height of the playfield to one-third of available area to avoid it masking out on extreme resolutions.
             relativeHeight = Math.Min(relativeHeight, 1f / 3f);
 
-            Scale = new Vector2(Math.Max((Parent!.ChildSize.Y / 768f) * (relativeHeight / base_relative_height), 1f));
-
-            // on mobile platforms where the base aspect ratio is wider, the taiko playfield
-            // needs to be scaled down to remain playable.
-            if (RuntimeInfo.IsMobile && osuGame != null)
-            {
-                const float base_aspect_ratio = 1024f / 768f;
-                float gameAspectRatio = osuGame.ScalingContainerTargetDrawSize.X / osuGame.ScalingContainerTargetDrawSize.Y;
-                // this magic scale is unexplainable, but required so the playfield doesn't become too zoomed out as the aspect ratio increases.
-                const float magic_scale = 1.25f;
-                Scale *= magic_scale * new Vector2(base_aspect_ratio / gameAspectRatio);
-            }
-
+            Scale = new Vector2(Parent!.ChildSize.Y / 768f * (relativeHeight / base_relative_height));
             Width = 1 / Scale.X;
         }
 
diff --git a/osu.Game.Tests/Beatmaps/BeatmapExtensionsTest.cs b/osu.Game.Tests/Beatmaps/BeatmapExtensionsTest.cs
new file mode 100644
index 0000000000..1dda2e314d
--- /dev/null
+++ b/osu.Game.Tests/Beatmaps/BeatmapExtensionsTest.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 NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Tests.Beatmaps
+{
+    public class BeatmapExtensionsTest
+    {
+        [Test]
+        public void TestLengthCalculations()
+        {
+            var beatmap = new Beatmap
+            {
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 5_000 },
+                    new HitCircle { StartTime = 300_000 },
+                    new Spinner { StartTime = 280_000, Duration = 40_000 }
+                },
+                Breaks =
+                {
+                    new BreakPeriod(50_000, 75_000),
+                    new BreakPeriod(100_000, 150_000),
+                }
+            };
+
+            Assert.That(beatmap.CalculatePlayableBounds(), Is.EqualTo((5_000, 320_000)));
+            Assert.That(beatmap.CalculatePlayableLength(), Is.EqualTo(315_000)); // 320_000 - 5_000
+            Assert.That(beatmap.CalculateDrainLength(), Is.EqualTo(240_000)); // 315_000 - (25_000 + 50_000) = 315_000 - 75_000
+        }
+
+        [Test]
+        public void TestDrainLengthCannotGoNegative()
+        {
+            var beatmap = new Beatmap
+            {
+                HitObjects =
+                {
+                    new HitCircle { StartTime = 5_000 },
+                    new HitCircle { StartTime = 300_000 },
+                    new Spinner { StartTime = 280_000, Duration = 40_000 }
+                },
+                Breaks =
+                {
+                    new BreakPeriod(0, 350_000),
+                }
+            };
+
+            Assert.That(beatmap.CalculatePlayableBounds(), Is.EqualTo((5_000, 320_000)));
+            Assert.That(beatmap.CalculatePlayableLength(), Is.EqualTo(315_000)); // 320_000 - 5_000
+            Assert.That(beatmap.CalculateDrainLength(), Is.EqualTo(0)); // break period encompasses entire beatmap
+        }
+    }
+}
diff --git a/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs b/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs
index adb1755c11..9747b654ae 100644
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs
@@ -404,6 +404,35 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
+        [Test]
+        public void TestComboColourCountIsLimitedToEight()
+        {
+            var decoder = new LegacySkinDecoder();
+
+            using (var resStream = TestResources.OpenResource("too-many-combo-colours.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var comboColors = decoder.Decode(stream).ComboColours;
+
+                Debug.Assert(comboColors != null);
+
+                Color4[] expectedColors =
+                {
+                    new Color4(142, 199, 255, 255),
+                    new Color4(255, 128, 128, 255),
+                    new Color4(128, 255, 255, 255),
+                    new Color4(128, 255, 128, 255),
+                    new Color4(255, 187, 255, 255),
+                    new Color4(255, 177, 140, 255),
+                    new Color4(100, 100, 100, 255),
+                    new Color4(142, 199, 255, 255),
+                };
+                Assert.AreEqual(expectedColors.Length, comboColors.Count);
+                for (int i = 0; i < expectedColors.Length; i++)
+                    Assert.AreEqual(expectedColors[i], comboColors[i]);
+            }
+        }
+
         [Test]
         public void TestGetLastObjectTime()
         {
diff --git a/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs b/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs
index c8a09786ec..caebf52026 100644
--- a/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs
@@ -28,6 +28,7 @@ using osu.Game.Skinning;
 using osu.Game.Storyboards;
 using osu.Game.Tests.Resources;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Tests.Beatmaps.Formats
 {
@@ -184,6 +185,32 @@ namespace osu.Game.Tests.Beatmaps.Formats
             Assert.That(decodedSlider.Path.ControlPoints.Count, Is.EqualTo(5));
         }
 
+        [Test]
+        public void TestOnlyEightComboColoursEncoded()
+        {
+            var beatmapSkin = new LegacyBeatmapSkin(new BeatmapInfo(), null)
+            {
+                Configuration =
+                {
+                    CustomComboColours =
+                    {
+                        new Color4(1, 1, 1, 255),
+                        new Color4(2, 2, 2, 255),
+                        new Color4(3, 3, 3, 255),
+                        new Color4(4, 4, 4, 255),
+                        new Color4(5, 5, 5, 255),
+                        new Color4(6, 6, 6, 255),
+                        new Color4(7, 7, 7, 255),
+                        new Color4(8, 8, 8, 255),
+                        new Color4(9, 9, 9, 255),
+                    }
+                }
+            };
+
+            var decodedAfterEncode = decodeFromLegacy(encodeToLegacy((new Beatmap(), beatmapSkin)), string.Empty);
+            Assert.That(decodedAfterEncode.skin.Configuration.CustomComboColours, Has.Count.EqualTo(8));
+        }
+
         private bool areComboColoursEqual(IHasComboColours a, IHasComboColours b)
         {
             // equal to null, no need to SequenceEqual
@@ -212,6 +239,8 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 var beatmap = new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(reader);
                 var beatmapSkin = new TestLegacySkin(beatmaps_resource_store, name);
+                stream.Seek(0, SeekOrigin.Begin);
+                beatmapSkin.Configuration = new LegacySkinDecoder().Decode(reader);
                 return (convert(beatmap), beatmapSkin);
             }
         }
diff --git a/osu.Game.Tests/NonVisual/Multiplayer/StatefulMultiplayerClientTest.cs b/osu.Game.Tests/NonVisual/Multiplayer/StatefulMultiplayerClientTest.cs
index 559db16751..8364e58bdc 100644
--- a/osu.Game.Tests/NonVisual/Multiplayer/StatefulMultiplayerClientTest.cs
+++ b/osu.Game.Tests/NonVisual/Multiplayer/StatefulMultiplayerClientTest.cs
@@ -6,9 +6,9 @@ using Humanizer;
 using NUnit.Framework;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Testing;
+using osu.Game.Extensions;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
-using osu.Game.Online.Rooms;
 using osu.Game.Tests.Visual.Multiplayer;
 
 namespace osu.Game.Tests.NonVisual.Multiplayer
@@ -16,6 +16,13 @@ namespace osu.Game.Tests.NonVisual.Multiplayer
     [HeadlessTest]
     public partial class StatefulMultiplayerClientTest : MultiplayerTestScene
     {
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom()));
+            WaitForJoined();
+        }
+
         [Test]
         public void TestUserAddedOnJoin()
         {
@@ -72,10 +79,6 @@ namespace osu.Game.Tests.NonVisual.Multiplayer
 
             AddStep("create room initially in gameplay", () =>
             {
-                var newRoom = new Room();
-                newRoom.CopyFrom(SelectedRoom.Value!);
-
-                newRoom.RoomID = null;
                 MultiplayerClient.RoomSetupAction = room =>
                 {
                     room.State = MultiplayerRoomState.Playing;
@@ -86,13 +89,32 @@ namespace osu.Game.Tests.NonVisual.Multiplayer
                     });
                 };
 
-                RoomManager.CreateRoom(newRoom);
+                MultiplayerClient.JoinRoom(MultiplayerClient.ServerSideRooms.Single()).ConfigureAwait(false);
             });
 
             AddUntilStep("wait for room join", () => RoomJoined);
             checkPlayingUserCount(1);
         }
 
+        [Test]
+        public void TestJoinRoomWithManyUsers()
+        {
+            AddStep("leave room", () => MultiplayerClient.LeaveRoom());
+            AddUntilStep("wait for room part", () => !RoomJoined);
+
+            AddStep("create room with many users", () =>
+            {
+                MultiplayerClient.RoomSetupAction = room =>
+                {
+                    room.Users.AddRange(Enumerable.Range(PLAYER_1_ID, 100).Select(id => new MultiplayerRoomUser(id)));
+                };
+
+                MultiplayerClient.JoinRoom(MultiplayerClient.ServerSideRooms.Single()).ConfigureAwait(false);
+            });
+
+            AddUntilStep("wait for room join", () => RoomJoined);
+        }
+
         private void checkPlayingUserCount(int expectedCount)
             => AddAssert($"{"user".ToQuantity(expectedCount)} playing", () => MultiplayerClient.CurrentMatchPlayingUserIds.Count == expectedCount);
 
diff --git a/osu.Game.Tests/Resources/too-many-combo-colours.osu b/osu.Game.Tests/Resources/too-many-combo-colours.osu
new file mode 100644
index 0000000000..477e362a6d
--- /dev/null
+++ b/osu.Game.Tests/Resources/too-many-combo-colours.osu
@@ -0,0 +1,73 @@
+osu file format v14
+
+[General]
+AudioFilename: 03. Renatus - Soleily 192kbps.mp3
+AudioLeadIn: 0
+PreviewTime: 164471
+Countdown: 0
+SampleSet: Soft
+StackLeniency: 0.7
+Mode: 0
+LetterboxInBreaks: 0
+WidescreenStoryboard: 0
+
+[Editor]
+Bookmarks: 11505,22054,32604,43153,53703,64252,74802,85351,95901,106450,116999,119637,130186,140735,151285,161834,164471,175020,185570,196119,206669,209306
+DistanceSpacing: 1.8
+BeatDivisor: 4
+GridSize: 4
+TimelineZoom: 2
+
+[Metadata]
+Title:Renatus
+TitleUnicode:Renatus
+Artist:Soleily
+ArtistUnicode:Soleily
+Creator:Gamu
+Version:Insane
+Source:
+Tags:MBC7 Unisphere 地球ヤバイEP Chikyu Yabai
+BeatmapID:557821
+BeatmapSetID:241526
+
+[Difficulty]
+HPDrainRate:6.5
+CircleSize:4
+OverallDifficulty:8
+ApproachRate:9
+SliderMultiplier:1.8
+SliderTickRate:2
+
+[Events]
+//Background and Video events
+0,0,"machinetop_background.jpg",0,0
+//Break Periods
+2,122474,140135
+//Storyboard Layer 0 (Background)
+//Storyboard Layer 1 (Fail)
+//Storyboard Layer 2 (Pass)
+//Storyboard Layer 3 (Foreground)
+//Storyboard Sound Samples
+
+[TimingPoints]
+956,329.67032967033,4,2,0,60,1,0
+
+
+[Colours]
+Combo1:142,199,255
+Combo2:255,128,128
+Combo3:128,255,255
+Combo4:128,255,128
+Combo5:255,187,255
+Combo6:255,177,140
+Combo7:100,100,100
+Combo8:142,199,255
+Combo9:255,128,128
+Combo10:128,255,255
+Combo11:128,255,128
+Combo12:255,187,255
+Combo13:255,177,140
+Combo14:100,100,100
+
+[HitObjects]
+192,168,956,6,0,P|184:128|200:80,1,90,4|0,1:2|0:0,0:0:0:0:
diff --git a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs
index 0742ed5eb9..c974a852f3 100644
--- a/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs
+++ b/osu.Game.Tests/Visual/DailyChallenge/TestSceneDailyChallenge.cs
@@ -6,6 +6,8 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Online.Metadata;
@@ -13,9 +15,11 @@ using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Screens.SelectV2.Leaderboards;
 using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual.Metadata;
 using osu.Game.Tests.Visual.OnlinePlay;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.DailyChallenge
 {
@@ -57,6 +61,39 @@ namespace osu.Game.Tests.Visual.DailyChallenge
             AddStep("push screen", () => LoadScreen(new Screens.OnlinePlay.DailyChallenge.DailyChallenge(room)));
         }
 
+        [Test]
+        public void TestUseTheseModsUnavailableIfNoFreeMods()
+        {
+            var room = new Room
+            {
+                RoomID = 1234,
+                Name = "Daily Challenge: June 4, 2024",
+                Playlist =
+                [
+                    new PlaylistItem(TestResources.CreateTestBeatmapSetInfo().Beatmaps.First())
+                    {
+                        RequiredMods = [new APIMod(new OsuModTraceable())],
+                        AllowedMods = []
+                    }
+                ],
+                EndDate = DateTimeOffset.Now.AddHours(12),
+                Category = RoomCategory.DailyChallenge
+            };
+
+            AddStep("add room", () => API.Perform(new CreateRoomRequest(room)));
+            Screens.OnlinePlay.DailyChallenge.DailyChallenge screen = null!;
+            AddStep("push screen", () => LoadScreen(screen = new Screens.OnlinePlay.DailyChallenge.DailyChallenge(room)));
+            AddUntilStep("wait for pushed", () => screen.IsCurrentScreen());
+            AddStep("force transforms to finish", () => FinishTransforms(true));
+            AddStep("right click second score", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<LeaderboardScoreV2>().ElementAt(1));
+                InputManager.Click(MouseButton.Right);
+            });
+            AddAssert("use these mods not present",
+                () => this.ChildrenOfType<OsuContextMenu>().All(m => m.Items.All(item => item.Text.Value != "Use these mods")));
+        }
+
         [Test]
         public void TestNotifications()
         {
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs b/osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs
index b7990b64c1..2758954907 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs
@@ -94,6 +94,8 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("release", () => InputManager.ReleaseButton(MouseButton.Left));
 
             AddAssert("new beatmap not persisted", () => beatmapManager.QueryBeatmapSet(s => s.ID == editorBeatmap.BeatmapInfo.BeatmapSet.AsNonNull().ID)?.Value.DeletePending == true);
+
+            AddUntilStep("wait for default beatmap", () => Editor.Beatmap.Value is DummyWorkingBeatmap);
         }
 
         [Test]
@@ -171,6 +173,8 @@ namespace osu.Game.Tests.Visual.Editing
                 return difficultyName != null && difficultyName != firstDifficultyName;
             });
 
+            ensureEditorLoaded();
+
             AddAssert("created difficulty has timing point", () =>
             {
                 var timingPoint = EditorBeatmap.ControlPointInfo.TimingPoints.Single();
@@ -215,6 +219,8 @@ namespace osu.Game.Tests.Visual.Editing
                 return difficultyName != null && difficultyName != previousDifficultyName;
             });
 
+            ensureEditorLoaded();
+
             AddStep("set unique difficulty name", () => EditorBeatmap.BeatmapInfo.DifficultyName = previousDifficultyName = Guid.NewGuid().ToString());
             AddStep("add timing point", () => EditorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = 1000 }));
             AddStep("add effect points", () =>
@@ -239,6 +245,8 @@ namespace osu.Game.Tests.Visual.Editing
                 return difficultyName != null && difficultyName != previousDifficultyName;
             });
 
+            ensureEditorLoaded();
+
             AddAssert("created difficulty has timing point", () =>
             {
                 var timingPoint = EditorBeatmap.ControlPointInfo.TimingPoints.Single();
@@ -287,6 +295,8 @@ namespace osu.Game.Tests.Visual.Editing
                 return difficultyName != null && difficultyName != firstDifficultyName;
             });
 
+            ensureEditorLoaded();
+
             AddAssert("created difficulty has timing point", () =>
             {
                 var timingPoint = EditorBeatmap.ControlPointInfo.TimingPoints.Single();
@@ -367,6 +377,8 @@ namespace osu.Game.Tests.Visual.Editing
                 return difficultyName != null && difficultyName != originalDifficultyName;
             });
 
+            ensureEditorLoaded();
+
             AddAssert("created difficulty has copy suffix in name", () => EditorBeatmap.BeatmapInfo.DifficultyName == copyDifficultyName);
             AddAssert("created difficulty has timing point", () =>
             {
@@ -377,7 +389,9 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("approach rate correctly copied", () => EditorBeatmap.Difficulty.ApproachRate == 4);
             AddAssert("combo colours correctly copied", () => EditorBeatmap.BeatmapSkin.AsNonNull().ComboColours.Count == 2);
 
+            ensureEditorLoaded();
             AddAssert("status is modified", () => EditorBeatmap.BeatmapInfo.Status == BeatmapOnlineStatus.LocallyModified);
+
             AddAssert("online ID not copied", () => EditorBeatmap.BeatmapInfo.OnlineID == -1);
 
             AddStep("save beatmap", () => Editor.Save());
@@ -440,6 +454,8 @@ namespace osu.Game.Tests.Visual.Editing
                 return difficultyName != null && difficultyName != originalDifficultyName;
             });
 
+            ensureEditorLoaded();
+
             AddStep("save without changes", () => Editor.Save());
 
             AddAssert("collection still points to old beatmap", () => !collection.BeatmapMD5Hashes.Contains(EditorBeatmap.BeatmapInfo.MD5Hash)
@@ -477,6 +493,9 @@ namespace osu.Game.Tests.Visual.Editing
                 string? difficultyName = Editor.ChildrenOfType<EditorBeatmap>().SingleOrDefault()?.BeatmapInfo.DifficultyName;
                 return difficultyName != null && difficultyName != "New Difficulty";
             });
+
+            ensureEditorLoaded();
+
             AddAssert("new difficulty has correct name", () => EditorBeatmap.BeatmapInfo.DifficultyName == "New Difficulty (1)");
             AddAssert("new difficulty persisted", () =>
             {
@@ -514,6 +533,8 @@ namespace osu.Game.Tests.Visual.Editing
                 return difficultyName != null && difficultyName != duplicate_difficulty_name;
             });
 
+            ensureEditorLoaded();
+
             AddStep("set difficulty name", () => EditorBeatmap.BeatmapInfo.DifficultyName = duplicate_difficulty_name);
             AddStep("try to save beatmap", () => Editor.Save());
             AddAssert("beatmap set not corrupted", () =>
@@ -540,6 +561,8 @@ namespace osu.Game.Tests.Visual.Editing
                 return set != null && set.PerformRead(s => s.Beatmaps.Count == 1 && s.Files.Count == 1);
             });
 
+            ensureEditorLoaded();
+
             AddStep("create new difficulty", () => Editor.CreateNewDifficulty(new CatchRuleset().RulesetInfo));
 
             AddUntilStep("wait for created", () =>
@@ -547,7 +570,8 @@ namespace osu.Game.Tests.Visual.Editing
                 string? difficultyName = Editor.ChildrenOfType<EditorBeatmap>().SingleOrDefault()?.BeatmapInfo.DifficultyName;
                 return difficultyName != null && difficultyName != duplicate_difficulty_name;
             });
-            AddUntilStep("wait for editor load", () => Editor.IsLoaded && DialogOverlay.IsLoaded);
+
+            ensureEditorLoaded();
 
             AddStep("add hitobjects", () => EditorBeatmap.AddRange(new[]
             {
@@ -584,6 +608,9 @@ namespace osu.Game.Tests.Visual.Editing
                 string? difficultyName = Editor.ChildrenOfType<EditorBeatmap>().SingleOrDefault()?.BeatmapInfo.DifficultyName;
                 return difficultyName != null && difficultyName == "New Difficulty";
             });
+
+            ensureEditorLoaded();
+
             AddAssert("new difficulty persisted", () =>
             {
                 var set = beatmapManager.QueryBeatmapSet(s => s.ID == setId);
@@ -610,6 +637,9 @@ namespace osu.Game.Tests.Visual.Editing
                 string? difficultyName = Editor.ChildrenOfType<EditorBeatmap>().SingleOrDefault()?.BeatmapInfo.DifficultyName;
                 return difficultyName != null && difficultyName == "New Difficulty (1)";
             });
+
+            ensureEditorLoaded();
+
             AddAssert("new difficulty persisted", () =>
             {
                 var set = beatmapManager.QueryBeatmapSet(s => s.ID == setId);
@@ -735,6 +765,8 @@ namespace osu.Game.Tests.Visual.Editing
             AddAssert("other audio not removed", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "audio (1).mp3"));
         }
 
+        private void ensureEditorLoaded() => AddUntilStep("wait for editor load", () => Editor.IsLoaded && DialogOverlay.IsLoaded);
+
         private void createNewDifficulty()
         {
             string? currentDifficulty = null;
@@ -748,13 +780,14 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddUntilStep("wait for dialog", () => DialogOverlay.CurrentDialog is CreateNewDifficultyDialog);
             AddStep("confirm creation with no objects", () => DialogOverlay.CurrentDialog!.PerformOkAction());
+
             AddUntilStep("wait for created", () =>
             {
                 string? difficultyName = Editor.ChildrenOfType<EditorBeatmap>().SingleOrDefault()?.BeatmapInfo.DifficultyName;
                 return difficultyName != null && difficultyName != currentDifficulty;
             });
+            ensureEditorLoaded();
 
-            AddUntilStep("wait for editor load", () => Editor.IsLoaded);
             AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
             AddUntilStep("wait for load", () => Editor.ChildrenOfType<SetupScreen>().Any());
         }
@@ -765,7 +798,7 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep($"switch to difficulty #{index + 1}", () =>
                 Editor.SwitchToDifficulty(Beatmap.Value.BeatmapSetInfo.Beatmaps.ElementAt(index)));
 
-            AddUntilStep("wait for editor load", () => Editor.IsLoaded);
+            ensureEditorLoaded();
             AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
             AddUntilStep("wait for load", () => Editor.ChildrenOfType<SetupScreen>().Any());
         }
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneZoomableScrollContainer.cs b/osu.Game.Tests/Visual/Editing/TestSceneZoomableScrollContainer.cs
index 1c8a18e131..2c84e76b2e 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneZoomableScrollContainer.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneZoomableScrollContainer.cs
@@ -128,12 +128,12 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("Press alt down", () => InputManager.PressKey(Key.AltLeft));
             AddStep("Scroll by 3", () => InputManager.ScrollBy(new Vector2(0, 3)));
             AddAssert("Box not at 0", () => !Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
-            AddAssert("Box 1/4 at 1/4", () => Precision.AlmostEquals(boxQuad.TopLeft.X + 0.25f * boxQuad.Size.X, scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X));
+            AddAssert("Box 1/2 at 1/2", () => Precision.AlmostEquals(boxQuad.TopLeft.X + 0.5f * boxQuad.Size.X, scrollQuad.TopLeft.X + 0.5f * scrollQuad.Size.X));
 
             // Scroll out at 0.25
             AddStep("Scroll by -3", () => InputManager.ScrollBy(new Vector2(0, -3)));
             AddAssert("Box at 0", () => Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
-            AddAssert("Box 1/4 at 1/4", () => Precision.AlmostEquals(boxQuad.TopLeft.X + 0.25f * boxQuad.Size.X, scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X));
+            AddAssert("Box 1/2 at 1/2", () => Precision.AlmostEquals(boxQuad.TopLeft.X + 0.5f * boxQuad.Size.X, scrollQuad.TopLeft.X + 0.5f * scrollQuad.Size.X));
             AddStep("Release alt", () => InputManager.ReleaseKey(Key.AltLeft));
         }
 
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorList.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorList.cs
index 66c465cbed..1445e872b5 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorList.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorList.cs
@@ -32,7 +32,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             Bindable<LocalUserPlayingState> playingState = new Bindable<LocalUserPlayingState>();
             GameplayState gameplayState = new GameplayState(new Beatmap(), new OsuRuleset(), healthProcessor: new OsuHealthProcessor(0), localUserPlayingState: playingState);
             TestSpectatorClient spectatorClient = new TestSpectatorClient();
-            TestMultiplayerClient multiplayerClient = new TestMultiplayerClient(new TestMultiplayerRoomManager(new TestRoomRequestsHandler()));
+            TestMultiplayerClient multiplayerClient = new TestMultiplayerClient(new TestRoomRequestsHandler());
 
             AddStep("create spectator list", () =>
             {
@@ -75,8 +75,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddRepeatStep("remove random user", () => ((ISpectatorClient)spectatorClient).UserEndedWatching(
                 spectatorClient.WatchingUsers[RNG.Next(spectatorClient.WatchingUsers.Count)].OnlineID), 5);
 
-            AddStep("change font to venera", () => list.Font.Value = Typeface.Venera);
-            AddStep("change font to torus", () => list.Font.Value = Typeface.Torus);
+            AddStep("change font to venera", () => list.HeaderFont.Value = Typeface.Venera);
+            AddStep("change font to torus", () => list.HeaderFont.Value = Typeface.Torus);
             AddStep("change header colour", () => list.HeaderColour.Value = new Colour4(RNG.NextSingle(), RNG.NextSingle(), RNG.NextSingle(), 1));
 
             AddStep("enter break", () => playingState.Value = LocalUserPlayingState.Break);
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableLoungeRoom.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableLoungeRoom.cs
index c5fb52461a..459a90d096 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableLoungeRoom.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableLoungeRoom.cs
@@ -38,7 +38,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [BackgroundDependencyLoader]
         private void load()
         {
-            var mockLounge = new Mock<LoungeSubScreen>();
+            var mockLounge = new Mock<IOnlinePlayLounge>();
             mockLounge
                 .Setup(l => l.Join(It.IsAny<Room>(), It.IsAny<string>(), It.IsAny<Action<Room>>(), It.IsAny<Action<string>>()))
                 .Callback<Room, string, Action<Room>, Action<string>>((_, _, _, d) =>
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomParticipantsList.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomParticipantsList.cs
index c1662bf944..2fd1268c8a 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomParticipantsList.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomParticipantsList.cs
@@ -15,6 +15,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
     public partial class TestSceneDrawableRoomParticipantsList : OnlinePlayTestScene
     {
+        private Room room = null!;
         private DrawableRoomParticipantsList list = null!;
 
         public override void SetUpSteps()
@@ -23,7 +24,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create list", () =>
             {
-                SelectedRoom.Value = new Room
+                room = new Room
                 {
                     Name = "test room",
                     Host = new APIUser
@@ -33,7 +34,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     }
                 };
 
-                Child = list = new DrawableRoomParticipantsList(SelectedRoom.Value)
+                Child = list = new DrawableRoomParticipantsList(room)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -119,7 +120,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("4 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 4);
             AddAssert("46 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 46);
 
-            AddStep("remove from end", () => removeUserAt(SelectedRoom.Value!.RecentParticipants.Count - 1));
+            AddStep("remove from end", () => removeUserAt(room.RecentParticipants.Count - 1));
             AddAssert("4 circles displayed", () => list.ChildrenOfType<UpdateableAvatar>().Count() == 4);
             AddAssert("45 hidden users", () => list.ChildrenOfType<DrawableRoomParticipantsList.HiddenUserCount>().Single().Count == 45);
 
@@ -138,18 +139,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private void addUser(int id)
         {
-            SelectedRoom.Value!.RecentParticipants = SelectedRoom.Value!.RecentParticipants.Append(new APIUser
+            room.RecentParticipants = room.RecentParticipants.Append(new APIUser
             {
                 Id = id,
                 Username = $"User {id}"
             }).ToArray();
-            SelectedRoom.Value!.ParticipantCount++;
+            room.ParticipantCount++;
         }
 
         private void removeUserAt(int index)
         {
-            SelectedRoom.Value!.RecentParticipants = SelectedRoom.Value!.RecentParticipants.Where(u => !u.Equals(SelectedRoom.Value!.RecentParticipants[index])).ToArray();
-            SelectedRoom.Value!.ParticipantCount--;
+            room.RecentParticipants = room.RecentParticipants.Where(u => !u.Equals(room.RecentParticipants[index])).ToArray();
+            room.ParticipantCount--;
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchBeatmapDetailArea.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchBeatmapDetailArea.cs
index 813a420cbd..e372d63fde 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchBeatmapDetailArea.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchBeatmapDetailArea.cs
@@ -16,15 +16,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
     public partial class TestSceneMatchBeatmapDetailArea : OnlinePlayTestScene
     {
+        private Room room = null!;
+
         public override void SetUpSteps()
         {
             base.SetUpSteps();
 
             AddStep("create area", () =>
             {
-                SelectedRoom.Value = new Room();
-
-                Child = new MatchBeatmapDetailArea(SelectedRoom.Value)
+                Child = new MatchBeatmapDetailArea(room = new Room())
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -36,9 +36,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private void createNewItem()
         {
-            SelectedRoom.Value!.Playlist = SelectedRoom.Value.Playlist.Append(new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
+            room.Playlist = room.Playlist.Append(new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
             {
-                ID = SelectedRoom.Value.Playlist.Count,
+                ID = room.Playlist.Count,
                 RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
                 RequiredMods = new[]
                 {
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchLeaderboard.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchLeaderboard.cs
index 38522db4d4..39ad21d0b0 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchLeaderboard.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchLeaderboard.cs
@@ -61,9 +61,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create leaderboard", () =>
             {
-                SelectedRoom.Value = new Room { RoomID = 3 };
-
-                Child = new MatchLeaderboard(SelectedRoom.Value)
+                Child = new MatchLeaderboard(new Room { RoomID = 3 })
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs
index 3245b3c6a9..60358dfbc4 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs
@@ -24,6 +24,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             base.SetUpSteps();
 
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom()));
+            WaitForJoined();
+
             AddStep("reset", () =>
             {
                 leaderboard?.RemoveAndDisposeImmediately();
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
index bd483f0fa1..aa98dc59db 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
@@ -17,6 +17,7 @@ using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer;
 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.Screens.OnlinePlay.Multiplayer.Spectate;
@@ -42,6 +43,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private BeatmapManager beatmapManager { get; set; } = null!;
 
         private MultiSpectatorScreen spectatorScreen = null!;
+        private Room room = null!;
 
         private readonly List<MultiplayerRoomUser> playingUsers = new List<MultiplayerRoomUser>();
 
@@ -63,6 +65,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
             base.SetUpSteps();
 
             AddStep("clear playing users", () => playingUsers.Clear());
+
+            AddStep("create room", () => room = CreateDefaultRoom());
+            AddStep("join room", () => JoinRoom(room));
+            WaitForJoined();
         }
 
         [TestCase(1)]
@@ -456,7 +462,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
                 applyToBeatmap?.Invoke(Beatmap.Value);
 
-                LoadScreen(spectatorScreen = new MultiSpectatorScreen(SelectedRoom.Value!, playingUsers.ToArray()));
+                LoadScreen(spectatorScreen = new MultiSpectatorScreen(room, playingUsers.ToArray()));
             });
 
             AddUntilStep("wait for screen load", () => spectatorScreen.LoadState == LoadState.Loaded && (!waitForPlayerLoad || spectatorScreen.AllPlayersLoaded));
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
index fb653cea8b..ec0117a990 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
@@ -33,7 +33,6 @@ using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Taiko;
 using osu.Game.Scoring;
 using osu.Game.Screens.OnlinePlay;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Screens.OnlinePlay.Match;
@@ -58,7 +57,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private TestMultiplayerComponents multiplayerComponents = null!;
 
         private TestMultiplayerClient multiplayerClient => multiplayerComponents.MultiplayerClient;
-        private TestMultiplayerRoomManager roomManager => multiplayerComponents.RoomManager;
 
         [Resolved]
         private OsuConfigManager config { get; set; } = null!;
@@ -257,7 +255,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("create room", () =>
             {
-                roomManager.AddServerSideRoom(new Room
+                multiplayerClient.AddServerSideRoom(new Room
                 {
                     Name = "Test Room",
                     Playlist =
@@ -286,7 +284,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("create room", () =>
             {
-                roomManager.AddServerSideRoom(new Room
+                multiplayerClient.AddServerSideRoom(new Room
                 {
                     Name = "Test Room",
                     Playlist =
@@ -336,7 +334,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("create room", () =>
             {
-                roomManager.AddServerSideRoom(new Room
+                multiplayerClient.AddServerSideRoom(new Room
                 {
                     Name = "Test Room",
                     Password = "password",
@@ -789,7 +787,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("create room", () =>
             {
-                roomManager.AddServerSideRoom(new Room
+                multiplayerClient.AddServerSideRoom(new Room
                 {
                     Name = "Test Room",
                     QueueMode = QueueMode.AllPlayers,
@@ -807,11 +805,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for room", () => this.ChildrenOfType<DrawableRoom>().Any());
             AddStep("select room", () => InputManager.Key(Key.Down));
 
-            AddStep("disable polling", () => this.ChildrenOfType<ListingPollingComponent>().Single().TimeBetweenPolls.Value = 0);
+            AddStep("disable polling", () => this.ChildrenOfType<LoungeListingPoller>().Single().TimeBetweenPolls.Value = 0);
             AddStep("change server-side settings", () =>
             {
-                roomManager.ServerSideRooms[0].Name = "New name";
-                roomManager.ServerSideRooms[0].Playlist =
+                multiplayerClient.ServerSideRooms[0].Name = "New name";
+                multiplayerClient.ServerSideRooms[0].Playlist =
                 [
                     new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0)).BeatmapInfo)
                     {
@@ -828,7 +826,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("local room has correct settings", () =>
             {
                 var localRoom = this.ChildrenOfType<MultiplayerMatchSubScreen>().Single().Room;
-                return localRoom.Name == roomManager.ServerSideRooms[0].Name && localRoom.Playlist.Single().ID == 2;
+                return localRoom.Name == multiplayerClient.ServerSideRooms[0].Name && localRoom.Playlist.Single().ID == 2;
             });
         }
 
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerLoungeSubScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerLoungeSubScreen.cs
index 9951f62c77..56187f8778 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerLoungeSubScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerLoungeSubScreen.cs
@@ -16,45 +16,32 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
-    public partial class TestSceneMultiplayerLoungeSubScreen : OnlinePlayTestScene
+    public partial class TestSceneMultiplayerLoungeSubScreen : MultiplayerTestScene
     {
-        protected new TestRoomManager RoomManager => (TestRoomManager)base.RoomManager;
-
-        private LoungeSubScreen loungeScreen = null!;
-        private Room? lastJoinedRoom;
-        private string? lastJoinedPassword;
+        private MultiplayerLoungeSubScreen loungeScreen = null!;
 
         public override void SetUpSteps()
         {
             base.SetUpSteps();
 
             AddStep("push screen", () => LoadScreen(loungeScreen = new MultiplayerLoungeSubScreen()));
-
             AddUntilStep("wait for present", () => loungeScreen.IsCurrentScreen());
-
-            AddStep("bind to event", () =>
-            {
-                lastJoinedRoom = null;
-                lastJoinedPassword = null;
-                RoomManager.JoinRoomRequested = onRoomJoined;
-            });
         }
 
         [Test]
         public void TestJoinRoomWithoutPassword()
         {
-            AddStep("add room", () => RoomManager.AddRooms(1, withPassword: false));
+            createRooms(GenerateRooms(1, withPassword: false));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("join room", () => InputManager.Key(Key.Enter));
 
-            AddAssert("room join requested", () => lastJoinedRoom == RoomManager.Rooms.First());
-            AddAssert("room join password correct", () => lastJoinedPassword == null);
+            AddAssert("room joined", () => MultiplayerClient.RoomJoined);
         }
 
         [Test]
         public void TestPopoverHidesOnBackButton()
         {
-            AddStep("add room", () => RoomManager.AddRooms(1, withPassword: true));
+            createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
 
@@ -67,18 +54,22 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("hit escape", () => InputManager.Key(Key.Escape));
             AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+
+            AddAssert("room not joined", () => !MultiplayerClient.RoomJoined);
         }
 
         [Test]
         public void TestPopoverHidesOnLeavingScreen()
         {
-            AddStep("add room", () => RoomManager.AddRooms(1, withPassword: true));
+            createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
 
             AddUntilStep("password prompt appeared", () => InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
             AddStep("exit screen", () => Stack.Exit());
             AddUntilStep("password prompt hidden", () => !InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().Any());
+
+            AddAssert("room not joined", () => !MultiplayerClient.RoomJoined);
         }
 
         [Test]
@@ -86,16 +77,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
 
-            AddStep("add room", () => RoomManager.AddRooms(1, withPassword: true));
+            createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
             AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "wrong");
             AddStep("press join room button", () => passwordEntryPopover.ChildrenOfType<OsuButton>().First().TriggerClick());
 
-            AddAssert("room not joined", () => loungeScreen.IsCurrentScreen());
+            AddAssert("still at lounge", () => loungeScreen.IsCurrentScreen());
             AddUntilStep("password prompt still visible", () => passwordEntryPopover!.State.Value == Visibility.Visible);
             AddAssert("textbox still focused", () => InputManager.FocusedDrawable is OsuPasswordTextBox);
+
+            AddAssert("room not joined", () => !MultiplayerClient.RoomJoined);
         }
 
         [Test]
@@ -103,16 +96,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
 
-            AddStep("add room", () => RoomManager.AddRooms(1, withPassword: true));
+            createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
             AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "wrong");
             AddStep("press enter", () => InputManager.Key(Key.Enter));
 
-            AddAssert("room not joined", () => loungeScreen.IsCurrentScreen());
+            AddAssert("still at lounge", () => loungeScreen.IsCurrentScreen());
             AddUntilStep("password prompt still visible", () => passwordEntryPopover!.State.Value == Visibility.Visible);
             AddAssert("textbox still focused", () => InputManager.FocusedDrawable is OsuPasswordTextBox);
+
+            AddAssert("room not joined", () => !MultiplayerClient.RoomJoined);
         }
 
         [Test]
@@ -120,15 +115,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
 
-            AddStep("add room", () => RoomManager.AddRooms(1, withPassword: true));
+            createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
             AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "password");
             AddStep("press join room button", () => passwordEntryPopover.ChildrenOfType<OsuButton>().First().TriggerClick());
 
-            AddAssert("room join requested", () => lastJoinedRoom == RoomManager.Rooms.First());
-            AddAssert("room join password correct", () => lastJoinedPassword == "password");
+            AddUntilStep("room joined", () => MultiplayerClient.RoomJoined);
         }
 
         [Test]
@@ -136,21 +130,27 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             DrawableLoungeRoom.PasswordEntryPopover? passwordEntryPopover = null;
 
-            AddStep("add room", () => RoomManager.AddRooms(1, withPassword: true));
+            createRooms(GenerateRooms(1, withPassword: true));
             AddStep("select room", () => InputManager.Key(Key.Down));
             AddStep("attempt join room", () => InputManager.Key(Key.Enter));
             AddUntilStep("password prompt appeared", () => (passwordEntryPopover = InputManager.ChildrenOfType<DrawableLoungeRoom.PasswordEntryPopover>().FirstOrDefault()) != null);
             AddStep("enter password in text box", () => passwordEntryPopover.ChildrenOfType<TextBox>().First().Text = "password");
             AddStep("press enter", () => InputManager.Key(Key.Enter));
 
-            AddAssert("room join requested", () => lastJoinedRoom == RoomManager.Rooms.First());
-            AddAssert("room join password correct", () => lastJoinedPassword == "password");
+            AddAssert("room joined", () => MultiplayerClient.RoomJoined);
         }
 
-        private void onRoomJoined(Room room, string? password)
+        private void createRooms(params Room[] rooms)
         {
-            lastJoinedRoom = room;
-            lastJoinedPassword = password;
+            AddStep("create rooms", () =>
+            {
+                foreach (var room in rooms)
+                    API.Queue(new CreateRoomRequest(room));
+            });
+
+            AddStep("refresh lounge", () => loungeScreen.RefreshRooms());
         }
+
+        protected override OnlinePlayTestSceneDependencies CreateOnlinePlayDependencies() => new MultiplayerTestSceneDependencies();
     }
 }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSongSelect.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSongSelect.cs
index 298e6e1b3c..9c85bdd57a 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSongSelect.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSongSelect.cs
@@ -39,6 +39,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private TestMultiplayerMatchSongSelect songSelect = null!;
         private Live<BeatmapSetInfo> importedBeatmapSet = null!;
+        private Room room = null!;
 
         [Resolved]
         private OsuConfigManager configManager { get; set; } = null!;
@@ -58,6 +59,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
             Add(beatmapStore);
         }
 
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("create room", () => room = CreateDefaultRoom());
+            AddStep("join room", () => JoinRoom(room));
+            WaitForJoined();
+        }
+
         private void setUp()
         {
             AddStep("create song select", () =>
@@ -66,7 +76,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 Beatmap.SetDefault();
                 SelectedMods.SetDefault();
 
-                LoadScreen(songSelect = new TestMultiplayerMatchSongSelect(SelectedRoom.Value!));
+                LoadScreen(songSelect = new TestMultiplayerMatchSongSelect(room));
             });
 
             AddUntilStep("wait for present", () => songSelect.IsCurrentScreen() && songSelect.BeatmapSetsLoaded);
@@ -138,8 +148,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create song select", () =>
             {
-                SelectedRoom.Value!.Playlist.Single().RulesetID = 2;
-                songSelect = new TestMultiplayerMatchSongSelect(SelectedRoom.Value, SelectedRoom.Value.Playlist.Single());
+                room.Playlist.Single().RulesetID = 2;
+                songSelect = new TestMultiplayerMatchSongSelect(room, room.Playlist.Single());
                 songSelect.OnLoadComplete += _ => Ruleset.Value = new TaikoRuleset().RulesetInfo;
                 LoadScreen(songSelect);
             });
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
index e95209f993..e5e4921a17 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerMatchSubScreen.cs
@@ -43,11 +43,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private MultiplayerMatchSubScreen screen = null!;
         private BeatmapManager beatmaps = null!;
         private BeatmapSetInfo importedSet = null!;
-
-        public TestSceneMultiplayerMatchSubScreen()
-            : base(false)
-        {
-        }
+        private Room room = null!;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
@@ -66,8 +62,8 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("load match", () =>
             {
-                SelectedRoom.Value = new Room { Name = "Test Room" };
-                LoadScreen(screen = new TestMultiplayerMatchSubScreen(SelectedRoom.Value!));
+                room = new Room { Name = "Test Room" };
+                LoadScreen(screen = new TestMultiplayerMatchSubScreen(room));
             });
 
             AddUntilStep("wait for load", () => screen.IsCurrentScreen());
@@ -78,7 +74,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("add playlist item", () =>
             {
-                SelectedRoom.Value!.Playlist =
+                room.Playlist =
                 [
                     new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
                     {
@@ -97,7 +93,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("add playlist item", () =>
             {
-                SelectedRoom.Value!.Playlist =
+                room.Playlist =
                 [
                     new PlaylistItem(new TestBeatmap(new TaikoRuleset().RulesetInfo).BeatmapInfo)
                     {
@@ -122,7 +118,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("set playlist", () =>
             {
-                SelectedRoom.Value!.Playlist =
+                room.Playlist =
                 [
                     new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
                     {
@@ -139,7 +135,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("set playlist", () =>
             {
-                SelectedRoom.Value!.Playlist =
+                room.Playlist =
                 [
                     new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First()).BeatmapInfo)
                     {
@@ -170,7 +166,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("add playlist item with allowed mod", () =>
             {
-                SelectedRoom.Value!.Playlist =
+                room.Playlist =
                 [
                     new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
                     {
@@ -199,7 +195,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("add playlist item with allowed mod", () =>
             {
-                SelectedRoom.Value!.Playlist =
+                room.Playlist =
                 [
                     new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
                     {
@@ -223,7 +219,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("add playlist item with no allowed mods", () =>
             {
-                SelectedRoom.Value!.Playlist =
+                room.Playlist =
                 [
                     new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
                     {
@@ -246,7 +242,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("add two playlist items", () =>
             {
-                SelectedRoom.Value!.Playlist =
+                room.Playlist =
                 [
                     new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First()).BeatmapInfo)
                     {
@@ -285,7 +281,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("add playlist item", () =>
             {
-                SelectedRoom.Value!.Playlist =
+                room.Playlist =
                 [
                     new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
                     {
@@ -317,6 +313,29 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("score multiplier = 1.20", () => this.ChildrenOfType<RankingInformationDisplay>().Single().ModMultiplier.Value, () => Is.EqualTo(1.2).Within(0.01));
         }
 
+        [Test]
+        public void TestChangeSettingsButtonVisibleForHost()
+        {
+            AddStep("add playlist item", () =>
+            {
+                room.Playlist =
+                [
+                    new PlaylistItem(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo)
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID
+                    }
+                ];
+            });
+            ClickButtonWhenEnabled<MultiplayerMatchSettingsOverlay.CreateOrUpdateButton>();
+
+            AddUntilStep("wait for join", () => RoomJoined);
+
+            AddUntilStep("button visible", () => this.ChildrenOfType<DrawableMatchRoom>().Single().ChangeSettingsButton?.Alpha, () => Is.GreaterThan(0));
+            AddStep("join other user", void () => MultiplayerClient.AddUser(new APIUser { Id = PLAYER_1_ID }));
+            AddStep("make other user host", () => MultiplayerClient.TransferHost(PLAYER_1_ID));
+            AddAssert("button hidden", () => this.ChildrenOfType<DrawableMatchRoom>().Single().ChangeSettingsButton?.Alpha, () => Is.EqualTo(0));
+        }
+
         private partial class TestMultiplayerMatchSubScreen : MultiplayerMatchSubScreen
         {
             [Resolved(canBeNull: true)]
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerParticipantsList.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerParticipantsList.cs
index d3c967a8d5..ed3fd4a6f8 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerParticipantsList.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerParticipantsList.cs
@@ -28,9 +28,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
     public partial class TestSceneMultiplayerParticipantsList : MultiplayerTestScene
     {
-        [SetUpSteps]
-        public void SetupSteps()
+        public override void SetUpSteps()
         {
+            base.SetUpSteps();
+
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom()));
+            WaitForJoined();
             createNewParticipantsList();
         }
 
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlayer.cs
index 94dd114c32..99bec1e714 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlayer.cs
@@ -22,6 +22,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         private MultiplayerPlayer player = null!;
 
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+            AddStep("join room", () => JoinRoom(CreateDefaultRoom()));
+            WaitForJoined();
+        }
+
         [Test]
         public void TestGameplay()
         {
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs
index 37a3cc2faf..7c8691d5d1 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerPlaylist.cs
@@ -32,6 +32,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private BeatmapManager beatmaps = null!;
         private BeatmapSetInfo importedSet = null!;
         private BeatmapInfo importedBeatmap = null!;
+        private Room room = null!;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
@@ -46,9 +47,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             base.SetUpSteps();
 
+            AddStep("create room", () => room = CreateDefaultRoom());
+            AddStep("join room", () => JoinRoom(room));
+            WaitForJoined();
+
             AddStep("create list", () =>
             {
-                Child = list = new MultiplayerPlaylist(SelectedRoom.Value!)
+                Child = list = new MultiplayerPlaylist(room)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -127,7 +132,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             addItemStep();
             AddStep("finish current item", () => MultiplayerClient.FinishCurrentItem().WaitSafely());
 
-            AddStep("leave room", () => RoomManager.PartRoom());
+            AddStep("leave room", () => MultiplayerClient.LeaveRoom());
             AddUntilStep("wait for room part", () => !RoomJoined);
 
             AddUntilStep("item 0 not in lists", () => !inHistoryList(0) && !inQueueList(0));
@@ -148,7 +153,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("finish current item", () => MultiplayerClient.FinishCurrentItem().WaitSafely());
             assertQueueTabCount(2);
 
-            AddStep("leave room", () => RoomManager.PartRoom());
+            AddStep("leave room", () => MultiplayerClient.LeaveRoom());
             AddUntilStep("wait for room part", () => !RoomJoined);
             assertQueueTabCount(0);
         }
@@ -157,12 +162,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestJoinRoomWithMixedItemsAddedInCorrectLists()
         {
-            AddStep("leave room", () => RoomManager.PartRoom());
+            AddStep("leave room", () => MultiplayerClient.LeaveRoom());
             AddUntilStep("wait for room part", () => !RoomJoined);
 
             AddStep("join room with items", () =>
             {
-                RoomManager.CreateRoom(new Room
+                API.Queue(new CreateRoomRequest(new Room
                 {
                     Name = "test name",
                     Playlist =
@@ -177,7 +182,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                             Expired = true
                         }
                     ]
-                });
+                }));
             });
 
             AddUntilStep("wait for room join", () => RoomJoined);
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerQueueList.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerQueueList.cs
index 3ef2e4ecf4..1a7b677798 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerQueueList.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerQueueList.cs
@@ -29,6 +29,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private BeatmapManager beatmaps = null!;
         private BeatmapSetInfo importedSet = null!;
         private BeatmapInfo importedBeatmap = null!;
+        private Room room = null!;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
@@ -42,9 +43,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             base.SetUpSteps();
 
+            AddStep("create room", () => room = CreateDefaultRoom());
+            AddStep("join room", () => JoinRoom(room));
+            WaitForJoined();
+
             AddStep("create playlist", () =>
             {
-                Child = playlist = new MultiplayerQueueList(SelectedRoom.Value!)
+                Child = playlist = new MultiplayerQueueList(room)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerSpectateButton.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerSpectateButton.cs
index 1429f86164..9e6734ce99 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerSpectateButton.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerSpectateButton.cs
@@ -28,6 +28,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         private MultiplayerSpectateButton spectateButton = null!;
         private MatchStartControl startControl = null!;
+        private Room room = null!;
 
         private BeatmapSetInfo importedSet = null!;
         private BeatmapManager beatmaps = null!;
@@ -46,11 +47,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             base.SetUpSteps();
 
+            AddStep("create room", () => room = CreateDefaultRoom());
+            AddStep("join room", () => JoinRoom(room));
+            WaitForJoined();
+
             AddStep("create button", () =>
             {
-                PlaylistItem item = SelectedRoom.Value!.Playlist.First();
-
-                AvailabilityTracker.SelectedItem.Value = item;
+                AvailabilityTracker.SelectedItem.Value = room.Playlist.First();
 
                 importedSet = beatmaps.GetAllUsableBeatmapSets().First();
                 Beatmap.Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First());
@@ -69,14 +72,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
                                 Anchor = Anchor.Centre,
                                 Origin = Anchor.Centre,
                                 Size = new Vector2(200, 50),
-                                SelectedItem = new Bindable<PlaylistItem?>(item)
+                                SelectedItem = new Bindable<PlaylistItem?>(room.Playlist.First())
                             },
                             startControl = new MatchStartControl
                             {
                                 Anchor = Anchor.Centre,
                                 Origin = Anchor.Centre,
                                 Size = new Vector2(200, 50),
-                                SelectedItem = new Bindable<PlaylistItem?>(item)
+                                SelectedItem = new Bindable<PlaylistItem?>(room.Playlist.First())
                             }
                         }
                     }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs b/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs
index 726d0ac9f9..7c73fb8321 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestScenePlaylistsSongSelect.cs
@@ -27,6 +27,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         private BeatmapManager manager = null!;
         private TestPlaylistsSongSelect songSelect = null!;
+        private Room room = null!;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
@@ -51,13 +52,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("reset", () =>
             {
-                SelectedRoom.Value = new Room();
+                room = new Room();
                 Ruleset.Value = new OsuRuleset().RulesetInfo;
                 Beatmap.SetDefault();
                 SelectedMods.Value = Array.Empty<Mod>();
             });
 
-            AddStep("create song select", () => LoadScreen(songSelect = new TestPlaylistsSongSelect(SelectedRoom.Value!)));
+            AddStep("create song select", () => LoadScreen(songSelect = new TestPlaylistsSongSelect(room)));
             AddUntilStep("wait for present", () => songSelect.IsCurrentScreen() && songSelect.BeatmapSetsLoaded);
         }
 
@@ -65,14 +66,14 @@ namespace osu.Game.Tests.Visual.Multiplayer
         public void TestItemAddedIfEmptyOnStart()
         {
             AddStep("finalise selection", () => songSelect.FinaliseSelection());
-            AddAssert("playlist has 1 item", () => SelectedRoom.Value!.Playlist.Count == 1);
+            AddAssert("playlist has 1 item", () => room.Playlist.Count == 1);
         }
 
         [Test]
         public void TestItemAddedWhenCreateNewItemClicked()
         {
             AddStep("create new item", () => songSelect.BeatmapDetails.CreateNewItem!());
-            AddAssert("playlist has 1 item", () => SelectedRoom.Value!.Playlist.Count == 1);
+            AddAssert("playlist has 1 item", () => room.Playlist.Count == 1);
         }
 
         [Test]
@@ -80,7 +81,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("create new item", () => songSelect.BeatmapDetails.CreateNewItem!());
             AddStep("finalise selection", () => songSelect.FinaliseSelection());
-            AddAssert("playlist has 1 item", () => SelectedRoom.Value!.Playlist.Count == 1);
+            AddAssert("playlist has 1 item", () => room.Playlist.Count == 1);
         }
 
         [Test]
@@ -88,7 +89,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("create new item", () => songSelect.BeatmapDetails.CreateNewItem!());
             AddStep("create new item", () => songSelect.BeatmapDetails.CreateNewItem!());
-            AddAssert("playlist has 2 items", () => SelectedRoom.Value!.Playlist.Count == 2);
+            AddAssert("playlist has 2 items", () => room.Playlist.Count == 2);
         }
 
         [Test]
@@ -96,10 +97,10 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("create new item", () => songSelect.BeatmapDetails.CreateNewItem!());
             AddStep("create new item", () => songSelect.BeatmapDetails.CreateNewItem!());
-            AddStep("rearrange", () => SelectedRoom.Value!.Playlist = SelectedRoom.Value!.Playlist.Skip(1).Append(SelectedRoom.Value!.Playlist[0]).ToArray());
+            AddStep("rearrange", () => room.Playlist = room.Playlist.Skip(1).Append(room.Playlist[0]).ToArray());
 
             AddStep("create new item", () => songSelect.BeatmapDetails.CreateNewItem!());
-            AddAssert("new item has id 2", () => SelectedRoom.Value!.Playlist.Last().ID == 2);
+            AddAssert("new item has id 2", () => room.Playlist.Last().ID == 2);
         }
 
         /// <summary>
@@ -115,13 +116,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddAssert("item 1 has rate 1.5", () =>
             {
-                var mod = (OsuModDoubleTime)SelectedRoom.Value!.Playlist.First().RequiredMods[0].ToMod(new OsuRuleset());
+                var mod = (OsuModDoubleTime)room.Playlist.First().RequiredMods[0].ToMod(new OsuRuleset());
                 return Precision.AlmostEquals(1.5, mod.SpeedChange.Value);
             });
 
             AddAssert("item 2 has rate 2", () =>
             {
-                var mod = (OsuModDoubleTime)SelectedRoom.Value!.Playlist.Last().RequiredMods[0].ToMod(new OsuRuleset());
+                var mod = (OsuModDoubleTime)room.Playlist.Last().RequiredMods[0].ToMod(new OsuRuleset());
                 return Precision.AlmostEquals(2, mod.SpeedChange.Value);
             });
         }
@@ -147,7 +148,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddStep("change stored mod rate", () => mod.SpeedChange.Value = 2);
             AddAssert("item has rate 1.5", () =>
             {
-                var m = (OsuModDoubleTime)SelectedRoom.Value!.Playlist.First().RequiredMods[0].ToMod(new OsuRuleset());
+                var m = (OsuModDoubleTime)room.Playlist.First().RequiredMods[0].ToMod(new OsuRuleset());
                 return Precision.AlmostEquals(1.5, m.SpeedChange.Value);
             });
         }
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneLoungeRoomsContainer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
similarity index 56%
rename from osu.Game.Tests/Visual/Multiplayer/TestSceneLoungeRoomsContainer.cs
rename to osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
index 797b69ec72..27c5758afa 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneLoungeRoomsContainer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneRoomListing.cs
@@ -3,6 +3,7 @@
 
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
@@ -17,11 +18,11 @@ using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
-    public partial class TestSceneLoungeRoomsContainer : OnlinePlayTestScene
+    public partial class TestSceneRoomListing : OnlinePlayTestScene
     {
-        protected new TestRoomManager RoomManager => (TestRoomManager)base.RoomManager;
-
-        private RoomsContainer container = null!;
+        private BindableList<Room> rooms = null!;
+        private IBindable<Room?> selectedRoom = null!;
+        private RoomListing container = null!;
 
         public override void SetUpSteps()
         {
@@ -29,17 +30,20 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("create container", () =>
             {
+                rooms = new BindableList<Room>();
+                selectedRoom = new Bindable<Room?>();
+
                 Child = new PopoverContainer
                 {
-                    RelativeSizeAxes = Axes.X,
-                    AutoSizeAxes = Axes.Y,
+                    RelativeSizeAxes = Axes.Both,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Width = 0.5f,
-
-                    Child = container = new RoomsContainer
+                    Child = container = new RoomListing
                     {
-                        SelectedRoom = { BindTarget = SelectedRoom }
+                        RelativeSizeAxes = Axes.Both,
+                        Rooms = { BindTarget = rooms },
+                        SelectedRoom = { BindTarget = selectedRoom }
                     }
                 };
             });
@@ -48,57 +52,58 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestBasicListChanges()
         {
-            AddStep("add rooms", () => RoomManager.AddRooms(5, withSpotlightRooms: true));
+            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(5, withSpotlightRooms: true)));
 
-            AddAssert("has 5 rooms", () => container.Rooms.Count == 5);
+            AddAssert("has 5 rooms", () => container.DrawableRooms.Count == 5);
 
-            AddAssert("all spotlights at top", () => container.Rooms
+            AddAssert("all spotlights at top", () => container.DrawableRooms
                                                               .SkipWhile(r => r.Room.Category == RoomCategory.Spotlight)
                                                               .All(r => r.Room.Category == RoomCategory.Normal));
 
-            AddStep("remove first room", () => RoomManager.RemoveRoom(RoomManager.Rooms.First(r => r.RoomID == 0)));
-            AddAssert("has 4 rooms", () => container.Rooms.Count == 4);
-            AddAssert("first room removed", () => container.Rooms.All(r => r.Room.RoomID != 0));
+            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.Rooms.First().TriggerClick());
-            AddAssert("first spotlight selected", () => checkRoomSelected(RoomManager.Rooms.First(r => r.Category == RoomCategory.Spotlight)));
+            AddStep("select first room", () => container.DrawableRooms.First().TriggerClick());
+            AddAssert("first spotlight selected", () => checkRoomSelected(rooms.First(r => r.Category == RoomCategory.Spotlight)));
 
-            AddStep("remove last room", () => RoomManager.RemoveRoom(RoomManager.Rooms.MinBy(r => r.RoomID)!));
-            AddAssert("first spotlight still selected", () => checkRoomSelected(RoomManager.Rooms.First(r => r.Category == RoomCategory.Spotlight)));
+            AddStep("remove last room", () => rooms.RemoveAt(rooms.Count - 1));
+            AddAssert("first spotlight still selected", () => checkRoomSelected(rooms.First(r => r.Category == RoomCategory.Spotlight)));
 
-            AddStep("remove spotlight room", () => RoomManager.RemoveRoom(RoomManager.Rooms.Single(r => r.Category == RoomCategory.Spotlight)));
+            AddStep("remove spotlight room", () => rooms.RemoveAll(r => r.Category == RoomCategory.Spotlight));
             AddAssert("selection vacated", () => checkRoomSelected(null));
         }
 
         [Test]
         public void TestKeyboardNavigation()
         {
-            AddStep("add rooms", () => RoomManager.AddRooms(3));
+            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(3)));
 
             AddAssert("no selection", () => checkRoomSelected(null));
 
             press(Key.Down);
-            AddAssert("first room selected", () => checkRoomSelected(RoomManager.Rooms.First()));
+            AddAssert("first room selected", () => checkRoomSelected(container.DrawableRooms.First().Room));
 
             press(Key.Up);
-            AddAssert("first room selected", () => checkRoomSelected(RoomManager.Rooms.First()));
+            AddAssert("first room selected", () => checkRoomSelected(container.DrawableRooms.First().Room));
 
             press(Key.Down);
             press(Key.Down);
-            AddAssert("last room selected", () => checkRoomSelected(RoomManager.Rooms.Last()));
+            AddAssert("last room selected", () => checkRoomSelected(container.DrawableRooms.Last().Room));
         }
 
         [Test]
         public void TestKeyboardNavigationAfterOrderChange()
         {
-            AddStep("add rooms", () => RoomManager.AddRooms(3));
+            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(3)));
 
             AddStep("reorder rooms", () =>
             {
-                var room = RoomManager.Rooms[1];
+                var room = rooms[1];
+                rooms.Remove(room);
 
-                RoomManager.RemoveRoom(room);
-                RoomManager.AddOrUpdateRoom(room);
+                room.RoomID += 3;
+                rooms.Add(room);
             });
 
             AddAssert("no selection", () => checkRoomSelected(null));
@@ -116,12 +121,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestClickDeselection()
         {
-            AddStep("add room", () => RoomManager.AddRooms(1));
+            AddStep("add room", () => rooms.AddRange(GenerateRooms(1)));
 
             AddAssert("no selection", () => checkRoomSelected(null));
 
             press(Key.Down);
-            AddAssert("first room selected", () => checkRoomSelected(RoomManager.Rooms.First()));
+            AddAssert("first room selected", () => checkRoomSelected(container.DrawableRooms.First().Room));
 
             AddStep("click away", () => InputManager.Click(MouseButton.Left));
             AddAssert("no selection", () => checkRoomSelected(null));
@@ -135,34 +140,34 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestStringFiltering()
         {
-            AddStep("add rooms", () => RoomManager.AddRooms(4));
+            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(4)));
 
-            AddUntilStep("4 rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 4);
+            AddUntilStep("4 rooms visible", () => container.DrawableRooms.Count(r => r.IsPresent) == 4);
 
-            AddStep("filter one room", () => container.Filter.Value = new FilterCriteria { SearchString = "1" });
+            AddStep("filter one room", () => container.Filter.Value = new FilterCriteria { SearchString = rooms.First().Name });
 
-            AddUntilStep("1 rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 1);
+            AddUntilStep("1 rooms visible", () => container.DrawableRooms.Count(r => r.IsPresent) == 1);
 
             AddStep("remove filter", () => container.Filter.Value = null);
 
-            AddUntilStep("4 rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 4);
+            AddUntilStep("4 rooms visible", () => container.DrawableRooms.Count(r => r.IsPresent) == 4);
         }
 
         [Test]
         public void TestRulesetFiltering()
         {
-            AddStep("add rooms", () => RoomManager.AddRooms(2, new OsuRuleset().RulesetInfo));
-            AddStep("add rooms", () => RoomManager.AddRooms(3, new CatchRuleset().RulesetInfo));
+            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(2, new OsuRuleset().RulesetInfo)));
+            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(3, new CatchRuleset().RulesetInfo)));
 
             // Todo: What even is this case...?
             AddStep("set empty filter criteria", () => container.Filter.Value = new FilterCriteria());
-            AddUntilStep("5 rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 5);
+            AddUntilStep("5 rooms visible", () => container.DrawableRooms.Count(r => r.IsPresent) == 5);
 
             AddStep("filter osu! rooms", () => container.Filter.Value = new FilterCriteria { Ruleset = new OsuRuleset().RulesetInfo });
-            AddUntilStep("2 rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 2);
+            AddUntilStep("2 rooms visible", () => container.DrawableRooms.Count(r => r.IsPresent) == 2);
 
             AddStep("filter catch rooms", () => container.Filter.Value = new FilterCriteria { Ruleset = new CatchRuleset().RulesetInfo });
-            AddUntilStep("3 rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 3);
+            AddUntilStep("3 rooms visible", () => container.DrawableRooms.Count(r => r.IsPresent) == 3);
         }
 
         [Test]
@@ -170,30 +175,30 @@ namespace osu.Game.Tests.Visual.Multiplayer
         {
             AddStep("add rooms", () =>
             {
-                RoomManager.AddRooms(1, withPassword: true);
-                RoomManager.AddRooms(1, withPassword: false);
+                rooms.AddRange(GenerateRooms(1, withPassword: true));
+                rooms.AddRange(GenerateRooms(1, withPassword: false));
             });
 
             AddStep("apply default filter", () => container.Filter.SetDefault());
 
-            AddUntilStep("both rooms visible", () => container.Rooms.Count(r => r.IsPresent) == 2);
+            AddUntilStep("both rooms visible", () => container.DrawableRooms.Count(r => r.IsPresent) == 2);
 
             AddStep("filter public rooms", () => container.Filter.Value = new FilterCriteria { Permissions = RoomPermissionsFilter.Public });
 
-            AddUntilStep("private room hidden", () => container.Rooms.All(r => !r.Room.HasPassword));
+            AddUntilStep("private room hidden", () => container.DrawableRooms.All(r => !r.Room.HasPassword));
 
             AddStep("filter private rooms", () => container.Filter.Value = new FilterCriteria { Permissions = RoomPermissionsFilter.Private });
 
-            AddUntilStep("public room hidden", () => container.Rooms.All(r => r.Room.HasPassword));
+            AddUntilStep("public room hidden", () => container.DrawableRooms.All(r => r.Room.HasPassword));
         }
 
         [Test]
         public void TestPasswordProtectedRooms()
         {
-            AddStep("add rooms", () => RoomManager.AddRooms(3, withPassword: true));
+            AddStep("add rooms", () => rooms.AddRange(GenerateRooms(3, withPassword: true)));
         }
 
-        private bool checkRoomSelected(Room? room) => SelectedRoom.Value == room;
+        private bool checkRoomSelected(Room? room) => selectedRoom.Value == room;
 
         private Room? getRoomInFlow(int index) =>
             (container.ChildrenOfType<FillFlowContainer<DrawableLoungeRoom>>().First().FlowingChildren.ElementAt(index) as DrawableRoom)?.Room;
diff --git a/osu.Game.Tests/Visual/Online/TestSceneChannelList.cs b/osu.Game.Tests/Visual/Online/TestSceneChannelList.cs
index 5f77e084da..364240502a 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneChannelList.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneChannelList.cs
@@ -115,6 +115,8 @@ namespace osu.Game.Tests.Visual.Online
                     channelList.AddChannel(createRandomPrivateChannel());
             });
 
+            AddStep("Add Team Channel", () => channelList.AddChannel(createRandomTeamChannel()));
+
             AddStep("Add Announce Channels", () =>
             {
                 for (int i = 0; i < 2; i++)
@@ -189,5 +191,16 @@ namespace osu.Game.Tests.Visual.Online
                 Id = id,
             };
         }
+
+        private Channel createRandomTeamChannel()
+        {
+            int id = TestResources.GetNextTestID();
+            return new Channel
+            {
+                Name = $"Team {id}",
+                Type = ChannelType.Team,
+                Id = id,
+            };
+        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs
index 8c8dc8d69a..ceb3a32402 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsLoungeSubScreen.cs
@@ -3,7 +3,6 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Bindables;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Graphics.Containers;
@@ -17,25 +16,22 @@ namespace osu.Game.Tests.Visual.Playlists
 {
     public partial class TestScenePlaylistsLoungeSubScreen : OnlinePlayTestScene
     {
-        protected new TestRoomManager RoomManager => (TestRoomManager)base.RoomManager;
-
-        private TestLoungeSubScreen loungeScreen = null!;
+        private PlaylistsLoungeSubScreen loungeScreen = null!;
 
         public override void SetUpSteps()
         {
             base.SetUpSteps();
 
-            AddStep("push screen", () => LoadScreen(loungeScreen = new TestLoungeSubScreen()));
-
+            AddStep("push screen", () => LoadScreen(loungeScreen = new PlaylistsLoungeSubScreen()));
             AddUntilStep("wait for present", () => loungeScreen.IsCurrentScreen());
         }
 
-        private RoomsContainer roomsContainer => loungeScreen.ChildrenOfType<RoomsContainer>().First();
+        private RoomListing roomListing => loungeScreen.ChildrenOfType<RoomListing>().First();
 
         [Test]
         public void TestManyRooms()
         {
-            AddStep("add rooms", () => RoomManager.AddRooms(500));
+            createRooms(GenerateRooms(500));
         }
 
         [Test]
@@ -43,59 +39,41 @@ namespace osu.Game.Tests.Visual.Playlists
         {
             AddStep("reset mouse", () => InputManager.ReleaseButton(MouseButton.Left));
 
-            AddStep("add rooms", () => RoomManager.AddRooms(30));
-            AddUntilStep("wait for rooms", () => roomsContainer.Rooms.Count == 30);
+            createRooms(GenerateRooms(30));
 
-            AddUntilStep("first room is not masked", () => checkRoomVisible(roomsContainer.Rooms[0]));
-
-            AddStep("move mouse to third room", () => InputManager.MoveMouseTo(roomsContainer.Rooms[2]));
+            AddStep("move mouse to third room", () => InputManager.MoveMouseTo(roomListing.DrawableRooms[2]));
             AddStep("hold down", () => InputManager.PressButton(MouseButton.Left));
-            AddStep("drag to top", () => InputManager.MoveMouseTo(roomsContainer.Rooms[0]));
+            AddStep("drag to top", () => InputManager.MoveMouseTo(roomListing.DrawableRooms[0]));
 
             AddAssert("first and second room masked", ()
-                => !checkRoomVisible(roomsContainer.Rooms[0]) &&
-                   !checkRoomVisible(roomsContainer.Rooms[1]));
+                => !checkRoomVisible(roomListing.DrawableRooms[0]) &&
+                   !checkRoomVisible(roomListing.DrawableRooms[1]));
         }
 
         [Test]
         public void TestScrollSelectedIntoView()
         {
-            AddStep("add rooms", () => RoomManager.AddRooms(30));
-            AddUntilStep("wait for rooms", () => roomsContainer.Rooms.Count == 30);
+            createRooms(GenerateRooms(30));
 
-            AddUntilStep("first room is not masked", () => checkRoomVisible(roomsContainer.Rooms[0]));
+            AddStep("select last room", () => roomListing.DrawableRooms[^1].TriggerClick());
 
-            AddStep("select last room", () => roomsContainer.Rooms[^1].TriggerClick());
-
-            AddUntilStep("first room is masked", () => !checkRoomVisible(roomsContainer.Rooms[0]));
-            AddUntilStep("last room is not masked", () => checkRoomVisible(roomsContainer.Rooms[^1]));
-        }
-
-        [Test]
-        public void TestEnteringRoomTakesLeaseOnSelection()
-        {
-            AddStep("add rooms", () => RoomManager.AddRooms(1));
-
-            AddAssert("selected room is not disabled", () => !loungeScreen.SelectedRoom.Disabled);
-
-            AddStep("select room", () => roomsContainer.Rooms[0].TriggerClick());
-            AddAssert("selected room is non-null", () => loungeScreen.SelectedRoom.Value != null);
-
-            AddStep("enter room", () => roomsContainer.Rooms[0].TriggerClick());
-
-            AddUntilStep("wait for match load", () => Stack.CurrentScreen is PlaylistsRoomSubScreen);
-
-            AddAssert("selected room is non-null", () => loungeScreen.SelectedRoom.Value != null);
-            AddAssert("selected room is disabled", () => loungeScreen.SelectedRoom.Disabled);
+            AddUntilStep("first room is masked", () => !checkRoomVisible(roomListing.DrawableRooms[0]));
+            AddUntilStep("last room is not masked", () => checkRoomVisible(roomListing.DrawableRooms[^1]));
         }
 
         private bool checkRoomVisible(DrawableRoom room) =>
             loungeScreen.ChildrenOfType<OsuScrollContainer>().First().ScreenSpaceDrawQuad
                         .Contains(room.ScreenSpaceDrawQuad.Centre);
 
-        private partial class TestLoungeSubScreen : PlaylistsLoungeSubScreen
+        private void createRooms(params Room[] rooms)
         {
-            public new Bindable<Room?> SelectedRoom => base.SelectedRoom;
+            AddStep("create rooms", () =>
+            {
+                foreach (var room in rooms)
+                    API.Queue(new CreateRoomRequest(room));
+            });
+
+            AddStep("refresh lounge", () => loungeScreen.RefreshRooms());
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsMatchSettingsOverlay.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsMatchSettingsOverlay.cs
index 5868331451..c714c39e22 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsMatchSettingsOverlay.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsMatchSettingsOverlay.cs
@@ -3,14 +3,13 @@
 
 using System;
 using NUnit.Framework;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
-using osu.Game.Screens.OnlinePlay;
 using osu.Game.Screens.OnlinePlay.Playlists;
 using osu.Game.Tests.Visual.OnlinePlay;
 
@@ -18,21 +17,38 @@ namespace osu.Game.Tests.Visual.Playlists
 {
     public partial class TestScenePlaylistsMatchSettingsOverlay : OnlinePlayTestScene
     {
-        protected new TestRoomManager RoomManager => (TestRoomManager)base.RoomManager;
-
         private TestRoomSettings settings = null!;
-
-        protected override OnlinePlayTestSceneDependencies CreateOnlinePlayDependencies() => new TestDependencies();
+        private Room room = null!;
+        private Func<Room, string?>? handleRequest;
 
         public override void SetUpSteps()
         {
             base.SetUpSteps();
 
+            AddStep("setup api", () =>
+            {
+                handleRequest = null;
+                ((DummyAPIAccess)API).HandleRequest = req =>
+                {
+                    if (req is not CreateRoomRequest createReq || handleRequest == null)
+                        return false;
+
+                    if (handleRequest(createReq.Room) is string errorText)
+                        createReq.TriggerFailure(new APIException(errorText, null));
+                    else
+                    {
+                        var createdRoom = new APICreatedRoom();
+                        createdRoom.CopyFrom(createReq.Room);
+                        createReq.TriggerSuccess(createdRoom);
+                    }
+
+                    return true;
+                };
+            });
+
             AddStep("create overlay", () =>
             {
-                SelectedRoom.Value = new Room();
-
-                Child = settings = new TestRoomSettings(SelectedRoom.Value!)
+                Child = settings = new TestRoomSettings(room = new Room())
                 {
                     RelativeSizeAxes = Axes.Both,
                     State = { Value = Visibility.Visible }
@@ -45,19 +61,19 @@ namespace osu.Game.Tests.Visual.Playlists
         {
             AddStep("clear name and beatmap", () =>
             {
-                SelectedRoom.Value!.Name = "";
-                SelectedRoom.Value!.Playlist = [];
+                room.Name = "";
+                room.Playlist = [];
             });
 
             AddAssert("button disabled", () => !settings.ApplyButton.Enabled.Value);
 
-            AddStep("set name", () => SelectedRoom.Value!.Name = "Room name");
+            AddStep("set name", () => room.Name = "Room name");
             AddAssert("button disabled", () => !settings.ApplyButton.Enabled.Value);
 
-            AddStep("set beatmap", () => SelectedRoom.Value!.Playlist = [new PlaylistItem(CreateBeatmap(Ruleset.Value).BeatmapInfo)]);
+            AddStep("set beatmap", () => room.Playlist = [new PlaylistItem(CreateBeatmap(Ruleset.Value).BeatmapInfo)]);
             AddAssert("button enabled", () => settings.ApplyButton.Enabled.Value);
 
-            AddStep("clear name", () => SelectedRoom.Value!.Name = "");
+            AddStep("clear name", () => room.Name = "");
             AddAssert("button disabled", () => !settings.ApplyButton.Enabled.Value);
         }
 
@@ -73,12 +89,12 @@ namespace osu.Game.Tests.Visual.Playlists
             {
                 settings.NameField.Current.Value = expected_name;
                 settings.DurationField.Current.Value = expectedDuration;
-                SelectedRoom.Value!.Playlist = [new PlaylistItem(CreateBeatmap(Ruleset.Value).BeatmapInfo)];
+                room.Playlist = [new PlaylistItem(CreateBeatmap(Ruleset.Value).BeatmapInfo)];
 
-                RoomManager.CreateRequested = r =>
+                handleRequest = r =>
                 {
                     createdRoom = r;
-                    return string.Empty;
+                    return null;
                 };
             });
 
@@ -98,22 +114,22 @@ namespace osu.Game.Tests.Visual.Playlists
             {
                 var beatmap = CreateBeatmap(Ruleset.Value).BeatmapInfo;
 
-                SelectedRoom.Value!.Name = "Test Room";
-                SelectedRoom.Value!.Playlist = [new PlaylistItem(beatmap)];
+                room.Name = "Test Room";
+                room.Playlist = [new PlaylistItem(beatmap)];
 
                 errorMessage = $"{not_found_prefix} {beatmap.OnlineID}";
 
-                RoomManager.CreateRequested = _ => errorMessage;
+                handleRequest = _ => errorMessage;
             });
 
             AddAssert("error not displayed", () => !settings.ErrorText.IsPresent);
-            AddAssert("playlist item valid", () => SelectedRoom.Value!.Playlist[0].Valid.Value);
+            AddAssert("playlist item valid", () => room.Playlist[0].Valid.Value);
 
             AddStep("create room", () => settings.ApplyButton.Action.Invoke());
 
             AddAssert("error displayed", () => settings.ErrorText.IsPresent);
             AddAssert("error has custom text", () => settings.ErrorText.Text != errorMessage);
-            AddAssert("playlist item marked invalid", () => !SelectedRoom.Value!.Playlist[0].Valid.Value);
+            AddAssert("playlist item marked invalid", () => !room.Playlist[0].Valid.Value);
         }
 
         [Test]
@@ -125,10 +141,10 @@ namespace osu.Game.Tests.Visual.Playlists
 
             AddStep("setup", () =>
             {
-                SelectedRoom.Value!.Name = "Test Room";
-                SelectedRoom.Value!.Playlist = [new PlaylistItem(CreateBeatmap(Ruleset.Value).BeatmapInfo)];
+                room.Name = "Test Room";
+                room.Playlist = [new PlaylistItem(CreateBeatmap(Ruleset.Value).BeatmapInfo)];
 
-                RoomManager.CreateRequested = _ => failText;
+                handleRequest = _ => failText;
             });
             AddAssert("error not displayed", () => !settings.ErrorText.IsPresent);
 
@@ -159,48 +175,5 @@ namespace osu.Game.Tests.Visual.Playlists
             {
             }
         }
-
-        private class TestDependencies : OnlinePlayTestSceneDependencies
-        {
-            protected override IRoomManager CreateRoomManager() => new TestRoomManager();
-        }
-
-        protected class TestRoomManager : IRoomManager
-        {
-            public Func<Room, string>? CreateRequested;
-
-            public event Action RoomsUpdated
-            {
-                add { }
-                remove { }
-            }
-
-            public IBindable<bool> InitialRoomsReceived { get; } = new Bindable<bool>(true);
-
-            public IBindableList<Room> Rooms => null!;
-
-            public void AddOrUpdateRoom(Room room) => throw new NotImplementedException();
-
-            public void RemoveRoom(Room room) => throw new NotImplementedException();
-
-            public void ClearRooms() => throw new NotImplementedException();
-
-            public void CreateRoom(Room room, Action<Room>? onSuccess = null, Action<string>? onError = null)
-            {
-                if (CreateRequested == null)
-                    return;
-
-                string error = CreateRequested.Invoke(room);
-
-                if (!string.IsNullOrEmpty(error))
-                    onError?.Invoke(error);
-                else
-                    onSuccess?.Invoke(room);
-            }
-
-            public void JoinRoom(Room room, string? password, Action<Room>? onSuccess = null, Action<string>? onError = null) => throw new NotImplementedException();
-
-            public void PartRoom() => throw new NotImplementedException();
-        }
     }
 }
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsParticipantsList.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsParticipantsList.cs
index c60b208ffc..e1ec30d02a 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsParticipantsList.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsParticipantsList.cs
@@ -14,13 +14,15 @@ namespace osu.Game.Tests.Visual.Playlists
 {
     public partial class TestScenePlaylistsParticipantsList : OnlinePlayTestScene
     {
+        private Room room = null!;
+
         public override void SetUpSteps()
         {
             base.SetUpSteps();
 
-            AddStep("create list", () =>
+            AddStep("create room", () =>
             {
-                SelectedRoom.Value = new Room
+                room = new Room
                 {
                     RoomID = 7,
                     RecentParticipants = Enumerable.Range(0, 50).Select(_ => new APIUser
@@ -38,7 +40,7 @@ namespace osu.Game.Tests.Visual.Playlists
         {
             AddStep("create component", () =>
             {
-                Child = new ParticipantsDisplay(SelectedRoom.Value!, Direction.Horizontal)
+                Child = new ParticipantsDisplay(room, Direction.Horizontal)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -52,7 +54,7 @@ namespace osu.Game.Tests.Visual.Playlists
         {
             AddStep("create component", () =>
             {
-                Child = new ParticipantsDisplay(SelectedRoom.Value!, Direction.Vertical)
+                Child = new ParticipantsDisplay(room, Direction.Vertical)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsResultsScreen.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsResultsScreen.cs
index 33bd573617..6b73f1a5f4 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsResultsScreen.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsResultsScreen.cs
@@ -7,9 +7,12 @@ using System.Linq;
 using System.Net;
 using Newtonsoft.Json.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Database;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
@@ -32,6 +35,9 @@ namespace osu.Game.Tests.Visual.Playlists
         private const int scores_per_result = 10;
         private const int real_user_position = 200;
 
+        [Cached]
+        private readonly BeatmapLookupCache beatmapLookupCache = new BeatmapLookupCache();
+
         private ResultsScreen resultsScreen = null!;
 
         private int lowestScoreId; // Score ID of the lowest score in the list.
@@ -41,6 +47,11 @@ namespace osu.Game.Tests.Visual.Playlists
         private int totalCount;
         private ScoreInfo userScore = null!;
 
+        public TestScenePlaylistsResultsScreen()
+        {
+            Add(beatmapLookupCache);
+        }
+
         [SetUpSteps]
         public override void SetUpSteps()
         {
@@ -58,9 +69,11 @@ namespace osu.Game.Tests.Visual.Playlists
                 totalCount = 0;
 
                 userScore = TestResources.CreateTestScoreInfo();
+                userScore.OnlineID = 1;
                 userScore.TotalScore = 0;
                 userScore.Statistics = new Dictionary<HitResult, int>();
                 userScore.MaximumStatistics = new Dictionary<HitResult, int>();
+                userScore.Position = real_user_position;
 
                 // Beatmap is required to be an actual beatmap so the scores can get their scores correctly
                 // calculated for standardised scoring, else the tests that rely on ordering will fall over.
@@ -143,13 +156,13 @@ namespace osu.Game.Tests.Visual.Playlists
                 AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
                 AddStep("scroll to right", () => resultsScreen.ChildrenOfType<ScorePanelList>().Single().ChildrenOfType<OsuScrollContainer>().Single().ScrollToEnd(false));
 
-                AddAssert("right loading spinner shown", () =>
+                AddUntilStep("right loading spinner shown", () =>
                     resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreRight).State.Value == Visibility.Visible);
 
                 waitForDisplay();
 
                 AddAssert($"count increased by {scores_per_result}", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount + scores_per_result);
-                AddAssert("right loading spinner hidden", () =>
+                AddUntilStep("right loading spinner hidden", () =>
                     resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreRight).State.Value == Visibility.Hidden);
             }
         }
@@ -167,26 +180,26 @@ namespace osu.Game.Tests.Visual.Playlists
             AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
             AddStep("scroll to right", () => resultsScreen.ChildrenOfType<ScorePanelList>().Single().ChildrenOfType<OsuScrollContainer>().Single().ScrollToEnd(false));
 
-            AddAssert("right loading spinner shown", () =>
+            AddUntilStep("right loading spinner shown", () =>
                 resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreRight).State.Value == Visibility.Visible);
 
             waitForDisplay();
 
             AddAssert($"count increased by {scores_per_result}", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount + scores_per_result);
-            AddAssert("right loading spinner hidden", () =>
+            AddUntilStep("right loading spinner hidden", () =>
                 resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreRight).State.Value == Visibility.Hidden);
 
             AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
             AddStep("bind delayed handler with no scores", () => bindHandler(delayed: true, noScores: true));
             AddStep("scroll to right", () => resultsScreen.ChildrenOfType<ScorePanelList>().Single().ChildrenOfType<OsuScrollContainer>().Single().ScrollToEnd(false));
 
-            AddAssert("right loading spinner shown", () =>
+            AddUntilStep("right loading spinner shown", () =>
                 resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreRight).State.Value == Visibility.Visible);
 
             waitForDisplay();
 
             AddAssert("count not increased", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount);
-            AddAssert("right loading spinner hidden", () =>
+            AddUntilStep("right loading spinner hidden", () =>
                 resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreRight).State.Value == Visibility.Hidden);
 
             AddAssert("no placeholders shown", () => this.ChildrenOfType<MessagePlaceholder>().Count(), () => Is.Zero);
@@ -209,13 +222,13 @@ namespace osu.Game.Tests.Visual.Playlists
                 AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
                 AddStep("scroll to left", () => resultsScreen.ChildrenOfType<ScorePanelList>().Single().ChildrenOfType<OsuScrollContainer>().Single().ScrollToStart(false));
 
-                AddAssert("left loading spinner shown", () =>
+                AddUntilStep("left loading spinner shown", () =>
                     resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreLeft).State.Value == Visibility.Visible);
 
                 waitForDisplay();
 
                 AddAssert($"count increased by {scores_per_result}", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount + scores_per_result);
-                AddAssert("left loading spinner hidden", () =>
+                AddUntilStep("left loading spinner hidden", () =>
                     resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreLeft).State.Value == Visibility.Hidden);
             }
         }
@@ -229,7 +242,36 @@ namespace osu.Game.Tests.Visual.Playlists
             AddStep("bind user score info handler", () => bindHandler(noScores: true));
             createUserBestResults();
             AddAssert("no scores visible", () => !resultsScreen.ChildrenOfType<ScorePanelList>().Single().GetScorePanels().Any());
-            AddAssert("placeholder shown", () => this.ChildrenOfType<MessagePlaceholder>().Count(), () => Is.EqualTo(1));
+            AddUntilStep("placeholder shown", () => this.ChildrenOfType<MessagePlaceholder>().Count(), () => Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestFetchingAllTheWayToFirstNeverDisplaysNegativePosition()
+        {
+            AddStep("set user position", () => userScore.Position = 20);
+            AddStep("bind user score info handler", () => bindHandler(userScore: userScore));
+
+            createResultsWithScore(() => userScore);
+            waitForDisplay();
+
+            AddStep("bind delayed handler", () => bindHandler(true));
+
+            for (int i = 0; i < 2; i++)
+            {
+                AddStep("simulate user falling down ranking", () => userScore.Position += 2);
+                AddStep("scroll to left", () => resultsScreen.ChildrenOfType<ScorePanelList>().Single().ChildrenOfType<OsuScrollContainer>().Single().ScrollToStart(false));
+
+                AddUntilStep("left loading spinner shown", () =>
+                    resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreLeft).State.Value == Visibility.Visible);
+
+                waitForDisplay();
+
+                AddUntilStep("left loading spinner hidden", () =>
+                    resultsScreen.ChildrenOfType<LoadingSpinner>().Single(l => l.Anchor == Anchor.CentreLeft).State.Value == Visibility.Hidden);
+            }
+
+            AddAssert("total count is 34", () => this.ChildrenOfType<ScorePanel>().Count(), () => Is.EqualTo(34));
+            AddUntilStep("all panels have non-negative position", () => this.ChildrenOfType<ScorePanel>().All(p => p.ScorePosition.Value > 0));
         }
 
         private void createResultsWithScore(Func<ScoreInfo> getScore)
@@ -279,6 +321,25 @@ namespace osu.Game.Tests.Visual.Playlists
                 case IndexPlaylistScoresRequest:
                     break;
 
+                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;
+
                 default:
                     return false;
             }
@@ -301,7 +362,7 @@ namespace osu.Game.Tests.Visual.Playlists
                         if (userScore == null)
                             triggerFail(s);
                         else
-                            triggerSuccess(s, createUserResponse(userScore));
+                            triggerSuccess(s, () => createUserResponse(userScore));
 
                         break;
 
@@ -309,12 +370,12 @@ namespace osu.Game.Tests.Visual.Playlists
                         if (userScore == null)
                             triggerFail(u);
                         else
-                            triggerSuccess(u, createUserResponse(userScore));
+                            triggerSuccess(u, () => createUserResponse(userScore));
 
                         break;
 
                     case IndexPlaylistScoresRequest i:
-                        triggerSuccess(i, createIndexResponse(i, noScores));
+                        triggerSuccess(i, () => createIndexResponse(i, noScores));
                         break;
                 }
             }, delay);
@@ -322,11 +383,11 @@ namespace osu.Game.Tests.Visual.Playlists
             return true;
         };
 
-        private void triggerSuccess<T>(APIRequest<T> req, T result)
+        private void triggerSuccess<T>(APIRequest<T> req, Func<T> result)
             where T : class
         {
             requestComplete = true;
-            req.TriggerSuccess(result);
+            req.TriggerSuccess(result.Invoke());
         }
 
         private void triggerFail(APIRequest req)
@@ -337,33 +398,20 @@ namespace osu.Game.Tests.Visual.Playlists
 
         private MultiplayerScore createUserResponse(ScoreInfo userScore)
         {
-            var multiplayerUserScore = new MultiplayerScore
-            {
-                ID = highestScoreId,
-                Accuracy = userScore.Accuracy,
-                Passed = userScore.Passed,
-                Rank = userScore.Rank,
-                Position = real_user_position,
-                MaxCombo = userScore.MaxCombo,
-                User = userScore.User,
-                ScoresAround = new MultiplayerScoresAround
-                {
-                    Higher = new MultiplayerScores(),
-                    Lower = new MultiplayerScores()
-                }
-            };
+            var multiplayerUserScore = createMultiplayerUserScore(userScore);
 
             totalCount++;
 
             for (int i = 1; i <= scores_per_result; i++)
             {
-                multiplayerUserScore.ScoresAround.Lower.Scores.Add(new MultiplayerScore
+                multiplayerUserScore.ScoresAround!.Lower!.Scores.Add(new MultiplayerScore
                 {
                     ID = getNextLowestScoreId(),
                     Accuracy = userScore.Accuracy,
                     Passed = true,
                     Rank = userScore.Rank,
                     MaxCombo = userScore.MaxCombo,
+                    BeatmapId = RNG.Next(0, 7),
                     User = new APIUser
                     {
                         Id = 2 + i,
@@ -372,13 +420,14 @@ namespace osu.Game.Tests.Visual.Playlists
                     },
                 });
 
-                multiplayerUserScore.ScoresAround.Higher.Scores.Add(new MultiplayerScore
+                multiplayerUserScore.ScoresAround!.Higher!.Scores.Add(new MultiplayerScore
                 {
                     ID = getNextHighestScoreId(),
                     Accuracy = userScore.Accuracy,
                     Passed = true,
                     Rank = userScore.Rank,
                     MaxCombo = userScore.MaxCombo,
+                    BeatmapId = RNG.Next(0, 7),
                     User = new APIUser
                     {
                         Id = 2 + i,
@@ -390,13 +439,33 @@ namespace osu.Game.Tests.Visual.Playlists
                 totalCount += 2;
             }
 
-            addCursor(multiplayerUserScore.ScoresAround.Lower);
-            addCursor(multiplayerUserScore.ScoresAround.Higher);
+            addCursor(multiplayerUserScore.ScoresAround!.Lower!);
+            addCursor(multiplayerUserScore.ScoresAround!.Higher!);
 
             return multiplayerUserScore;
         }
 
-        private IndexedMultiplayerScores createIndexResponse(IndexPlaylistScoresRequest req, bool noScores = false)
+        private MultiplayerScore createMultiplayerUserScore(ScoreInfo userScore)
+        {
+            return new MultiplayerScore
+            {
+                ID = highestScoreId,
+                Accuracy = userScore.Accuracy,
+                Passed = userScore.Passed,
+                Rank = userScore.Rank,
+                Position = userScore.Position,
+                MaxCombo = userScore.MaxCombo,
+                User = userScore.User,
+                BeatmapId = RNG.Next(0, 7),
+                ScoresAround = new MultiplayerScoresAround
+                {
+                    Higher = new MultiplayerScores(),
+                    Lower = new MultiplayerScores()
+                }
+            };
+        }
+
+        private IndexedMultiplayerScores createIndexResponse(IndexPlaylistScoresRequest req, bool noScores)
         {
             var result = new IndexedMultiplayerScores();
 
@@ -404,15 +473,26 @@ namespace osu.Game.Tests.Visual.Playlists
 
             string sort = req.IndexParams?.Properties["sort"].ToObject<string>() ?? "score_desc";
 
+            bool reachedEnd = false;
+
             for (int i = 1; i <= scores_per_result; i++)
             {
+                int nextId = sort == "score_asc" ? getNextHighestScoreId() : getNextLowestScoreId();
+
+                if (userScore.OnlineID - nextId >= userScore.Position)
+                {
+                    reachedEnd = true;
+                    break;
+                }
+
                 result.Scores.Add(new MultiplayerScore
                 {
-                    ID = sort == "score_asc" ? getNextHighestScoreId() : getNextLowestScoreId(),
+                    ID = nextId,
                     Accuracy = 1,
                     Passed = true,
                     Rank = ScoreRank.X,
                     MaxCombo = 1000,
+                    BeatmapId = RNG.Next(0, 7),
                     User = new APIUser
                     {
                         Id = 2 + i,
@@ -424,7 +504,10 @@ namespace osu.Game.Tests.Visual.Playlists
                 totalCount++;
             }
 
-            addCursor(result);
+            if (!reachedEnd)
+                addCursor(result);
+
+            result.UserScore = createMultiplayerUserScore(userScore);
 
             return result;
         }
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomCreation.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomCreation.cs
index 0270840597..a748d61d44 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomCreation.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomCreation.cs
@@ -35,6 +35,7 @@ namespace osu.Game.Tests.Visual.Playlists
         private BeatmapManager manager = null!;
         private TestPlaylistsRoomSubScreen match = null!;
         private BeatmapSetInfo importedBeatmap = null!;
+        private Room room = null!;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
@@ -47,11 +48,9 @@ namespace osu.Game.Tests.Visual.Playlists
         [SetUpSteps]
         public void SetupSteps()
         {
-            AddStep("set room", () => SelectedRoom.Value = new Room());
-
             importBeatmap();
 
-            AddStep("load match", () => LoadScreen(match = new TestPlaylistsRoomSubScreen(SelectedRoom.Value!)));
+            AddStep("load match", () => LoadScreen(match = new TestPlaylistsRoomSubScreen(room = new Room())));
             AddUntilStep("wait for load", () => match.IsCurrentScreen());
         }
 
@@ -119,7 +118,7 @@ namespace osu.Game.Tests.Visual.Playlists
                 ];
             });
 
-            AddAssert("first playlist item selected", () => match.SelectedItem.Value == SelectedRoom.Value!.Playlist[0]);
+            AddAssert("first playlist item selected", () => match.SelectedItem.Value == room.Playlist[0]);
         }
 
         [Test]
@@ -197,10 +196,9 @@ namespace osu.Game.Tests.Visual.Playlists
             AddUntilStep("match has correct beatmap", () => realHash == match.Beatmap.Value.BeatmapInfo.MD5Hash);
         }
 
-        private void setupAndCreateRoom(Action<Room> room)
+        private void setupAndCreateRoom(Action<Room> setupFunc)
         {
-            AddStep("setup room", () => room(SelectedRoom.Value!));
-
+            AddStep("setup room", () => setupFunc(room));
             AddStep("click create button", () =>
             {
                 InputManager.MoveMouseTo(this.ChildrenOfType<PlaylistsRoomSettingsOverlay.CreateRoomButton>().Single());
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneExpandedPanelMiddleContent.cs b/osu.Game.Tests/Visual/Ranking/TestSceneExpandedPanelMiddleContent.cs
index 02a321d22f..eade5aaf5d 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneExpandedPanelMiddleContent.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneExpandedPanelMiddleContent.cs
@@ -80,7 +80,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 showPanel(TestResources.CreateTestScoreInfo(beatmap));
             });
 
-            AddAssert("pp display faded out", () =>
+            AddUntilStep("pp display faded out", () =>
             {
                 var ppDisplay = this.ChildrenOfType<PerformanceStatistic>().Single();
                 return ppDisplay.Alpha == 0.5 && ppDisplay.TooltipText == ResultsScreenStrings.NoPPForUnrankedBeatmaps;
@@ -97,7 +97,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 showPanel(score);
             });
 
-            AddAssert("pp display faded out", () =>
+            AddUntilStep("pp display faded out", () =>
             {
                 var ppDisplay = this.ChildrenOfType<PerformanceStatistic>().Single();
                 return ppDisplay.Alpha == 0.5 && ppDisplay.TooltipText == ResultsScreenStrings.NoPPForUnrankedMods;
@@ -116,7 +116,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 showPanel(score);
             });
 
-            AddAssert("pp display faded out", () => this.ChildrenOfType<PerformanceStatistic>().Single().Alpha == 1);
+            AddUntilStep("pp display faded out", () => this.ChildrenOfType<PerformanceStatistic>().Single().Alpha == 1);
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneResultsScreen.cs b/osu.Game.Tests/Visual/Ranking/TestSceneResultsScreen.cs
index 3a08756090..b19288fd99 100644
--- a/osu.Game.Tests/Visual/Ranking/TestSceneResultsScreen.cs
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneResultsScreen.cs
@@ -4,7 +4,6 @@
 #nullable disable
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using NUnit.Framework;
@@ -17,7 +16,6 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Online.API;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Osu;
@@ -416,21 +414,19 @@ namespace osu.Game.Tests.Visual.Ranking
                 RetryOverlay = InternalChildren.OfType<HotkeyRetryOverlay>().SingleOrDefault();
             }
 
-            protected override APIRequest FetchScores(Action<IEnumerable<ScoreInfo>> scoresCallback)
+            protected override Task<ScoreInfo[]> FetchScores()
             {
-                var scores = new List<ScoreInfo>();
+                var scores = new ScoreInfo[20];
 
-                for (int i = 0; i < 20; i++)
+                for (int i = 0; i < scores.Length; i++)
                 {
                     var score = TestResources.CreateTestScoreInfo();
                     score.TotalScore += 10 - i;
                     score.HasOnlineReplay = true;
-                    scores.Add(score);
+                    scores[i] = score;
                 }
 
-                scoresCallback.Invoke(scores);
-
-                return null;
+                return Task.FromResult(scores);
             }
         }
 
@@ -446,27 +442,25 @@ namespace osu.Game.Tests.Visual.Ranking
                 this.fetchWaitTask = fetchWaitTask ?? Task.CompletedTask;
             }
 
-            protected override APIRequest FetchScores(Action<IEnumerable<ScoreInfo>> scoresCallback)
+            protected override Task<ScoreInfo[]> FetchScores()
             {
-                Task.Run(async () =>
+                return Task.Run(async () =>
                 {
                     await fetchWaitTask;
 
-                    var scores = new List<ScoreInfo>();
+                    var scores = new ScoreInfo[20];
 
-                    for (int i = 0; i < 20; i++)
+                    for (int i = 0; i < scores.Length; i++)
                     {
                         var score = TestResources.CreateTestScoreInfo();
                         score.TotalScore += 10 - i;
-                        scores.Add(score);
+                        scores[i] = score;
                     }
 
-                    scoresCallback?.Invoke(scores);
-
                     Schedule(() => FetchCompleted = true);
-                });
 
-                return null;
+                    return scores;
+                });
             }
         }
 
diff --git a/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs b/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
new file mode 100644
index 0000000000..ebfd553815
--- /dev/null
+++ b/osu.Game.Tests/Visual/Ranking/TestSceneUserTagControl.cs
@@ -0,0 +1,85 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Screens.Ranking;
+
+namespace osu.Game.Tests.Visual.Ranking
+{
+    public partial class TestSceneUserTagControl : OsuTestScene
+    {
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("set up working beatmap", () =>
+            {
+                Beatmap.Value.BeatmapInfo.OnlineID = 42;
+            });
+            AddStep("set up network requests", () =>
+            {
+                dummyAPI.HandleRequest = request =>
+                {
+                    switch (request)
+                    {
+                        case ListTagsRequest listTagsRequest:
+                        {
+                            Scheduler.AddDelayed(() => listTagsRequest.TriggerSuccess(new APITagCollection
+                            {
+                                Tags =
+                                [
+                                    new APITag { Id = 1, Name = "tech", Description = "Tests uncommon skills.", },
+                                    new APITag { Id = 2, Name = "alt", Description = "Colloquial term for maps which use rhythms that encourage the player to alternate notes. Typically distinct from burst or stream maps.", },
+                                    new APITag { Id = 3, Name = "aim", Description = "Category for difficulty relating to cursor movement.", },
+                                    new APITag { Id = 4, Name = "tap", Description = "Category for difficulty relating to tapping input.", },
+                                ]
+                            }), 500);
+                            return true;
+                        }
+
+                        case GetBeatmapSetRequest getBeatmapSetRequest:
+                        {
+                            var beatmapSet = CreateAPIBeatmapSet(Beatmap.Value.BeatmapInfo);
+                            beatmapSet.Beatmaps.Single().TopTags =
+                            [
+                                new APIBeatmapTag { TagId = 3, VoteCount = 9 },
+                            ];
+                            Scheduler.AddDelayed(() => getBeatmapSetRequest.TriggerSuccess(beatmapSet), 500);
+                            return true;
+                        }
+
+                        case AddBeatmapTagRequest:
+                        case RemoveBeatmapTagRequest:
+                        {
+                            Scheduler.AddDelayed(request.TriggerSuccess, 500);
+                            return true;
+                        }
+                    }
+
+                    return false;
+                };
+            });
+            AddStep("create control", () =>
+            {
+                Child = new PopoverContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = new UserTagControl
+                    {
+                        Width = 500,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                };
+            });
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs b/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs
index 5ca08e0bba..9f0dc75f84 100644
--- a/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs
+++ b/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs
@@ -136,6 +136,13 @@ namespace osu.Game.Tests.Visual.Settings
 
             public Bindable<float> Rotation { get; } = new Bindable<float>();
 
+            public BindableFloat PressureThreshold { get; } = new BindableFloat
+            {
+                MinValue = 0f,
+                MaxValue = 1f,
+                Precision = 0.005f,
+            };
+
             public IBindable<TabletInfo> Tablet => tablet;
 
             private readonly Bindable<TabletInfo> tablet = new Bindable<TabletInfo>();
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs
index c234cc8a9c..62ca8bf831 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs
@@ -12,6 +12,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.Cursor;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Leaderboards;
 using osu.Game.Overlays;
@@ -20,14 +22,16 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Scoring;
+using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Tests.Resources;
 using osu.Game.Users;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.SongSelect
 {
-    public partial class TestSceneBeatmapLeaderboard : OsuTestScene
+    public partial class TestSceneBeatmapLeaderboard : OsuManualInputManagerTestScene
     {
         private readonly FailableLeaderboard leaderboard;
 
@@ -37,6 +41,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         private ScoreManager scoreManager = null!;
         private RulesetStore rulesetStore = null!;
         private BeatmapManager beatmapManager = null!;
+        private PlaySongSelect songSelect = null!;
 
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
@@ -45,25 +50,36 @@ namespace osu.Game.Tests.Visual.SongSelect
             dependencies.Cache(rulesetStore = new RealmRulesetStore(Realm));
             dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, Realm, null, dependencies.Get<AudioManager>(), Resources, dependencies.Get<GameHost>(), Beatmap.Default));
             dependencies.Cache(scoreManager = new ScoreManager(rulesetStore, () => beatmapManager, LocalStorage, Realm, API));
+            dependencies.CacheAs<Screens.Select.SongSelect>(songSelect = new PlaySongSelect());
             Dependencies.Cache(Realm);
 
             return dependencies;
         }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            LoadComponent(songSelect);
+        }
+
         public TestSceneBeatmapLeaderboard()
         {
-            AddRange(new Drawable[]
+            Add(new OsuContextMenuContainer
             {
-                dialogOverlay = new DialogOverlay
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
                 {
-                    Depth = -1
-                },
-                leaderboard = new FailableLeaderboard
-                {
-                    Origin = Anchor.Centre,
-                    Anchor = Anchor.Centre,
-                    Size = new Vector2(550f, 450f),
-                    Scope = BeatmapLeaderboardScope.Global,
+                    dialogOverlay = new DialogOverlay
+                    {
+                        Depth = -1
+                    },
+                    leaderboard = new FailableLeaderboard
+                    {
+                        Origin = Anchor.Centre,
+                        Anchor = Anchor.Centre,
+                        Size = new Vector2(550f, 450f),
+                        Scope = BeatmapLeaderboardScope.Global,
+                    }
                 }
             });
         }
@@ -165,6 +181,11 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             AddStep(@"Set scope", () => leaderboard.Scope = BeatmapLeaderboardScope.Global);
             AddStep(@"New Scores", () => leaderboard.SetScores(generateSampleScores(new BeatmapInfo())));
+            AddStep(@"New Scores with teams", () => leaderboard.SetScores(generateSampleScores(new BeatmapInfo()).Select(s =>
+            {
+                s.User.Team = new APITeam();
+                return s;
+            })));
         }
 
         [Test]
@@ -187,6 +208,40 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep(@"None selected", () => leaderboard.SetErrorState(LeaderboardState.NoneSelected));
         }
 
+        [Test]
+        public void TestUseTheseModsDoesNotCopySystemMods()
+        {
+            AddStep(@"set scores", () => leaderboard.SetScores(leaderboard.Scores, new ScoreInfo
+            {
+                Position = 999,
+                Rank = ScoreRank.XH,
+                Accuracy = 1,
+                MaxCombo = 244,
+                TotalScore = 1707827,
+                Ruleset = new OsuRuleset().RulesetInfo,
+                Mods = new Mod[] { new OsuModHidden(), new ModScoreV2(), },
+                User = new APIUser
+                {
+                    Id = 6602580,
+                    Username = @"waaiiru",
+                    CountryCode = CountryCode.ES,
+                }
+            }));
+            AddUntilStep("wait for scores", () => this.ChildrenOfType<LeaderboardScore>().Count(), () => Is.GreaterThan(0));
+            AddStep("right click panel", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<LeaderboardScore>().Single());
+                InputManager.Click(MouseButton.Right);
+            });
+            AddStep("click use these mods", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<DrawableOsuMenuItem>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+            AddAssert("song select received HD", () => songSelect.Mods.Value.Any(m => m is OsuModHidden));
+            AddAssert("song select did not receive SV2", () => !songSelect.Mods.Value.Any(m => m is ModScoreV2));
+        }
+
         private void showPersonalBestWithNullPosition()
         {
             leaderboard.SetScores(leaderboard.Scores, new ScoreInfo
@@ -423,7 +478,7 @@ namespace osu.Game.Tests.Visual.SongSelect
                     Accuracy = 0.5140,
                     MaxCombo = 244,
                     TotalScore = 1707827,
-                    Date = DateTime.Now.AddMonths(-3),
+                    Date = DateTime.Now.AddMonths(-10),
                     Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
                     BeatmapInfo = beatmapInfo,
                     BeatmapHash = beatmapInfo.Hash,
diff --git a/osu.Game.Tests/Visual/SongSelectV2/SongSelectComponentsTestScene.cs b/osu.Game.Tests/Visual/SongSelectV2/SongSelectComponentsTestScene.cs
index b7b0101a7c..8694722acc 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/SongSelectComponentsTestScene.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/SongSelectComponentsTestScene.cs
@@ -6,16 +6,17 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Testing;
+using osu.Game.Graphics.Cursor;
 using osu.Game.Overlays;
 
 namespace osu.Game.Tests.Visual.SongSelectV2
 {
-    public abstract partial class SongSelectComponentsTestScene : OsuTestScene
+    public abstract partial class SongSelectComponentsTestScene : OsuManualInputManagerTestScene
     {
         [Cached]
         protected readonly OverlayColourProvider ColourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
 
-        protected override Container<Drawable> Content { get; } = new Container
+        protected override Container<Drawable> Content { get; } = new OsuContextMenuContainer
         {
             RelativeSizeAxes = Axes.X,
             AutoSizeAxes = Axes.Y,
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneLeaderboardScore.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneLeaderboardScore.cs
index a7d0d70c03..26d39c9203 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneLeaderboardScore.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneLeaderboardScore.cs
@@ -7,9 +7,11 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Rulesets.Mania;
@@ -22,6 +24,7 @@ using osu.Game.Screens.SelectV2.Leaderboards;
 using osu.Game.Tests.Resources;
 using osu.Game.Users;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.SongSelectV2
 {
@@ -102,6 +105,69 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             });
         }
 
+        [Test]
+        public void TestUseTheseModsDoesNotCopySystemMods()
+        {
+            LeaderboardScoreV2 score = null!;
+
+            AddStep("create content", () =>
+            {
+                Children = new Drawable[]
+                {
+                    fillFlow = new FillFlowContainer
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Spacing = new Vector2(0f, 2f),
+                        Shear = new Vector2(OsuGame.SHEAR, 0)
+                    },
+                    drawWidthText = new OsuSpriteText(),
+                };
+
+                var scoreInfo = new ScoreInfo
+                {
+                    Position = 999,
+                    Rank = ScoreRank.X,
+                    Accuracy = 1,
+                    MaxCombo = 244,
+                    TotalScore = RNG.Next(1_800_000, 2_000_000),
+                    MaximumStatistics = { { HitResult.Great, 3000 } },
+                    Mods = new Mod[] { new OsuModHidden(), new ModScoreV2(), },
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                    User = new APIUser
+                    {
+                        Id = 6602580,
+                        Username = @"waaiiru",
+                        CountryCode = CountryCode.ES,
+                        CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c1.jpg",
+                    },
+                    Date = DateTimeOffset.Now.AddYears(-2),
+                };
+
+                fillFlow.Add(score = new LeaderboardScoreV2(scoreInfo)
+                {
+                    Rank = scoreInfo.Position,
+                    Shear = Vector2.Zero,
+                });
+
+                score.Show();
+            });
+            AddStep("right click panel", () =>
+            {
+                InputManager.MoveMouseTo(score);
+                InputManager.Click(MouseButton.Right);
+            });
+            AddStep("click use these mods", () =>
+            {
+                InputManager.MoveMouseTo(this.ChildrenOfType<DrawableOsuMenuItem>().Single());
+                InputManager.Click(MouseButton.Left);
+            });
+            AddAssert("mods received HD", () => score.SelectedMods.Value.Any(m => m is OsuModHidden));
+            AddAssert("mods did not receive SV2", () => !score.SelectedMods.Value.Any(m => m is ModScoreV2));
+        }
+
         public override void SetUpSteps()
         {
             AddToggleStep("toggle scoring mode", v => config.SetValue(OsuSetting.ScoreDisplayMode, v ? ScoringMode.Classic : ScoringMode.Standardised));
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
index 33474d7449..630f3c95ee 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelect.cs
@@ -9,16 +9,10 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
-using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps;
-using osu.Game.Configuration;
 using osu.Game.Database;
-using osu.Game.Online.API;
-using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
-using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mods;
@@ -29,7 +23,6 @@ using osu.Game.Screens;
 using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
 using osu.Game.Screens.SelectV2.Footer;
-using osu.Game.Tests.Resources;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.SongSelectV2
@@ -42,8 +35,6 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         [Cached]
         private readonly OsuLogo logo;
 
-        private BeatmapManager beatmapManager = null!;
-
         protected override bool UseOnlineAPI => true;
 
         public TestSceneSongSelect()
@@ -66,32 +57,12 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         }
 
         [BackgroundDependencyLoader]
-        private void load(GameHost host, IAPIProvider onlineAPI)
+        private void load()
         {
-            BeatmapStore beatmapStore;
-            BeatmapUpdater beatmapUpdater;
-            BeatmapDifficultyCache difficultyCache;
+            RealmDetachedBeatmapStore beatmapStore;
 
-            // These DI caches are required to ensure for interactive runs this test scene doesn't nuke all user beatmaps in the local install.
-            // At a point we have isolated interactive test runs enough, this can likely be removed.
-            Dependencies.Cache(new RealmRulesetStore(Realm));
-            Dependencies.Cache(Realm);
-            Dependencies.Cache(difficultyCache = new BeatmapDifficultyCache());
-            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, Realm, onlineAPI, Audio, Resources, host, Beatmap.Default, difficultyCache));
-            Dependencies.CacheAs(beatmapUpdater = new BeatmapUpdater(beatmapManager, difficultyCache, onlineAPI, LocalStorage));
-            Dependencies.CacheAs(beatmapStore = new RealmDetachedBeatmapStore());
-
-            beatmapManager.ProcessBeatmap = (set, scope) => beatmapUpdater.Process(set, scope);
-
-            MusicController music;
-            Dependencies.Cache(music = new MusicController());
-
-            // required to get bindables attached
-            Add(difficultyCache);
-            Add(music);
+            Dependencies.CacheAs<BeatmapStore>(beatmapStore = new RealmDetachedBeatmapStore());
             Add(beatmapStore);
-
-            Dependencies.Cache(new OsuConfigManager(LocalStorage));
         }
 
         protected override void LoadComplete()
@@ -107,9 +78,8 @@ namespace osu.Game.Tests.Visual.SongSelectV2
         {
             base.SetUpSteps();
 
-            AddStep("load screen", () => Stack.Push(new Screens.SelectV2.SongSelectV2()));
-            AddUntilStep("wait for load", () => Stack.CurrentScreen is Screens.SelectV2.SongSelectV2 songSelect && songSelect.IsLoaded);
-            AddStep("import test beatmap", () => beatmapManager.Import(TestResources.GetTestBeatmapForImport()));
+            AddStep("load screen", () => Stack.Push(new Screens.SelectV2.SoloSongSelect()));
+            AddUntilStep("wait for load", () => Stack.CurrentScreen is Screens.SelectV2.SongSelect songSelect && songSelect.IsLoaded);
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectNavigation.cs b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectNavigation.cs
index 5173cb5673..a7ca3cd18c 100644
--- a/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectNavigation.cs
+++ b/osu.Game.Tests/Visual/SongSelectV2/TestSceneSongSelectNavigation.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Tests.Visual.SongSelectV2
             base.SetUpSteps();
             AddStep("press enter", () => InputManager.Key(Key.Enter));
             AddWaitStep("wait", 5);
-            PushAndConfirm(() => new Screens.SelectV2.SongSelectV2());
+            PushAndConfirm(() => new Screens.SelectV2.SoloSongSelect());
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/TestMultiplayerComponents.cs b/osu.Game.Tests/Visual/TestMultiplayerComponents.cs
index 1814fb70c8..e385ff3a03 100644
--- a/osu.Game.Tests/Visual/TestMultiplayerComponents.cs
+++ b/osu.Game.Tests/Visual/TestMultiplayerComponents.cs
@@ -11,7 +11,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Online.API;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Screens;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Tests.Visual.Multiplayer;
 using osu.Game.Tests.Visual.OnlinePlay;
 
@@ -26,15 +25,12 @@ namespace osu.Game.Tests.Visual
     /// <item>Provides a <see cref="TestMultiplayerClient"/> to be resolved as a dependency in the <see cref="Screens.OnlinePlay.Multiplayer.Multiplayer"/> screen,
     /// which is typically a part of <see cref="OsuGameBase"/>.</item>
     /// <item>Rebinds the <see cref="DummyAPIAccess"/> to handle requests via a <see cref="TestRoomRequestsHandler"/>.</item>
-    /// <item>Provides a <see cref="TestMultiplayerRoomManager"/> for the <see cref="Screens.OnlinePlay.Multiplayer.Multiplayer"/> screen.</item>
     /// </list>
     /// </p>
     /// </summary>
     public partial class TestMultiplayerComponents : OsuScreen
     {
-        public Screens.OnlinePlay.Multiplayer.Multiplayer MultiplayerScreen => multiplayerScreen;
-
-        public TestMultiplayerRoomManager RoomManager => multiplayerScreen.RoomManager;
+        public Screens.OnlinePlay.Multiplayer.Multiplayer MultiplayerScreen { get; }
 
         public IScreen CurrentScreen => screenStack.CurrentScreen;
 
@@ -53,17 +49,17 @@ namespace osu.Game.Tests.Visual
         private BeatmapManager beatmapManager { get; set; }
 
         private readonly OsuScreenStack screenStack;
-        private readonly TestMultiplayer multiplayerScreen;
+        private readonly TestRoomRequestsHandler requestsHandler = new TestRoomRequestsHandler();
 
         public TestMultiplayerComponents()
         {
-            multiplayerScreen = new TestMultiplayer();
+            MultiplayerScreen = new Screens.OnlinePlay.Multiplayer.Multiplayer();
 
             InternalChildren = new Drawable[]
             {
                 userLookupCache,
                 beatmapLookupCache,
-                MultiplayerClient = new TestMultiplayerClient(RoomManager),
+                MultiplayerClient = new TestMultiplayerClient(requestsHandler),
                 screenStack = new OsuScreenStack
                 {
                     Name = nameof(TestMultiplayerComponents),
@@ -71,13 +67,13 @@ namespace osu.Game.Tests.Visual
                 }
             };
 
-            screenStack.Push(multiplayerScreen);
+            screenStack.Push(MultiplayerScreen);
         }
 
         [BackgroundDependencyLoader]
         private void load(IAPIProvider api)
         {
-            ((DummyAPIAccess)api).HandleRequest = request => multiplayerScreen.RequestsHandler.HandleRequest(request, api.LocalUser.Value, beatmapManager);
+            ((DummyAPIAccess)api).HandleRequest = request => requestsHandler.HandleRequest(request, api.LocalUser.Value, beatmapManager);
         }
 
         public override bool OnBackButton() => (screenStack.CurrentScreen as OsuScreen)?.OnBackButton() ?? base.OnBackButton();
@@ -90,13 +86,5 @@ namespace osu.Game.Tests.Visual
             screenStack.Exit();
             return true;
         }
-
-        private partial class TestMultiplayer : Screens.OnlinePlay.Multiplayer.Multiplayer
-        {
-            public new TestMultiplayerRoomManager RoomManager { get; private set; }
-            public TestRoomRequestsHandler RequestsHandler { get; private set; }
-
-            protected override RoomManager CreateRoomManager() => RoomManager = new TestMultiplayerRoomManager(RequestsHandler = new TestRoomRequestsHandler());
-        }
     }
 }
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneModDifficultyAdjustSettings.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneModDifficultyAdjustSettings.cs
index b40d0b10d2..30470c9c17 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneModDifficultyAdjustSettings.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneModDifficultyAdjustSettings.cs
@@ -18,6 +18,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osuTK;
 using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
@@ -220,6 +221,29 @@ namespace osu.Game.Tests.Visual.UserInterface
             checkBindableAtValue("Circle Size", null);
         }
 
+        [Test]
+        public void TestResetToDefaultViaDoubleClickingNub()
+        {
+            setBeatmapWithDifficultyParameters(5);
+
+            setSliderValue("Circle Size", 3);
+            setExtendedLimits(true);
+
+            checkSliderAtValue("Circle Size", 3);
+            checkBindableAtValue("Circle Size", 3);
+
+            AddStep("double click circle size nub", () =>
+            {
+                var nub = this.ChildrenOfType<RoundedSliderBar<float>.SliderNub>().First();
+                InputManager.MoveMouseTo(nub);
+                InputManager.Click(MouseButton.Left);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            checkSliderAtValue("Circle Size", 5);
+            checkBindableAtValue("Circle Size", null);
+        }
+
         [Test]
         public void TestModSettingChangeTracker()
         {
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs
index 280497e861..6eb9263c7e 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs
@@ -1030,7 +1030,10 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private partial class TestModSelectOverlay : UserModSelectOverlay
         {
-            protected override bool ShowPresets => true;
+            public TestModSelectOverlay()
+            {
+                ShowPresets = true;
+            }
         }
 
         private class TestUnimplementedMod : Mod
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs
index a4cf8a276f..fc8777068d 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooter.cs
@@ -23,7 +23,7 @@ namespace osu.Game.Tests.Visual.UserInterface
     {
         private DependencyProvidingContainer contentContainer = null!;
         private ScreenFooter screenFooter = null!;
-        private TestModSelectOverlay modOverlay = null!;
+        private UserModSelectOverlay modOverlay = null!;
 
         [SetUp]
         public void SetUp() => Schedule(() =>
@@ -39,7 +39,7 @@ namespace osu.Game.Tests.Visual.UserInterface
                 },
                 Children = new Drawable[]
                 {
-                    modOverlay = new TestModSelectOverlay(),
+                    modOverlay = new UserModSelectOverlay { ShowPresets = true },
                     new PopoverContainer
                     {
                         RelativeSizeAxes = Axes.Both,
@@ -196,11 +196,6 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddAssert("external overlay content still not shown", () => this.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent, () => Is.Not.True);
         }
 
-        private partial class TestModSelectOverlay : UserModSelectOverlay
-        {
-            protected override bool ShowPresets => true;
-        }
-
         private partial class TestShearedOverlayContainer : ShearedOverlayContainer
         {
             public TestShearedOverlayContainer()
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs
index ba53eb83c4..e86f83ee15 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneScreenFooterButtonMods.cs
@@ -115,11 +115,10 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private partial class TestModSelectOverlay : UserModSelectOverlay
         {
-            protected override bool ShowPresets => true;
-
             public TestModSelectOverlay()
                 : base(OverlayColourScheme.Aquamarine)
             {
+                ShowPresets = true;
             }
         }
 
diff --git a/osu.Game/Beatmaps/APIBeatmapTag.cs b/osu.Game/Beatmaps/APIBeatmapTag.cs
new file mode 100644
index 0000000000..5f4f9b851d
--- /dev/null
+++ b/osu.Game/Beatmaps/APIBeatmapTag.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 Newtonsoft.Json;
+
+namespace osu.Game.Beatmaps
+{
+    public class APIBeatmapTag
+    {
+        [JsonProperty("tag_id")]
+        public long TagId { get; set; }
+
+        [JsonProperty("count")]
+        public int VoteCount { get; set; }
+    }
+}
diff --git a/osu.Game/Beatmaps/BeatmapInfoExtensions.cs b/osu.Game/Beatmaps/BeatmapInfoExtensions.cs
index 16b4b04ce4..25f98c812c 100644
--- a/osu.Game/Beatmaps/BeatmapInfoExtensions.cs
+++ b/osu.Game/Beatmaps/BeatmapInfoExtensions.cs
@@ -1,15 +1,28 @@
 // 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.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Screens.Select;
 
 namespace osu.Game.Beatmaps
 {
     public static class BeatmapInfoExtensions
     {
+        /// <summary>
+        /// Given an <see cref="IBeatmap"/>, update length, BPM and object counts.
+        /// </summary>
+        public static void UpdateStatisticsFromBeatmap(this BeatmapInfo beatmapInfo, IBeatmap beatmap)
+        {
+            beatmapInfo.Length = beatmap.CalculatePlayableLength();
+            beatmapInfo.BPM = 60000 / beatmap.GetMostCommonBeatLength();
+            beatmapInfo.EndTimeObjectCount = beatmap.HitObjects.Count(h => h is IHasDuration);
+            beatmapInfo.TotalObjectCount = beatmap.HitObjects.Count;
+        }
+
         /// <summary>
         /// A user-presentable display title representing this beatmap.
         /// </summary>
diff --git a/osu.Game/Beatmaps/BeatmapUpdater.cs b/osu.Game/Beatmaps/BeatmapUpdater.cs
index efb432b84e..64ac69bb07 100644
--- a/osu.Game/Beatmaps/BeatmapUpdater.cs
+++ b/osu.Game/Beatmaps/BeatmapUpdater.cs
@@ -51,7 +51,7 @@ namespace osu.Game.Beatmaps
                 if (lookupScope != MetadataLookupScope.None)
                     metadataLookup.Update(beatmapSet, lookupScope == MetadataLookupScope.OnlineFirst);
 
-                foreach (var beatmap in beatmapSet.Beatmaps)
+                foreach (BeatmapInfo beatmap in beatmapSet.Beatmaps)
                 {
                     difficultyCache.Invalidate(beatmap);
 
@@ -63,10 +63,7 @@ namespace osu.Game.Beatmaps
                     var calculator = ruleset.CreateDifficultyCalculator(working);
 
                     beatmap.StarRating = calculator.Calculate().StarRating;
-                    beatmap.Length = working.Beatmap.CalculatePlayableLength();
-                    beatmap.BPM = 60000 / working.Beatmap.GetMostCommonBeatLength();
-                    beatmap.EndTimeObjectCount = working.Beatmap.HitObjects.Count(h => h is IHasDuration);
-                    beatmap.TotalObjectCount = working.Beatmap.HitObjects.Count;
+                    beatmap.UpdateStatisticsFromBeatmap(working.Beatmap);
                 }
 
                 // And invalidate again afterwards as re-fetching the most up-to-date database metadata will be required.
diff --git a/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs b/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs
index 599d1b380a..7b99ad40de 100644
--- a/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs
+++ b/osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs
@@ -101,7 +101,7 @@ namespace osu.Game.Beatmaps.Drawables
         {
             if (Status == BeatmapOnlineStatus.None)
             {
-                this.FadeOut(animation_duration, Easing.OutQuint);
+                Hide();
                 return;
             }
 
diff --git a/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs b/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
index 07e88ab956..787ae1c222 100644
--- a/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
@@ -319,11 +319,13 @@ namespace osu.Game.Beatmaps.Formats
                 SampleControlPoint createSampleControlPointFor(double time, IList<HitSampleInfo> samples)
                 {
                     int volume = samples.Max(o => o.Volume);
+                    string bank = samples.Where(s => s.Name == HitSampleInfo.HIT_NORMAL).Select(s => s.Bank).FirstOrDefault()
+                                  ?? samples.Select(s => s.Bank).First();
                     int customIndex = samples.Any(o => o is ConvertHitObjectParser.LegacyHitSampleInfo)
                         ? samples.OfType<ConvertHitObjectParser.LegacyHitSampleInfo>().Max(o => o.CustomSampleBank)
                         : -1;
 
-                    return new LegacyBeatmapDecoder.LegacySampleControlPoint { Time = time, SampleVolume = volume, CustomSampleBank = customIndex };
+                    return new LegacyBeatmapDecoder.LegacySampleControlPoint { Time = time, SampleVolume = volume, SampleBank = bank, CustomSampleBank = customIndex };
                 }
             }
 
@@ -349,7 +351,7 @@ namespace osu.Game.Beatmaps.Formats
 
             writer.WriteLine("[Colours]");
 
-            for (int i = 0; i < colours.Count; i++)
+            for (int i = 0; i < Math.Min(colours.Count, LegacyBeatmapDecoder.MAX_COMBO_COLOUR_COUNT); i++)
             {
                 var comboColour = colours[i];
 
diff --git a/osu.Game/Beatmaps/Formats/LegacyDecoder.cs b/osu.Game/Beatmaps/Formats/LegacyDecoder.cs
index ca4fadf458..6c290c4f1c 100644
--- a/osu.Game/Beatmaps/Formats/LegacyDecoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyDecoder.cs
@@ -18,6 +18,8 @@ namespace osu.Game.Beatmaps.Formats
     {
         public const int LATEST_VERSION = 14;
 
+        public const int MAX_COMBO_COLOUR_COUNT = 8;
+
         /// <summary>
         /// The .osu format (beatmap) version.
         ///
@@ -126,7 +128,9 @@ namespace osu.Game.Beatmaps.Formats
             string[] split = pair.Value.Split(',');
             Color4 colour = convertSettingStringToColor4(split, allowAlpha, pair);
 
-            bool isCombo = pair.Key.StartsWith(@"Combo", StringComparison.Ordinal);
+            bool isCombo = pair.Key.StartsWith(@"Combo", StringComparison.Ordinal)
+                           && int.TryParse(pair.Key[5..], out int comboIndex)
+                           && comboIndex >= 1 && comboIndex <= MAX_COMBO_COLOUR_COUNT;
 
             if (isCombo)
             {
diff --git a/osu.Game/Beatmaps/IBeatmap.cs b/osu.Game/Beatmaps/IBeatmap.cs
index 826d4e19a7..f95fcefd7e 100644
--- a/osu.Game/Beatmaps/IBeatmap.cs
+++ b/osu.Game/Beatmaps/IBeatmap.cs
@@ -161,7 +161,7 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// Find the total milliseconds between the first and last hittable objects, excluding any break time.
         /// </summary>
-        public static double CalculateDrainLength(this IBeatmap beatmap) => CalculatePlayableLength(beatmap.HitObjects) - beatmap.TotalBreakTime;
+        public static double CalculateDrainLength(this IBeatmap beatmap) => Math.Max(CalculatePlayableLength(beatmap.HitObjects) - beatmap.TotalBreakTime, 0);
 
         /// <summary>
         /// Find the timestamps in milliseconds of the start and end of the playable region.
diff --git a/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs b/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs
index a1744f74b3..d876ba55b2 100644
--- a/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs
+++ b/osu.Game/Beatmaps/LocalCachedBeatmapMetadataSource.cs
@@ -104,11 +104,6 @@ namespace osu.Game.Beatmaps
 
                     switch (getCacheVersion(db))
                     {
-                        case 1:
-                            // will eventually become irrelevant due to the monthly recycling of local caches
-                            // can be removed 20250221
-                            return queryCacheVersion1(db, beatmapInfo, out onlineMetadata);
-
                         case 2:
                             return queryCacheVersion2(db, beatmapInfo, out onlineMetadata);
                     }
@@ -270,42 +265,6 @@ namespace osu.Game.Beatmaps
             }
         }
 
-        private bool queryCacheVersion1(SqliteConnection db, BeatmapInfo beatmapInfo, out OnlineBeatmapMetadata? onlineMetadata)
-        {
-            Debug.Assert(beatmapInfo.BeatmapSet != null);
-
-            using var cmd = db.CreateCommand();
-
-            cmd.CommandText =
-                @"SELECT beatmapset_id, beatmap_id, approved, user_id, checksum, last_update FROM osu_beatmaps WHERE checksum = @MD5Hash OR filename = @Path";
-
-            cmd.Parameters.Add(new SqliteParameter(@"@MD5Hash", beatmapInfo.MD5Hash));
-            cmd.Parameters.Add(new SqliteParameter(@"@Path", beatmapInfo.Path));
-
-            using var reader = cmd.ExecuteReader();
-
-            if (reader.Read())
-            {
-                logForModel(beatmapInfo.BeatmapSet, $@"Cached local retrieval for {beatmapInfo} (cache version 1).");
-
-                onlineMetadata = new OnlineBeatmapMetadata
-                {
-                    BeatmapSetID = reader.GetInt32(0),
-                    BeatmapID = reader.GetInt32(1),
-                    BeatmapStatus = (BeatmapOnlineStatus)reader.GetByte(2),
-                    BeatmapSetStatus = (BeatmapOnlineStatus)reader.GetByte(2),
-                    AuthorID = reader.GetInt32(3),
-                    MD5Hash = reader.GetString(4),
-                    LastUpdated = reader.GetDateTimeOffset(5),
-                    // TODO: DateSubmitted and DateRanked are not provided by local cache in this version.
-                };
-                return true;
-            }
-
-            onlineMetadata = null;
-            return false;
-        }
-
         private bool queryCacheVersion2(SqliteConnection db, BeatmapInfo beatmapInfo, out OnlineBeatmapMetadata? onlineMetadata)
         {
             Debug.Assert(beatmapInfo.BeatmapSet != null);
@@ -317,8 +276,12 @@ namespace osu.Game.Beatmaps
                 SELECT `b`.`beatmapset_id`, `b`.`beatmap_id`, `b`.`approved`, `b`.`user_id`, `b`.`checksum`, `b`.`last_update`, `s`.`submit_date`, `s`.`approved_date`
                 FROM `osu_beatmaps` AS `b`
                 JOIN `osu_beatmapsets` AS `s` ON `s`.`beatmapset_id` = `b`.`beatmapset_id`
-                WHERE `b`.`checksum` = @MD5Hash OR `b`.`filename` = @Path
+                WHERE (`b`.`checksum` = @MD5Hash OR `b`.`filename` = @Path)
+                AND `b`.`approved` in (1, 2, 4)
                 """;
+            // approved conditional can theoretically be removed as it was fixed in
+            // https://github.com/ppy/osu-onlinedb-generator/commit/489ac000775c3ff63bc914efb83cad0f6fbde261
+            // but it's also safe to leave it (should not affect performance).
 
             cmd.Parameters.Add(new SqliteParameter(@"@MD5Hash", beatmapInfo.MD5Hash));
             cmd.Parameters.Add(new SqliteParameter(@"@Path", beatmapInfo.Path));
diff --git a/osu.Game/Beatmaps/WorkingBeatmap.cs b/osu.Game/Beatmaps/WorkingBeatmap.cs
index fd40097c4e..8df57fd0c8 100644
--- a/osu.Game/Beatmaps/WorkingBeatmap.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmap.cs
@@ -235,11 +235,18 @@ namespace osu.Game.Beatmaps
                     // Todo: Handle cancellation during beatmap parsing
                     var b = GetBeatmap() ?? new Beatmap();
 
-                    // The original beatmap version needs to be preserved as the database doesn't contain it
-                    BeatmapInfo.BeatmapVersion = b.BeatmapInfo.BeatmapVersion;
-
-                    // Use the database-backed info for more up-to-date values (beatmap id, ranked status, etc)
-                    b.BeatmapInfo = BeatmapInfo;
+                    // Copy across values of key properties for which the database-backed model has data that the decoded beatmap isn't going to.
+                    b.BeatmapInfo.ID = BeatmapInfo.ID;
+                    b.BeatmapInfo.UserSettings = BeatmapInfo.UserSettings;
+                    b.BeatmapInfo.BeatmapSet = BeatmapInfo.BeatmapSet;
+                    b.BeatmapInfo.Status = BeatmapInfo.Status;
+                    b.BeatmapInfo.OnlineID = BeatmapInfo.OnlineID;
+                    b.BeatmapInfo.OnlineMD5Hash = BeatmapInfo.OnlineMD5Hash;
+                    b.BeatmapInfo.LastLocalUpdate = BeatmapInfo.LastLocalUpdate;
+                    b.BeatmapInfo.LastOnlineUpdate = BeatmapInfo.LastOnlineUpdate;
+                    b.BeatmapInfo.LastPlayed = BeatmapInfo.LastPlayed;
+                    b.BeatmapInfo.EditorTimestamp = BeatmapInfo.EditorTimestamp;
+                    b.BeatmapInfo.StarRating = BeatmapInfo.StarRating; // this could be recomputed in the decoding process but it's a bit annoying to do.
 
                     return b;
                 }, loadCancellationSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
diff --git a/osu.Game/Beatmaps/WorkingBeatmapCache.cs b/osu.Game/Beatmaps/WorkingBeatmapCache.cs
index 8af74d11d8..30bbbbc1fe 100644
--- a/osu.Game/Beatmaps/WorkingBeatmapCache.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmapCache.cs
@@ -89,7 +89,7 @@ namespace osu.Game.Beatmaps
 
         public virtual WorkingBeatmap GetWorkingBeatmap([CanBeNull] BeatmapInfo beatmapInfo)
         {
-            if (beatmapInfo?.BeatmapSet == null)
+            if (beatmapInfo == null || ReferenceEquals(beatmapInfo, DefaultBeatmap.BeatmapInfo))
                 return DefaultBeatmap;
 
             lock (workingCache)
@@ -152,14 +152,25 @@ namespace osu.Game.Beatmaps
                         return null;
                     }
 
-                    if (stream.ComputeMD5Hash() != BeatmapInfo.MD5Hash)
+                    string streamMD5 = stream.ComputeMD5Hash();
+                    string streamSHA2 = stream.ComputeSHA2Hash();
+
+                    if (streamMD5 != BeatmapInfo.MD5Hash)
                     {
                         Logger.Log($"Beatmap failed to load (file {BeatmapInfo.Path} does not have the expected hash).", level: LogLevel.Error);
                         return null;
                     }
 
                     using (var reader = new LineBufferedReader(stream))
-                        return Decoder.GetDecoder<Beatmap>(reader).Decode(reader);
+                    {
+                        var beatmap = Decoder.GetDecoder<Beatmap>(reader).Decode(reader);
+
+                        beatmap.BeatmapInfo.MD5Hash = streamMD5;
+                        beatmap.BeatmapInfo.Hash = streamSHA2;
+                        beatmap.BeatmapInfo.UpdateStatisticsFromBeatmap(beatmap);
+
+                        return beatmap;
+                    }
                 }
                 catch (Exception e)
                 {
diff --git a/osu.Game/Configuration/SessionStatics.cs b/osu.Game/Configuration/SessionStatics.cs
index d2069e4027..b816d1a88b 100644
--- a/osu.Game/Configuration/SessionStatics.cs
+++ b/osu.Game/Configuration/SessionStatics.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using osu.Framework;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Input;
@@ -27,11 +25,12 @@ namespace osu.Game.Configuration
             SetDefault(Static.FeaturedArtistDisclaimerShownOnce, false);
             SetDefault(Static.LastHoverSoundPlaybackTime, (double?)null);
             SetDefault(Static.LastModSelectPanelSamplePlaybackTime, (double?)null);
-            SetDefault<APISeasonalBackgrounds>(Static.SeasonalBackgrounds, null);
+            SetDefault<APISeasonalBackgrounds?>(Static.SeasonalBackgrounds, null);
             SetDefault(Static.TouchInputActive, RuntimeInfo.IsMobile);
-            SetDefault<ScoreInfo>(Static.LastLocalUserScore, null);
-            SetDefault<ScoreInfo>(Static.LastAppliedOffsetScore, null);
-            SetDefault<UserActivity>(Static.UserOnlineActivity, null);
+            SetDefault<ScoreInfo?>(Static.LastLocalUserScore, null);
+            SetDefault<ScoreInfo?>(Static.LastAppliedOffsetScore, null);
+            SetDefault<UserActivity?>(Static.UserOnlineActivity, null);
+            SetDefault<APITag[]?>(Static.AllBeatmapTags, null);
         }
 
         /// <summary>
@@ -99,5 +98,7 @@ namespace osu.Game.Configuration
         /// The activity for the current user to broadcast to other players.
         /// </summary>
         UserOnlineActivity,
+
+        AllBeatmapTags,
     }
 }
diff --git a/osu.Game/Database/BackgroundDataStoreProcessor.cs b/osu.Game/Database/BackgroundDataStoreProcessor.cs
index 1512b6be93..4e813fa2c7 100644
--- a/osu.Game/Database/BackgroundDataStoreProcessor.cs
+++ b/osu.Game/Database/BackgroundDataStoreProcessor.cs
@@ -76,8 +76,9 @@ namespace osu.Game.Database
             {
                 Logger.Log("Beginning background data store processing..");
 
-                checkForOutdatedStarRatings();
-                processBeatmapSetsWithMissingMetrics();
+                clearOutdatedStarRatings();
+                populateMissingStarRatings();
+                processOnlineBeatmapSetsWithNoUpdate();
                 // Note that the previous method will also update these on a fresh run.
                 processBeatmapsWithMissingObjectCounts();
                 processScoresWithMissingStatistics();
@@ -100,7 +101,7 @@ namespace osu.Game.Database
         /// Check whether the databased difficulty calculation version matches the latest ruleset provided version.
         /// If it doesn't, clear out any existing difficulties so they can be incrementally recalculated.
         /// </summary>
-        private void checkForOutdatedStarRatings()
+        private void clearOutdatedStarRatings()
         {
             foreach (var ruleset in rulesetStore.AvailableRulesets)
             {
@@ -132,7 +133,86 @@ namespace osu.Game.Database
             }
         }
 
-        private void processBeatmapSetsWithMissingMetrics()
+        /// <remarks>
+        /// This is split out from <see cref="processOnlineBeatmapSetsWithNoUpdate"/> as a separate process to prevent high server-side load
+        /// from the <see cref="beatmapUpdater"/> firing online requests as part of the update.
+        /// Star rating recalculations can be ran strictly locally.
+        /// </remarks>
+        private void populateMissingStarRatings()
+        {
+            HashSet<Guid> beatmapIds = new HashSet<Guid>();
+
+            Logger.Log("Querying for beatmaps with missing star ratings...");
+
+            realmAccess.Run(r =>
+            {
+                foreach (var b in r.All<BeatmapInfo>().Where(b => b.StarRating < 0 && b.BeatmapSet != null))
+                    beatmapIds.Add(b.ID);
+            });
+
+            if (beatmapIds.Count == 0)
+                return;
+
+            Logger.Log($"Found {beatmapIds.Count} beatmaps which require star rating reprocessing.");
+
+            var notification = showProgressNotification(beatmapIds.Count, "Reprocessing star rating for beatmaps", "beatmaps' star ratings have been updated");
+
+            int processedCount = 0;
+            int failedCount = 0;
+
+            Dictionary<string, Ruleset> rulesetCache = new Dictionary<string, Ruleset>();
+
+            Ruleset getRuleset(RulesetInfo rulesetInfo)
+            {
+                if (!rulesetCache.TryGetValue(rulesetInfo.ShortName, out var ruleset))
+                    ruleset = rulesetCache[rulesetInfo.ShortName] = rulesetInfo.CreateInstance();
+
+                return ruleset;
+            }
+
+            foreach (Guid id in beatmapIds)
+            {
+                if (notification?.State == ProgressNotificationState.Cancelled)
+                    break;
+
+                updateNotificationProgress(notification, processedCount, beatmapIds.Count);
+
+                sleepIfRequired();
+
+                var beatmap = realmAccess.Run(r => r.Find<BeatmapInfo>(id)?.Detach());
+
+                if (beatmap == null)
+                    return;
+
+                try
+                {
+                    var working = beatmapManager.GetWorkingBeatmap(beatmap);
+                    var ruleset = getRuleset(working.BeatmapInfo.Ruleset);
+
+                    Debug.Assert(ruleset != null);
+
+                    var calculator = ruleset.CreateDifficultyCalculator(working);
+
+                    double starRating = calculator.Calculate().StarRating;
+                    realmAccess.Write(r =>
+                    {
+                        if (r.Find<BeatmapInfo>(id) is BeatmapInfo liveBeatmapInfo)
+                            liveBeatmapInfo.StarRating = starRating;
+                    });
+                    ((IWorkingBeatmapCache)beatmapManager).Invalidate(beatmap);
+                    ++processedCount;
+                }
+                catch (Exception e)
+                {
+                    Logger.Log($"Background processing failed on {beatmap}: {e}");
+                    ++failedCount;
+                }
+            }
+
+            completeNotification(notification, processedCount, beatmapIds.Count, failedCount);
+        }
+
+        private void processOnlineBeatmapSetsWithNoUpdate()
         {
             HashSet<Guid> beatmapSetIds = new HashSet<Guid>();
 
@@ -148,12 +228,7 @@ namespace osu.Game.Database
                 // of other possible ways), but for now avoid queueing if the user isn't logged in at startup.
                 if (api.IsLoggedIn)
                 {
-                    foreach (var b in r.All<BeatmapInfo>().Where(b => (b.StarRating < 0 || (b.OnlineID > 0 && b.LastOnlineUpdate == null)) && b.BeatmapSet != null))
-                        beatmapSetIds.Add(b.BeatmapSet!.ID);
-                }
-                else
-                {
-                    foreach (var b in r.All<BeatmapInfo>().Where(b => b.StarRating < 0 && b.BeatmapSet != null))
+                    foreach (var b in r.All<BeatmapInfo>().Where(b => b.OnlineID > 0 && b.LastOnlineUpdate == null && b.BeatmapSet != null))
                         beatmapSetIds.Add(b.BeatmapSet!.ID);
                 }
             });
@@ -161,10 +236,9 @@ namespace osu.Game.Database
             if (beatmapSetIds.Count == 0)
                 return;
 
-            Logger.Log($"Found {beatmapSetIds.Count} beatmap sets which require reprocessing.");
+            Logger.Log($"Found {beatmapSetIds.Count} beatmap sets which require online updates.");
 
-            // Technically this is doing more than just star ratings, but easier for the end user to understand.
-            var notification = showProgressNotification(beatmapSetIds.Count, "Reprocessing star rating for beatmaps", "beatmaps' star ratings have been updated");
+            var notification = showProgressNotification(beatmapSetIds.Count, "Updating online data for beatmaps", "beatmaps' online data have been updated");
 
             int processedCount = 0;
             int failedCount = 0;
diff --git a/osu.Game/Database/RealmAccess.cs b/osu.Game/Database/RealmAccess.cs
index 5cc143f4e2..3212e17b7b 100644
--- a/osu.Game/Database/RealmAccess.cs
+++ b/osu.Game/Database/RealmAccess.cs
@@ -315,6 +315,17 @@ namespace osu.Game.Database
                 attemptRecoverFromFile(newerVersionFilename);
             }
 
+            try
+            {
+                // Some platforms' realm implementation (including windows) don't update modified time on open.
+                // Let's do this explicitly as some users may depend on it roughly aligning to usage expectations.
+                string fullPath = storage.GetFullPath(Filename);
+                var fi = new FileInfo(fullPath);
+                if (fi.Exists)
+                    fi.LastWriteTime = DateTime.Now;
+            }
+            catch { }
+
             try
             {
                 return getRealmInstance();
diff --git a/osu.Game/Graphics/Containers/LinkFlowContainer.cs b/osu.Game/Graphics/Containers/LinkFlowContainer.cs
index aa72996fff..6022ea6bd6 100644
--- a/osu.Game/Graphics/Containers/LinkFlowContainer.cs
+++ b/osu.Game/Graphics/Containers/LinkFlowContainer.cs
@@ -134,9 +134,14 @@ namespace osu.Game.Graphics.Containers
 
         protected virtual DrawableLinkCompiler CreateLinkCompiler(ITextPart textPart) => new DrawableLinkCompiler(textPart);
 
-        // We want the compilers to always be visible no matter where they are, so RelativeSizeAxes is used.
-        // However due to https://github.com/ppy/osu-framework/issues/2073, it's possible for the compilers to be relative size in the flow's auto-size axes - an unsupported operation.
-        // Since the compilers don't display any content and don't affect the layout, it's simplest to exclude them from the flow.
-        public override IEnumerable<Drawable> FlowingChildren => base.FlowingChildren.Where(c => !(c is DrawableLinkCompiler));
+        protected override FillFlowContainer CreateFlow() => new LinkFlow();
+
+        private partial class LinkFlow : InnerFlow
+        {
+            // We want the compilers to always be visible no matter where they are, so RelativeSizeAxes is used.
+            // However due to https://github.com/ppy/osu-framework/issues/2073, it's possible for the compilers to be relative size in the flow's auto-size axes - an unsupported operation.
+            // Since the compilers don't display any content and don't affect the layout, it's simplest to exclude them from the flow.
+            public override IEnumerable<Drawable> FlowingChildren => base.FlowingChildren.Where(c => !(c is DrawableLinkCompiler));
+        }
     }
 }
diff --git a/osu.Game/Graphics/UserInterface/RoundedSliderBar.cs b/osu.Game/Graphics/UserInterface/RoundedSliderBar.cs
index aeab7c34b2..9a0183da64 100644
--- a/osu.Game/Graphics/UserInterface/RoundedSliderBar.cs
+++ b/osu.Game/Graphics/UserInterface/RoundedSliderBar.cs
@@ -10,6 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Game.Overlays;
 using Vector2 = osuTK.Vector2;
@@ -52,10 +53,21 @@ namespace osu.Game.Graphics.UserInterface
             }
         }
 
+        /// <summary>
+        /// The action to use to reset the value of <see cref="SliderBar{T}.Current"/> to the default.
+        /// Triggered on double click.
+        /// </summary>
+        public Action ResetToDefault { get; internal set; }
+
         public RoundedSliderBar()
         {
             Height = Nub.HEIGHT;
             RangePadding = Nub.DEFAULT_EXPANDED_SIZE / 2;
+            ResetToDefault = () =>
+            {
+                if (!Current.Disabled)
+                    Current.SetDefault();
+            };
             Children = new Drawable[]
             {
                 new Container
@@ -102,11 +114,7 @@ namespace osu.Game.Graphics.UserInterface
                         Origin = Anchor.TopCentre,
                         RelativePositionAxes = Axes.X,
                         Current = { Value = true },
-                        OnDoubleClicked = () =>
-                        {
-                            if (!Current.Disabled)
-                                Current.SetDefault();
-                        },
+                        OnDoubleClicked = () => ResetToDefault.Invoke(),
                     },
                 },
                 hoverClickSounds = new HoverClickSounds()
diff --git a/osu.Game/Graphics/UserInterfaceV2/FormColourPalette.cs b/osu.Game/Graphics/UserInterfaceV2/FormColourPalette.cs
index fad58841e3..a0348fa27a 100644
--- a/osu.Game/Graphics/UserInterfaceV2/FormColourPalette.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/FormColourPalette.cs
@@ -31,9 +31,12 @@ namespace osu.Game.Graphics.UserInterfaceV2
         public LocalisableString Caption { get; init; }
         public LocalisableString HintText { get; init; }
 
+        public BindableBool CanAdd { get; } = new BindableBool(true);
+
         private Box background = null!;
         private FormFieldCaption caption = null!;
         private FillFlowContainer flow = null!;
+        private RoundedButton addButton = null!;
 
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; } = null!;
@@ -47,8 +50,6 @@ namespace osu.Game.Graphics.UserInterfaceV2
             Masking = true;
             CornerRadius = 5;
 
-            RoundedButton button;
-
             InternalChildren = new Drawable[]
             {
                 background = new Box
@@ -76,7 +77,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
                             AutoSizeAxes = Axes.Y,
                             Direction = FillDirection.Full,
                             Spacing = new Vector2(5),
-                            Child = button = new RoundedButton
+                            Child = addButton = new RoundedButton
                             {
                                 Action = addNewColour,
                                 Size = new Vector2(70),
@@ -87,7 +88,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
                 },
             };
 
-            flow.SetLayoutPosition(button, float.MaxValue);
+            flow.SetLayoutPosition(addButton, float.MaxValue);
         }
 
         protected override void LoadComplete()
@@ -99,6 +100,19 @@ namespace osu.Game.Graphics.UserInterfaceV2
                 if (args.Action != NotifyCollectionChangedAction.Replace)
                     updateColours();
             }, true);
+            CanAdd.BindValueChanged(canAdd =>
+            {
+                if (canAdd.NewValue)
+                {
+                    addButton.Enabled.Value = true;
+                    addButton.TooltipText = string.Empty;
+                }
+                else
+                {
+                    addButton.Enabled.Value = false;
+                    addButton.TooltipText = "Maximum combo colours reached";
+                }
+            }, true);
             updateState();
         }
 
diff --git a/osu.Game/Graphics/UserInterfaceV2/RoundedButton.cs b/osu.Game/Graphics/UserInterfaceV2/RoundedButton.cs
index 6aded3fe32..9b57ebb200 100644
--- a/osu.Game/Graphics/UserInterfaceV2/RoundedButton.cs
+++ b/osu.Game/Graphics/UserInterfaceV2/RoundedButton.cs
@@ -8,6 +8,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Game.Graphics.Backgrounds;
@@ -17,7 +18,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Graphics.UserInterfaceV2
 {
-    public partial class RoundedButton : OsuButton, IFilterable
+    public partial class RoundedButton : OsuButton, IFilterable, IHasTooltip
     {
         protected TrianglesV2? Triangles { get; private set; }
 
@@ -107,5 +108,7 @@ namespace osu.Game.Graphics.UserInterfaceV2
         }
 
         public bool FilteringActive { get; set; }
+
+        public virtual LocalisableString TooltipText { get; set; }
     }
 }
diff --git a/osu.Game/Input/Bindings/GlobalActionContainer.cs b/osu.Game/Input/Bindings/GlobalActionContainer.cs
index e4dc2d503b..6de2dabe2b 100644
--- a/osu.Game/Input/Bindings/GlobalActionContainer.cs
+++ b/osu.Game/Input/Bindings/GlobalActionContainer.cs
@@ -155,6 +155,7 @@ namespace osu.Game.Input.Bindings
             new KeyBinding(new[] { InputKey.Control, InputKey.Shift, InputKey.B }, GlobalAction.EditorRemoveClosestBookmark),
             new KeyBinding(new[] { InputKey.Alt, InputKey.Left }, GlobalAction.EditorSeekToPreviousBookmark),
             new KeyBinding(new[] { InputKey.Alt, InputKey.Right }, GlobalAction.EditorSeekToNextBookmark),
+            new KeyBinding(new[] { InputKey.Control, InputKey.L }, GlobalAction.EditorDiscardUnsavedChanges),
         };
 
         private static IEnumerable<KeyBinding> editorTestPlayKeyBindings => new[]
@@ -502,6 +503,9 @@ namespace osu.Game.Input.Bindings
 
         [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorToggleMoveControl))]
         EditorToggleMoveControl,
+
+        [LocalisableDescription(typeof(GlobalActionKeyBindingStrings), nameof(GlobalActionKeyBindingStrings.EditorDiscardUnsavedChanges))]
+        EditorDiscardUnsavedChanges,
     }
 
     public enum GlobalActionCategory
diff --git a/osu.Game/Localisation/CommonStrings.cs b/osu.Game/Localisation/CommonStrings.cs
index 243a100029..f9d0feb5e2 100644
--- a/osu.Game/Localisation/CommonStrings.cs
+++ b/osu.Game/Localisation/CommonStrings.cs
@@ -39,6 +39,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString Default => new TranslatableString(getKey(@"default"), @"Default");
 
+        /// <summary>
+        /// "Rename"
+        /// </summary>
+        public static LocalisableString Rename => new TranslatableString(getKey(@"rename"), @"Rename");
+
         /// <summary>
         /// "Export"
         /// </summary>
diff --git a/osu.Game/Localisation/EditorDialogsStrings.cs b/osu.Game/Localisation/EditorDialogsStrings.cs
index 94f28c617c..3617dca81f 100644
--- a/osu.Game/Localisation/EditorDialogsStrings.cs
+++ b/osu.Game/Localisation/EditorDialogsStrings.cs
@@ -54,6 +54,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString EditorReloadDialogHeader => new TranslatableString(getKey(@"editor_reload_dialog_header"), @"The editor must be reloaded to apply this change. The beatmap will be saved.");
 
+        /// <summary>
+        /// "Discard all unsaved changes? This cannot be undone."
+        /// </summary>
+        public static LocalisableString DiscardUnsavedChangesDialogHeader => new TranslatableString(getKey(@"discard_unsaved_changes_dialog_header"), @"Discard all unsaved changes? This cannot be undone.");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs b/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
index 5713df57c9..34b9e1fecc 100644
--- a/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
+++ b/osu.Game/Localisation/GlobalActionKeyBindingStrings.cs
@@ -459,6 +459,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString EditorToggleMoveControl => new TranslatableString(getKey(@"editor_toggle_move_control"), @"Toggle movement control");
 
+        /// <summary>
+        /// "Discard unsaved changes"
+        /// </summary>
+        public static LocalisableString EditorDiscardUnsavedChanges => new TranslatableString(getKey(@"editor_discard_unsaved_changes"), @"Discard unsaved changes");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Localisation/TabletSettingsStrings.cs b/osu.Game/Localisation/TabletSettingsStrings.cs
index 6c2e3c1f9c..ff0ced457f 100644
--- a/osu.Game/Localisation/TabletSettingsStrings.cs
+++ b/osu.Game/Localisation/TabletSettingsStrings.cs
@@ -59,6 +59,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString LockAspectRatio => new TranslatableString(getKey(@"lock_aspect_ratio"), @"Lock aspect ratio");
 
+        /// <summary>
+        /// "Tip pressure for click"
+        /// </summary>
+        public static LocalisableString TipPressureForClick => new TranslatableString(getKey(@"tip_pressure_for_click"), "Tip pressure for click");
+
         private static string getKey(string key) => $@"{prefix}:{key}";
     }
 }
diff --git a/osu.Game/Online/API/Requests/AddBeatmapTagRequest.cs b/osu.Game/Online/API/Requests/AddBeatmapTagRequest.cs
new file mode 100644
index 0000000000..4fa02dc569
--- /dev/null
+++ b/osu.Game/Online/API/Requests/AddBeatmapTagRequest.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.Globalization;
+using System.Net.Http;
+using osu.Framework.IO.Network;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class AddBeatmapTagRequest : APIRequest
+    {
+        public int BeatmapID { get; }
+        public long TagID { get; }
+
+        public AddBeatmapTagRequest(int beatmapID, long tagID)
+        {
+            BeatmapID = beatmapID;
+            TagID = tagID;
+        }
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+            req.Method = HttpMethod.Post;
+            req.AddParameter(@"tag_id", TagID.ToString(CultureInfo.InvariantCulture), RequestParameterType.Query);
+            return req;
+        }
+
+        protected override string Target => $@"beatmaps/{BeatmapID}/tags";
+    }
+}
diff --git a/osu.Game/Online/API/Requests/GetUsersRequest.cs b/osu.Game/Online/API/Requests/GetUsersRequest.cs
index cd75ff4e31..fe7ba8c33d 100644
--- a/osu.Game/Online/API/Requests/GetUsersRequest.cs
+++ b/osu.Game/Online/API/Requests/GetUsersRequest.cs
@@ -13,14 +13,14 @@ namespace osu.Game.Online.API.Requests
     /// </summary>
     public class GetUsersRequest : APIRequest<GetUsersResponse>
     {
-        public readonly int[] UserIds;
+        public const int MAX_IDS_PER_REQUEST = 50;
 
-        private const int max_ids_per_request = 50;
+        public readonly int[] UserIds;
 
         public GetUsersRequest(int[] userIds)
         {
-            if (userIds.Length > max_ids_per_request)
-                throw new ArgumentException($"{nameof(GetUsersRequest)} calls only support up to {max_ids_per_request} IDs at once");
+            if (userIds.Length > MAX_IDS_PER_REQUEST)
+                throw new ArgumentException($"{nameof(GetUsersRequest)} calls only support up to {MAX_IDS_PER_REQUEST} IDs at once");
 
             UserIds = userIds;
         }
diff --git a/osu.Game/Online/API/Requests/ListTagsRequest.cs b/osu.Game/Online/API/Requests/ListTagsRequest.cs
new file mode 100644
index 0000000000..ac4b1a3e2a
--- /dev/null
+++ b/osu.Game/Online/API/Requests/ListTagsRequest.cs
@@ -0,0 +1,12 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class ListTagsRequest : APIRequest<APITagCollection>
+    {
+        protected override string Target => "tags";
+    }
+}
diff --git a/osu.Game/Online/API/Requests/RemoveBeatmapTagRequest.cs b/osu.Game/Online/API/Requests/RemoveBeatmapTagRequest.cs
new file mode 100644
index 0000000000..4ac00e28f4
--- /dev/null
+++ b/osu.Game/Online/API/Requests/RemoveBeatmapTagRequest.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.Net.Http;
+using osu.Framework.IO.Network;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class RemoveBeatmapTagRequest : APIRequest
+    {
+        public int BeatmapID { get; }
+        public long TagID { get; }
+
+        public RemoveBeatmapTagRequest(int beatmapID, long tagID)
+        {
+            BeatmapID = beatmapID;
+            TagID = tagID;
+        }
+
+        protected override WebRequest CreateWebRequest()
+        {
+            var req = base.CreateWebRequest();
+            req.Method = HttpMethod.Delete;
+            return req;
+        }
+
+        protected override string Target => $@"beatmaps/{BeatmapID}/tags/{TagID}";
+    }
+}
diff --git a/osu.Game/Online/API/Requests/Responses/APIBeatmap.cs b/osu.Game/Online/API/Requests/Responses/APIBeatmap.cs
index e5ecfe2c99..66e17739a8 100644
--- a/osu.Game/Online/API/Requests/Responses/APIBeatmap.cs
+++ b/osu.Game/Online/API/Requests/Responses/APIBeatmap.cs
@@ -95,6 +95,12 @@ namespace osu.Game.Online.API.Requests.Responses
         [JsonProperty(@"failtimes")]
         public APIFailTimes? FailTimes { get; set; }
 
+        [JsonProperty(@"top_tag_ids")]
+        public APIBeatmapTag[]? TopTags { get; set; }
+
+        [JsonProperty(@"current_user_tag_ids")]
+        public long[]? OwnTagIds { get; set; }
+
         [JsonProperty(@"max_combo")]
         public int? MaxCombo { get; set; }
 
diff --git a/osu.Game/Online/API/Requests/Responses/APITag.cs b/osu.Game/Online/API/Requests/Responses/APITag.cs
new file mode 100644
index 0000000000..4dd18663af
--- /dev/null
+++ b/osu.Game/Online/API/Requests/Responses/APITag.cs
@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using Newtonsoft.Json;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APITag
+    {
+        [JsonProperty("id")]
+        public long Id { get; set; }
+
+        [JsonProperty("name")]
+        public string Name { get; set; } = string.Empty;
+
+        [JsonProperty("description")]
+        public string Description { get; set; } = string.Empty;
+    }
+}
diff --git a/osu.Game/Online/API/Requests/Responses/APITagCollection.cs b/osu.Game/Online/API/Requests/Responses/APITagCollection.cs
new file mode 100644
index 0000000000..a177699348
--- /dev/null
+++ b/osu.Game/Online/API/Requests/Responses/APITagCollection.cs
@@ -0,0 +1,14 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using Newtonsoft.Json;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APITagCollection
+    {
+        [JsonProperty("tags")]
+        public APITag[] Tags { get; set; } = Array.Empty<APITag>();
+    }
+}
diff --git a/osu.Game/Online/Chat/ChannelManager.cs b/osu.Game/Online/Chat/ChannelManager.cs
index 74e85c595c..e9ca0a8ed2 100644
--- a/osu.Game/Online/Chat/ChannelManager.cs
+++ b/osu.Game/Online/Chat/ChannelManager.cs
@@ -411,7 +411,7 @@ namespace osu.Game.Online.Chat
         }
 
         /// <summary>
-        /// Find an existing channel instance for the provided channel. Lookup is performed basd on ID.
+        /// Find an existing channel instance for the provided channel. Lookup is performed based on ID.
         /// The provided channel may be used if an existing instance is not found.
         /// </summary>
         /// <param name="lookup">A candidate channel to be used for lookup or permanently on lookup failure.</param>
diff --git a/osu.Game/Online/Chat/ChannelType.cs b/osu.Game/Online/Chat/ChannelType.cs
index bd628e90c4..4fb890c2cc 100644
--- a/osu.Game/Online/Chat/ChannelType.cs
+++ b/osu.Game/Online/Chat/ChannelType.cs
@@ -14,5 +14,6 @@ namespace osu.Game.Online.Chat
         Group,
         System,
         Announce,
+        Team,
     }
 }
diff --git a/osu.Game/Online/Leaderboards/LeaderboardScore.cs b/osu.Game/Online/Leaderboards/LeaderboardScore.cs
index fc30f158f0..fb5bb225c0 100644
--- a/osu.Game/Online/Leaderboards/LeaderboardScore.cs
+++ b/osu.Game/Online/Leaderboards/LeaderboardScore.cs
@@ -190,7 +190,7 @@ namespace osu.Game.Online.Leaderboards
                                                     RelativeSizeAxes = Axes.Y,
                                                     Direction = FillDirection.Horizontal,
                                                     Spacing = new Vector2(5f, 0f),
-                                                    Width = 114f,
+                                                    Width = 130f,
                                                     Masking = true,
                                                     Children = new Drawable[]
                                                     {
@@ -271,6 +271,7 @@ namespace osu.Game.Online.Leaderboards
                                             Anchor = Anchor.CentreRight,
                                             Origin = Anchor.CentreRight,
                                             AutoSizeAxes = Axes.Both,
+                                            Spacing = new Vector2(-10, 0),
                                             Direction = FillDirection.Horizontal,
                                             ChildrenEnumerable = Score.Mods.AsOrdered().Select(mod => new ModIcon(mod) { Scale = new Vector2(0.34f) })
                                         },
@@ -394,7 +395,7 @@ namespace osu.Game.Online.Leaderboards
                             Origin = Anchor.CentreLeft,
                             Text = statistic.Value,
                             Spacing = new Vector2(-1, 0),
-                            Font = OsuFont.GetFont(size: 14, weight: FontWeight.Bold, fixedWidth: true)
+                            Font = OsuFont.GetFont(size: 16, weight: FontWeight.Bold, fixedWidth: true)
                         },
                     },
                 };
@@ -425,7 +426,7 @@ namespace osu.Game.Online.Leaderboards
             public DateLabel(DateTimeOffset date)
                 : base(date)
             {
-                Font = OsuFont.GetFont(size: 13, weight: FontWeight.Bold, italics: true);
+                Font = OsuFont.GetFont(size: 16, weight: FontWeight.Bold);
             }
 
             protected override string Format() => Date.ToShortRelativeTime(TimeSpan.FromSeconds(30));
@@ -451,8 +452,11 @@ namespace osu.Game.Online.Leaderboards
             {
                 List<MenuItem> items = new List<MenuItem>();
 
-                if (Score.Mods.Length > 0 && songSelect != null)
-                    items.Add(new OsuMenuItem("Use these mods", MenuItemType.Highlighted, () => songSelect.Mods.Value = Score.Mods));
+                // system mods should never be copied across regardless of anything.
+                var copyableMods = Score.Mods.Where(m => m.Type != ModType.System).ToArray();
+
+                if (copyableMods.Length > 0 && songSelect != null)
+                    items.Add(new OsuMenuItem("Use these mods", MenuItemType.Highlighted, () => songSelect.Mods.Value = copyableMods));
 
                 if (Score.OnlineID > 0)
                     items.Add(new OsuMenuItem(CommonStrings.CopyLink, MenuItemType.Standard, () => clipboard?.SetText($@"{api.Endpoints.WebsiteUrl}/scores/{Score.OnlineID}")));
diff --git a/osu.Game/Online/Multiplayer/IMultiplayerLoungeServer.cs b/osu.Game/Online/Multiplayer/IMultiplayerLoungeServer.cs
index f266c38b8b..0ee9fa54cd 100644
--- a/osu.Game/Online/Multiplayer/IMultiplayerLoungeServer.cs
+++ b/osu.Game/Online/Multiplayer/IMultiplayerLoungeServer.cs
@@ -10,6 +10,13 @@ namespace osu.Game.Online.Multiplayer
     /// </summary>
     public interface IMultiplayerLoungeServer
     {
+        /// <summary>
+        /// Request to create a multiplayer room.
+        /// </summary>
+        /// <param name="room">The room to create.</param>
+        /// <returns>The created multiplayer room.</returns>
+        Task<MultiplayerRoom> CreateRoom(MultiplayerRoom room);
+
         /// <summary>
         /// Request to join a multiplayer room.
         /// </summary>
diff --git a/osu.Game/Online/Multiplayer/InvalidPasswordException.cs b/osu.Game/Online/Multiplayer/InvalidPasswordException.cs
index b76a1cc05d..860fb90258 100644
--- a/osu.Game/Online/Multiplayer/InvalidPasswordException.cs
+++ b/osu.Game/Online/Multiplayer/InvalidPasswordException.cs
@@ -9,5 +9,9 @@ namespace osu.Game.Online.Multiplayer
     [Serializable]
     public class InvalidPasswordException : HubException
     {
+        public InvalidPasswordException()
+            : base("Invalid password")
+        {
+        }
     }
 }
diff --git a/osu.Game/Online/Multiplayer/MultiplayerClient.cs b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
index 97161cce48..57aaf68853 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerClient.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
@@ -51,6 +51,11 @@ namespace osu.Game.Online.Multiplayer
         /// </summary>
         public event Action<MultiplayerRoomUser>? UserKicked;
 
+        /// <summary>
+        /// Invoked when the room's host is changed.
+        /// </summary>
+        public event Action<MultiplayerRoomUser?>? HostChanged;
+
         /// <summary>
         /// Invoked when a new item is added to the playlist.
         /// </summary>
@@ -166,60 +171,91 @@ namespace osu.Game.Online.Multiplayer
         private CancellationTokenSource? joinCancellationSource;
 
         /// <summary>
-        /// Joins the <see cref="MultiplayerRoom"/> for a given API <see cref="Room"/>.
+        /// Creates and joins a <see cref="MultiplayerRoom"/> described by an API <see cref="Room"/>.
         /// </summary>
-        /// <param name="room">The API <see cref="Room"/>.</param>
-        /// <param name="password">An optional password to use for the join operation.</param>
-        public async Task JoinRoom(Room room, string? password = null)
+        /// <param name="room">The API <see cref="Room"/> describing the room to create.</param>
+        /// <exception cref="InvalidOperationException">If the current user is already in another room.</exception>
+        public async Task CreateRoom(Room room)
         {
             if (Room != null)
-                throw new InvalidOperationException("Cannot join a multiplayer room while already in one.");
+                throw new InvalidOperationException("Cannot create a multiplayer room while already in one.");
 
             var cancellationSource = joinCancellationSource = new CancellationTokenSource();
 
             await joinOrLeaveTaskChain.Add(async () =>
             {
-                Debug.Assert(room.RoomID != null);
-
-                // Join the server-side room.
-                var joinedRoom = await JoinRoom(room.RoomID.Value, password ?? room.Password).ConfigureAwait(false);
-                Debug.Assert(joinedRoom != null);
-
-                // Populate users.
-                Debug.Assert(joinedRoom.Users != null);
-                await PopulateUsers(joinedRoom.Users).ConfigureAwait(false);
-
-                // Update the stored room (must be done on update thread for thread-safety).
-                await runOnUpdateThreadAsync(() =>
-                {
-                    Debug.Assert(Room == null);
-
-                    Room = joinedRoom;
-                    APIRoom = room;
-
-                    Debug.Assert(joinedRoom.Playlist.Count > 0);
-
-                    APIRoom.Playlist = joinedRoom.Playlist.Select(item => new PlaylistItem(item)).ToArray();
-                    APIRoom.CurrentPlaylistItem = APIRoom.Playlist.Single(item => item.ID == joinedRoom.Settings.PlaylistItemId);
-
-                    // The server will null out the end date upon the host joining the room, but the null value is never communicated to the client.
-                    APIRoom.EndDate = null;
-
-                    Debug.Assert(LocalUser != null);
-                    addUserToAPIRoom(LocalUser);
-
-                    foreach (var user in joinedRoom.Users)
-                        updateUserPlayingState(user.UserID, user.State);
-
-                    updateLocalRoomSettings(joinedRoom.Settings);
-
-                    postServerShuttingDownNotification();
-
-                    OnRoomJoined();
-                }, 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);
         }
 
+        /// <summary>
+        /// Joins the <see cref="MultiplayerRoom"/> for a given API <see cref="Room"/>.
+        /// </summary>
+        /// <param name="room">The API <see cref="Room"/>.</param>
+        /// <param name="password">An optional password to use for the join operation.</param>
+        /// <exception cref="InvalidOperationException">If the current user is already in another room, or <paramref name="room"/> does not represent an active room.</exception>
+        public async Task JoinRoom(Room room, string? password = null)
+        {
+            if (Room != null)
+                throw new InvalidOperationException("Cannot join a multiplayer room while already in one.");
+
+            if (room.RoomID == null)
+                throw new InvalidOperationException("Cannot join an inactive room.");
+
+            var cancellationSource = joinCancellationSource = new CancellationTokenSource();
+
+            await joinOrLeaveTaskChain.Add(async () =>
+            {
+                var multiplayerRoom = await JoinRoomInternal(room.RoomID.Value, password ?? room.Password).ConfigureAwait(false);
+                await setupJoinedRoom(room, multiplayerRoom, cancellationSource.Token).ConfigureAwait(false);
+            }, cancellationSource.Token).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Performs post-join setup of a <see cref="MultiplayerRoom"/>.
+        /// </summary>
+        /// <param name="apiRoom">The incoming API <see cref="Room"/> that was requested to be joined.</param>
+        /// <param name="joinedRoom">The resuling <see cref="MultiplayerRoom"/> that was joined.</param>
+        /// <param name="cancellationToken">A token to cancel the process.</param>
+        private async Task setupJoinedRoom(Room apiRoom, MultiplayerRoom joinedRoom, CancellationToken cancellationToken)
+        {
+            // Populate users.
+            await PopulateUsers(joinedRoom.Users).ConfigureAwait(false);
+            if (joinedRoom.Host != null)
+                await PopulateUsers([joinedRoom.Host]).ConfigureAwait(false);
+
+            // Update the stored room (must be done on update thread for thread-safety).
+            await runOnUpdateThreadAsync(() =>
+            {
+                Debug.Assert(Room == null);
+                Debug.Assert(APIRoom == null);
+
+                Room = joinedRoom;
+                APIRoom = apiRoom;
+
+                APIRoom.RoomID = joinedRoom.RoomID;
+                APIRoom.ChannelId = joinedRoom.ChannelID;
+                APIRoom.Host = joinedRoom.Host?.User;
+                APIRoom.Playlist = joinedRoom.Playlist.Select(item => new PlaylistItem(item)).ToArray();
+                APIRoom.CurrentPlaylistItem = APIRoom.Playlist.Single(item => item.ID == joinedRoom.Settings.PlaylistItemId);
+                // The server will null out the end date upon the host joining the room, but the null value is never communicated to the client.
+                APIRoom.EndDate = null;
+
+                Debug.Assert(LocalUser != null);
+                addUserToAPIRoom(LocalUser);
+
+                foreach (var user in joinedRoom.Users)
+                    updateUserPlayingState(user.UserID, user.State);
+
+                updateLocalRoomSettings(joinedRoom.Settings);
+
+                postServerShuttingDownNotification();
+
+                OnRoomJoined();
+            }, cancellationToken).ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Fired when the room join sequence is complete
         /// </summary>
@@ -227,16 +263,11 @@ namespace osu.Game.Online.Multiplayer
         {
         }
 
-        /// <summary>
-        /// Joins the <see cref="MultiplayerRoom"/> with a given ID.
-        /// </summary>
-        /// <param name="roomId">The room ID.</param>
-        /// <param name="password">An optional password to use when joining the room.</param>
-        /// <returns>The joined <see cref="MultiplayerRoom"/>.</returns>
-        protected abstract Task<MultiplayerRoom> JoinRoom(long roomId, string? password = null);
-
         public Task LeaveRoom()
         {
+            if (Room == null)
+                return Task.CompletedTask;
+
             // The join may have not completed yet, so certain tasks that either update the room or reference the room should be cancelled.
             // This includes the setting of Room itself along with the initial update of the room settings on join.
             joinCancellationSource?.Cancel();
@@ -260,6 +291,24 @@ namespace osu.Game.Online.Multiplayer
             });
         }
 
+        /// <summary>
+        /// Creates the <see cref="MultiplayerRoom"/> with the given settings.
+        /// </summary>
+        /// <param name="room">The room.</param>
+        /// <returns>The joined <see cref="MultiplayerRoom"/></returns>
+        protected abstract Task<MultiplayerRoom> CreateRoomInternal(MultiplayerRoom room);
+
+        /// <summary>
+        /// Joins the <see cref="MultiplayerRoom"/> with a given ID.
+        /// </summary>
+        /// <param name="roomId">The room ID.</param>
+        /// <param name="password">An optional password to use when joining the room.</param>
+        /// <returns>The joined <see cref="MultiplayerRoom"/>.</returns>
+        protected abstract Task<MultiplayerRoom> JoinRoomInternal(long roomId, string? password = null);
+
+        /// <summary>
+        /// Leaves the currently-joined <see cref="MultiplayerRoom"/>.
+        /// </summary>
         protected abstract Task LeaveRoomInternal();
 
         public abstract Task InvitePlayer(int userId);
@@ -438,18 +487,44 @@ namespace osu.Game.Online.Multiplayer
             }, false);
         }
 
-        Task IMultiplayerClient.UserLeft(MultiplayerRoomUser user) =>
-            handleUserLeft(user, UserLeft);
+        Task IMultiplayerClient.UserLeft(MultiplayerRoomUser user)
+        {
+            Scheduler.Add(() => handleUserLeft(user, UserLeft), false);
+            return Task.CompletedTask;
+        }
 
         Task IMultiplayerClient.UserKicked(MultiplayerRoomUser user)
         {
-            if (LocalUser == null)
-                return Task.CompletedTask;
+            Scheduler.Add(() =>
+            {
+                if (LocalUser == null)
+                    return;
 
-            if (user.Equals(LocalUser))
-                LeaveRoom();
+                if (user.Equals(LocalUser))
+                    LeaveRoom();
 
-            return handleUserLeft(user, UserKicked);
+                handleUserLeft(user, UserKicked);
+            }, false);
+
+            return Task.CompletedTask;
+        }
+
+        private void handleUserLeft(MultiplayerRoomUser user, Action<MultiplayerRoomUser>? callback)
+        {
+            Debug.Assert(ThreadSafety.IsUpdateThread);
+
+            if (Room == null)
+                return;
+
+            Room.Users.Remove(user);
+            PlayingUserIds.Remove(user.UserID);
+
+            Debug.Assert(APIRoom != null);
+            APIRoom.RecentParticipants = APIRoom.RecentParticipants.Where(u => u.Id != user.UserID).ToArray();
+            APIRoom.ParticipantCount--;
+
+            callback?.Invoke(user);
+            RoomUpdated?.Invoke();
         }
 
         async Task IMultiplayerClient.Invited(int invitedBy, long roomID, string password)
@@ -496,27 +571,6 @@ namespace osu.Game.Online.Multiplayer
             APIRoom.ParticipantCount++;
         }
 
-        private Task handleUserLeft(MultiplayerRoomUser user, Action<MultiplayerRoomUser>? callback)
-        {
-            Scheduler.Add(() =>
-            {
-                if (Room == null)
-                    return;
-
-                Room.Users.Remove(user);
-                PlayingUserIds.Remove(user.UserID);
-
-                Debug.Assert(APIRoom != null);
-                APIRoom.RecentParticipants = APIRoom.RecentParticipants.Where(u => u.Id != user.UserID).ToArray();
-                APIRoom.ParticipantCount--;
-
-                callback?.Invoke(user);
-                RoomUpdated?.Invoke();
-            }, false);
-
-            return Task.CompletedTask;
-        }
-
         Task IMultiplayerClient.HostChanged(int userId)
         {
             Scheduler.Add(() =>
@@ -531,6 +585,7 @@ namespace osu.Game.Online.Multiplayer
                 Room.Host = user;
                 APIRoom.Host = user?.User;
 
+                HostChanged?.Invoke(user);
                 RoomUpdated?.Invoke();
             }, false);
 
@@ -809,19 +864,22 @@ namespace osu.Game.Online.Multiplayer
         /// <param name="multiplayerUsers">The <see cref="MultiplayerRoomUser"/>s to populate.</param>
         protected async Task PopulateUsers(IEnumerable<MultiplayerRoomUser> multiplayerUsers)
         {
-            var request = new GetUsersRequest(multiplayerUsers.Select(u => u.UserID).Distinct().ToArray());
-
-            await API.PerformAsync(request).ConfigureAwait(false);
-
-            if (request.Response == null)
-                return;
-
-            Dictionary<int, APIUser> users = request.Response.Users.ToDictionary(user => user.Id);
-
-            foreach (var multiplayerUser in multiplayerUsers)
+            foreach (int[] userChunk in multiplayerUsers.Select(u => u.UserID).Distinct().Chunk(GetUsersRequest.MAX_IDS_PER_REQUEST))
             {
-                if (users.TryGetValue(multiplayerUser.UserID, out var user))
-                    multiplayerUser.User = user;
+                var request = new GetUsersRequest(userChunk);
+
+                await API.PerformAsync(request).ConfigureAwait(false);
+
+                if (request.Response == null)
+                    return;
+
+                Dictionary<int, APIUser> users = request.Response.Users.ToDictionary(user => user.Id);
+
+                foreach (var multiplayerUser in multiplayerUsers)
+                {
+                    if (users.TryGetValue(multiplayerUser.UserID, out var user))
+                        multiplayerUser.User = user;
+                }
             }
         }
 
diff --git a/osu.Game/Online/Multiplayer/MultiplayerClientExtensions.cs b/osu.Game/Online/Multiplayer/MultiplayerClientExtensions.cs
index d846e7f566..1cc5a8e70a 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerClientExtensions.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerClientExtensions.cs
@@ -5,6 +5,7 @@ using System;
 using System.Diagnostics;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.SignalR;
+using osu.Framework.Extensions.ExceptionExtensions;
 using osu.Framework.Logging;
 
 namespace osu.Game.Online.Multiplayer
@@ -16,12 +17,8 @@ namespace osu.Game.Online.Multiplayer
             {
                 if (t.IsFaulted)
                 {
-                    Exception? exception = t.Exception;
-
-                    if (exception is AggregateException ae)
-                        exception = ae.InnerException;
-
-                    Debug.Assert(exception != null);
+                    Debug.Assert(t.Exception != null);
+                    Exception exception = t.Exception.AsSingular();
 
                     if (exception.GetHubExceptionMessage() is string message)
                         // Hub exceptions generally contain something we can show the user directly.
diff --git a/osu.Game/Online/Multiplayer/MultiplayerRoom.cs b/osu.Game/Online/Multiplayer/MultiplayerRoom.cs
index 00048fa931..b8b90d907f 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerRoom.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerRoom.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using MessagePack;
 using Newtonsoft.Json;
 using osu.Game.Online.Rooms;
@@ -58,6 +59,12 @@ namespace osu.Game.Online.Multiplayer
         [Key(7)]
         public IList<MultiplayerCountdown> ActiveCountdowns { get; set; } = new List<MultiplayerCountdown>();
 
+        /// <summary>
+        /// The ID of the chat channel for the room.
+        /// </summary>
+        [Key(8)]
+        public int ChannelID { get; set; }
+
         [JsonConstructor]
         [SerializationConstructor]
         public MultiplayerRoom(long roomId)
@@ -65,6 +72,15 @@ namespace osu.Game.Online.Multiplayer
             RoomID = roomId;
         }
 
+        public MultiplayerRoom(Room room)
+        {
+            RoomID = room.RoomID ?? 0;
+            ChannelID = room.ChannelId;
+            Settings = new MultiplayerRoomSettings(room);
+            Host = room.Host != null ? new MultiplayerRoomUser(room.Host.OnlineID) : null;
+            Playlist = room.Playlist.Select(p => new MultiplayerPlaylistItem(p)).ToArray();
+        }
+
         public override string ToString() => $"RoomID:{RoomID} Host:{Host?.UserID} Users:{Users.Count} State:{State} Settings: [{Settings}]";
     }
 }
diff --git a/osu.Game/Online/Multiplayer/MultiplayerRoomSettings.cs b/osu.Game/Online/Multiplayer/MultiplayerRoomSettings.cs
index c73b02874e..c264ec1eef 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerRoomSettings.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerRoomSettings.cs
@@ -35,6 +35,20 @@ namespace osu.Game.Online.Multiplayer
         [IgnoreMember]
         public bool AutoStartEnabled => AutoStartDuration != TimeSpan.Zero;
 
+        public MultiplayerRoomSettings()
+        {
+        }
+
+        public MultiplayerRoomSettings(Room room)
+        {
+            Name = room.Name;
+            Password = room.Password ?? string.Empty;
+            MatchType = room.Type;
+            QueueMode = room.QueueMode;
+            AutoStartDuration = room.AutoStartDuration;
+            AutoSkip = room.AutoSkip;
+        }
+
         public bool Equals(MultiplayerRoomSettings? other)
         {
             if (ReferenceEquals(this, other)) return true;
diff --git a/osu.Game/Online/Multiplayer/OnlineMultiplayerClient.cs b/osu.Game/Online/Multiplayer/OnlineMultiplayerClient.cs
index a485a6b262..02e9cd4ee8 100644
--- a/osu.Game/Online/Multiplayer/OnlineMultiplayerClient.cs
+++ b/osu.Game/Online/Multiplayer/OnlineMultiplayerClient.cs
@@ -76,7 +76,32 @@ namespace osu.Game.Online.Multiplayer
             }
         }
 
-        protected override async Task<MultiplayerRoom> JoinRoom(long roomId, string? password = null)
+        protected override async Task<MultiplayerRoom> CreateRoomInternal(MultiplayerRoom room)
+        {
+            if (!IsConnected.Value)
+                throw new OperationCanceledException();
+
+            Debug.Assert(connection != null);
+
+            try
+            {
+                return await connection.InvokeAsync<MultiplayerRoom>(nameof(IMultiplayerServer.CreateRoom), room).ConfigureAwait(false);
+            }
+            catch (HubException exception)
+            {
+                if (exception.GetHubExceptionMessage() == HubClientConnector.SERVER_SHUTDOWN_MESSAGE)
+                {
+                    Debug.Assert(connector != null);
+
+                    await connector.Reconnect().ConfigureAwait(false);
+                    return await CreateRoomInternal(room).ConfigureAwait(false);
+                }
+
+                throw;
+            }
+        }
+
+        protected override async Task<MultiplayerRoom> JoinRoomInternal(long roomId, string? password = null)
         {
             if (!IsConnected.Value)
                 throw new OperationCanceledException();
@@ -94,7 +119,7 @@ namespace osu.Game.Online.Multiplayer
                     Debug.Assert(connector != null);
 
                     await connector.Reconnect().ConfigureAwait(false);
-                    return await JoinRoom(roomId, password).ConfigureAwait(false);
+                    return await JoinRoomInternal(roomId, password).ConfigureAwait(false);
                 }
 
                 throw;
diff --git a/osu.Game/Online/Rooms/CreateRoomRequest.cs b/osu.Game/Online/Rooms/CreateRoomRequest.cs
index 63a3b7bfa8..5b2ea77aad 100644
--- a/osu.Game/Online/Rooms/CreateRoomRequest.cs
+++ b/osu.Game/Online/Rooms/CreateRoomRequest.cs
@@ -15,6 +15,9 @@ namespace osu.Game.Online.Rooms
         public CreateRoomRequest(Room room)
         {
             Room = room;
+
+            // Also copy back to the source model, since it is likely to have been stored elsewhere.
+            Success += r => Room.CopyFrom(r);
         }
 
         protected override WebRequest CreateWebRequest()
@@ -23,7 +26,6 @@ namespace osu.Game.Online.Rooms
 
             req.ContentType = "application/json";
             req.Method = HttpMethod.Post;
-
             req.AddRaw(JsonConvert.SerializeObject(Room));
 
             return req;
diff --git a/osu.Game/Online/Rooms/JoinRoomRequest.cs b/osu.Game/Online/Rooms/JoinRoomRequest.cs
index dfc7a53fb2..610e887242 100644
--- a/osu.Game/Online/Rooms/JoinRoomRequest.cs
+++ b/osu.Game/Online/Rooms/JoinRoomRequest.cs
@@ -16,6 +16,9 @@ namespace osu.Game.Online.Rooms
         {
             Room = room;
             Password = password;
+
+            // Also copy back to the source model, since it is likely to have been stored elsewhere.
+            Success += r => Room.CopyFrom(r);
         }
 
         protected override WebRequest CreateWebRequest()
diff --git a/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs b/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
index b737cda4ba..3234e28166 100644
--- a/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
+++ b/osu.Game/Online/Rooms/MultiplayerPlaylistItem.cs
@@ -66,5 +66,21 @@ namespace osu.Game.Online.Rooms
         public MultiplayerPlaylistItem()
         {
         }
+
+        public MultiplayerPlaylistItem(PlaylistItem item)
+        {
+            ID = item.ID;
+            OwnerID = item.OwnerID;
+            BeatmapID = item.Beatmap.OnlineID;
+            BeatmapChecksum = item.Beatmap.MD5Hash;
+            RulesetID = item.RulesetID;
+            RequiredMods = item.RequiredMods.ToArray();
+            AllowedMods = item.AllowedMods.ToArray();
+            Expired = item.Expired;
+            PlaylistOrder = item.PlaylistOrder ?? 0;
+            PlayedAt = item.PlayedAt;
+            StarRating = item.Beatmap.StarRating;
+            Freestyle = item.Freestyle;
+        }
     }
 }
diff --git a/osu.Game/Online/Rooms/MultiplayerScore.cs b/osu.Game/Online/Rooms/MultiplayerScore.cs
index 2adee26da3..74eaea8dbc 100644
--- a/osu.Game/Online/Rooms/MultiplayerScore.cs
+++ b/osu.Game/Online/Rooms/MultiplayerScore.cs
@@ -80,6 +80,9 @@ namespace osu.Game.Online.Rooms
         [JsonProperty("ruleset_id")]
         public int RulesetId { get; set; }
 
+        [JsonProperty("beatmap_id")]
+        public int BeatmapId { get; set; }
+
         public ScoreInfo CreateScoreInfo(ScoreManager scoreManager, RulesetStore rulesets, [NotNull] BeatmapInfo beatmap)
         {
             var ruleset = rulesets.GetRuleset(RulesetId);
diff --git a/osu.Game/Online/Rooms/Room.cs b/osu.Game/Online/Rooms/Room.cs
index f8660a656e..e965f9c187 100644
--- a/osu.Game/Online/Rooms/Room.cs
+++ b/osu.Game/Online/Rooms/Room.cs
@@ -242,7 +242,7 @@ namespace osu.Game.Online.Rooms
         public int ChannelId
         {
             get => channelId;
-            private set => SetField(ref channelId, value);
+            set => SetField(ref channelId, value);
         }
 
         /// <summary>
@@ -342,6 +342,23 @@ namespace osu.Game.Online.Rooms
         // Not yet serialised (not implemented).
         private RoomAvailability availability;
 
+        public Room()
+        {
+        }
+
+        public Room(MultiplayerRoom room)
+        {
+            RoomID = room.RoomID;
+            Name = room.Settings.Name;
+            Password = room.Settings.Password;
+            Type = room.Settings.MatchType;
+            QueueMode = room.Settings.QueueMode;
+            AutoStartDuration = room.Settings.AutoStartDuration;
+            AutoSkip = room.Settings.AutoSkip;
+            Host = room.Host != null ? new APIUser { Id = room.Host.UserID } : null;
+            Playlist = room.Playlist.Select(p => new PlaylistItem(p)).ToArray();
+        }
+
         /// <summary>
         /// Copies values from another <see cref="Room"/> into this one.
         /// </summary>
diff --git a/osu.Game/OsuGame.cs b/osu.Game/OsuGame.cs
index d23d27c89e..4a9154f14b 100644
--- a/osu.Game/OsuGame.cs
+++ b/osu.Game/OsuGame.cs
@@ -421,6 +421,7 @@ namespace osu.Game
 
             SelectedMods.BindValueChanged(modsChanged);
             Beatmap.BindValueChanged(beatmapChanged, true);
+            configUserActivity.BindValueChanged(_ => updateWindowTitle());
 
             applySafeAreaConsiderations = LocalConfig.GetBindable<bool>(OsuSetting.SafeAreaConsiderations);
             applySafeAreaConsiderations.BindValueChanged(apply => SafeAreaContainer.SafeAreaOverrideEdges = apply.NewValue ? SafeAreaOverrideEdges : Edges.All, true);
@@ -828,6 +829,35 @@ namespace osu.Game
         {
             beatmap.OldValue?.CancelAsyncLoad();
             beatmap.NewValue?.BeginAsyncLoad();
+            updateWindowTitle();
+        }
+
+        private void updateWindowTitle()
+        {
+            if (Host.Window == null)
+                return;
+
+            string newTitle;
+
+            switch (configUserActivity.Value)
+            {
+                default:
+                    newTitle = Name;
+                    break;
+
+                case UserActivity.InGame:
+                case UserActivity.TestingBeatmap:
+                case UserActivity.WatchingReplay:
+                    newTitle = $"{Name} - {Beatmap.Value.BeatmapInfo.GetDisplayTitleRomanisable(true, false)}";
+                    break;
+
+                case UserActivity.EditingBeatmap:
+                    newTitle = $"{Name} - {Beatmap.Value.BeatmapInfo.Path ?? "new beatmap"}";
+                    break;
+            }
+
+            if (newTitle != Host.Window.Title)
+                Host.Window.Title = newTitle;
         }
 
         private void modsChanged(ValueChangedEvent<IReadOnlyList<Mod>> mods)
diff --git a/osu.Game/Overlays/BeatmapSet/BeatmapAvailability.cs b/osu.Game/Overlays/BeatmapSet/BeatmapAvailability.cs
index d18e1c93c9..c9783d42dc 100644
--- a/osu.Game/Overlays/BeatmapSet/BeatmapAvailability.cs
+++ b/osu.Game/Overlays/BeatmapSet/BeatmapAvailability.cs
@@ -39,7 +39,6 @@ namespace osu.Game.Overlays.BeatmapSet
                 },
                 textContainer = new LinkFlowContainer(t => t.Font = OsuFont.GetFont(size: 14))
                 {
-                    Direction = FillDirection.Full,
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
                     Padding = new MarginPadding(10),
diff --git a/osu.Game/Overlays/BeatmapSet/Buttons/FavouriteButton.cs b/osu.Game/Overlays/BeatmapSet/Buttons/FavouriteButton.cs
index cbdb2ea190..eab394c8f6 100644
--- a/osu.Game/Overlays/BeatmapSet/Buttons/FavouriteButton.cs
+++ b/osu.Game/Overlays/BeatmapSet/Buttons/FavouriteButton.cs
@@ -7,7 +7,6 @@ using System.Diagnostics;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Graphics.UserInterface;
@@ -21,7 +20,7 @@ using APIUser = osu.Game.Online.API.Requests.Responses.APIUser;
 
 namespace osu.Game.Overlays.BeatmapSet.Buttons
 {
-    public partial class FavouriteButton : HeaderButton, IHasTooltip
+    public partial class FavouriteButton : HeaderButton
     {
         public readonly Bindable<APIBeatmapSet> BeatmapSet = new Bindable<APIBeatmapSet>();
 
@@ -32,7 +31,7 @@ namespace osu.Game.Overlays.BeatmapSet.Buttons
 
         private readonly IBindable<APIUser> localUser = new Bindable<APIUser>();
 
-        public LocalisableString TooltipText
+        public override LocalisableString TooltipText
         {
             get
             {
diff --git a/osu.Game/Overlays/Changelog/ChangelogEntry.cs b/osu.Game/Overlays/Changelog/ChangelogEntry.cs
index 9c40440778..d6021972c6 100644
--- a/osu.Game/Overlays/Changelog/ChangelogEntry.cs
+++ b/osu.Game/Overlays/Changelog/ChangelogEntry.cs
@@ -82,7 +82,6 @@ namespace osu.Game.Overlays.Changelog
                     },
                     title = new LinkFlowContainer
                     {
-                        Direction = FillDirection.Full,
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
                         TextAnchor = Anchor.BottomLeft,
diff --git a/osu.Game/Overlays/Chat/ChannelList/ChannelList.cs b/osu.Game/Overlays/Chat/ChannelList/ChannelList.cs
index f027888962..03f6923455 100644
--- a/osu.Game/Overlays/Chat/ChannelList/ChannelList.cs
+++ b/osu.Game/Overlays/Chat/ChannelList/ChannelList.cs
@@ -9,6 +9,7 @@ using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
 using osu.Framework.Testing;
@@ -39,6 +40,7 @@ namespace osu.Game.Overlays.Chat.ChannelList
 
         public ChannelGroup AnnounceChannelGroup { get; private set; } = null!;
         public ChannelGroup PublicChannelGroup { get; private set; } = null!;
+        public ChannelGroup TeamChannelGroup { get; private set; } = null!;
         public ChannelGroup PrivateChannelGroup { get; private set; } = null!;
 
         private OsuScrollContainer scroll = null!;
@@ -79,10 +81,12 @@ namespace osu.Game.Overlays.Chat.ChannelList
                                     RelativeSizeAxes = Axes.X,
                                 }
                             },
-                            AnnounceChannelGroup = new ChannelGroup(ChatStrings.ChannelsListTitleANNOUNCE.ToUpper(), false),
-                            PublicChannelGroup = new ChannelGroup(ChatStrings.ChannelsListTitlePUBLIC.ToUpper(), false),
+                            // cross-reference for icons: https://github.com/ppy/osu-web/blob/3c9e99eaf4bd9e73d2712f60d67f5bc95f9dfe2b/resources/js/chat/conversation-list.tsx#L13-L19
+                            AnnounceChannelGroup = new ChannelGroup(ChatStrings.ChannelsListTitleANNOUNCE.ToUpper(), FontAwesome.Solid.Bullhorn, false),
+                            PublicChannelGroup = new ChannelGroup(ChatStrings.ChannelsListTitlePUBLIC.ToUpper(), FontAwesome.Solid.Comments, false),
                             selector = new ChannelListItem(ChannelListingChannel),
-                            PrivateChannelGroup = new ChannelGroup(ChatStrings.ChannelsListTitlePM.ToUpper(), true),
+                            TeamChannelGroup = new ChannelGroup(ChatStrings.ChannelsListTitleTEAM.ToUpper(), FontAwesome.Solid.Users, false),
+                            PrivateChannelGroup = new ChannelGroup(ChatStrings.ChannelsListTitlePM.ToUpper(), FontAwesome.Solid.Envelope, true),
                         },
                     },
                 },
@@ -102,6 +106,7 @@ namespace osu.Game.Overlays.Chat.ChannelList
             };
 
             selector.OnRequestSelect += chan => OnRequestSelect?.Invoke(chan);
+            updateVisibility();
         }
 
         public void AddChannel(Channel channel)
@@ -109,9 +114,13 @@ namespace osu.Game.Overlays.Chat.ChannelList
             if (channelMap.ContainsKey(channel))
                 return;
 
-            ChannelListItem item = new ChannelListItem(channel);
+            ChannelListItem item = new ChannelListItem(channel)
+            {
+                CanLeave = channel.Type != ChannelType.Team
+            };
             item.OnRequestSelect += chan => OnRequestSelect?.Invoke(chan);
-            item.OnRequestLeave += chan => OnRequestLeave?.Invoke(chan);
+            if (item.CanLeave)
+                item.OnRequestLeave += chan => OnRequestLeave?.Invoke(chan);
 
             ChannelGroup group = getGroupFromChannel(channel);
             channelMap.Add(channel, item);
@@ -156,6 +165,9 @@ namespace osu.Game.Overlays.Chat.ChannelList
                 case ChannelType.Announce:
                     return AnnounceChannelGroup;
 
+                case ChannelType.Team:
+                    return TeamChannelGroup;
+
                 default:
                     return PublicChannelGroup;
             }
@@ -163,10 +175,8 @@ namespace osu.Game.Overlays.Chat.ChannelList
 
         private void updateVisibility()
         {
-            if (AnnounceChannelGroup.ItemFlow.Children.Count == 0)
-                AnnounceChannelGroup.Hide();
-            else
-                AnnounceChannelGroup.Show();
+            AnnounceChannelGroup.Alpha = AnnounceChannelGroup.ItemFlow.Any() ? 1 : 0;
+            TeamChannelGroup.Alpha = TeamChannelGroup.ItemFlow.Any() ? 1 : 0;
         }
 
         public partial class ChannelGroup : FillFlowContainer
@@ -174,7 +184,7 @@ namespace osu.Game.Overlays.Chat.ChannelList
             private readonly bool sortByRecent;
             public readonly ChannelListItemFlow ItemFlow;
 
-            public ChannelGroup(LocalisableString label, bool sortByRecent)
+            public ChannelGroup(LocalisableString label, IconUsage icon, bool sortByRecent)
             {
                 this.sortByRecent = sortByRecent;
                 Direction = FillDirection.Vertical;
@@ -184,11 +194,26 @@ namespace osu.Game.Overlays.Chat.ChannelList
 
                 Children = new Drawable[]
                 {
-                    new OsuSpriteText
+                    new FillFlowContainer
                     {
-                        Text = label,
-                        Margin = new MarginPadding { Left = 18, Bottom = 5 },
-                        Font = OsuFont.Torus.With(size: 12, weight: FontWeight.SemiBold),
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Direction = FillDirection.Horizontal,
+                        Spacing = new Vector2(5),
+                        Children = new Drawable[]
+                        {
+                            new OsuSpriteText
+                            {
+                                Text = label,
+                                Margin = new MarginPadding { Left = 18, Bottom = 5 },
+                                Font = OsuFont.Torus.With(size: 12, weight: FontWeight.SemiBold),
+                            },
+                            new SpriteIcon
+                            {
+                                Icon = icon,
+                                Size = new Vector2(12),
+                            },
+                        }
                     },
                     ItemFlow = new ChannelListItemFlow(sortByRecent)
                     {
diff --git a/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs b/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs
index b197fe199d..6107f130ec 100644
--- a/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs
+++ b/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs
@@ -24,6 +24,8 @@ namespace osu.Game.Overlays.Chat.ChannelList
     public partial class ChannelListItem : OsuClickableContainer, IFilterable
     {
         public event Action<Channel>? OnRequestSelect;
+
+        public bool CanLeave { get; init; } = true;
         public event Action<Channel>? OnRequestLeave;
 
         public readonly Channel Channel;
@@ -160,7 +162,7 @@ namespace osu.Game.Overlays.Chat.ChannelList
 
         private ChannelListItemCloseButton? createCloseButton()
         {
-            if (isSelector)
+            if (isSelector || !CanLeave)
                 return null;
 
             return new ChannelListItemCloseButton
diff --git a/osu.Game/Overlays/Chat/ChatLine.cs b/osu.Game/Overlays/Chat/ChatLine.cs
index e386f2ac09..20c3b26b8b 100644
--- a/osu.Game/Overlays/Chat/ChatLine.cs
+++ b/osu.Game/Overlays/Chat/ChatLine.cs
@@ -46,7 +46,7 @@ namespace osu.Game.Overlays.Chat
             }
         }
 
-        public IReadOnlyCollection<Drawable> DrawableContentFlow => drawableContentFlow;
+        public IEnumerable<Drawable> DrawableContentFlow => drawableContentFlow.Children;
 
         private const float font_size = 13;
 
diff --git a/osu.Game/Overlays/Chat/DrawableChatUsername.cs b/osu.Game/Overlays/Chat/DrawableChatUsername.cs
index 67191f6836..83f67d1a8a 100644
--- a/osu.Game/Overlays/Chat/DrawableChatUsername.cs
+++ b/osu.Game/Overlays/Chat/DrawableChatUsername.cs
@@ -178,7 +178,7 @@ namespace osu.Game.Overlays.Chat
                 }
 
                 if (!user.Equals(api.LocalUser.Value))
-                    items.Add(new OsuMenuItem("Report", MenuItemType.Destructive, ReportRequested));
+                    items.Add(new OsuMenuItem(UsersStrings.ReportButtonText, MenuItemType.Destructive, ReportRequested));
 
                 return items.ToArray();
             }
diff --git a/osu.Game/Overlays/ChatOverlay.cs b/osu.Game/Overlays/ChatOverlay.cs
index c49afa3a66..7f4ba3e2e2 100644
--- a/osu.Game/Overlays/ChatOverlay.cs
+++ b/osu.Game/Overlays/ChatOverlay.cs
@@ -228,7 +228,8 @@ namespace osu.Game.Overlays
                     return true;
 
                 case PlatformAction.DocumentClose:
-                    channelManager.LeaveChannel(currentChannel.Value);
+                    if (currentChannel.Value?.Type != ChannelType.Team)
+                        channelManager.LeaveChannel(currentChannel.Value);
                     return true;
 
                 case PlatformAction.TabRestore:
diff --git a/osu.Game/Overlays/Mods/ModSelectOverlay.cs b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
index daac925dfb..ac589fbebf 100644
--- a/osu.Game/Overlays/Mods/ModSelectOverlay.cs
+++ b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
@@ -35,7 +35,7 @@ using osuTK.Input;
 
 namespace osu.Game.Overlays.Mods
 {
-    public abstract partial class ModSelectOverlay : ShearedOverlayContainer, ISamplePlaybackDisabler, IKeyBindingHandler<PlatformAction>
+    public partial class ModSelectOverlay : ShearedOverlayContainer, ISamplePlaybackDisabler, IKeyBindingHandler<PlatformAction>
     {
         public const int BUTTON_WIDTH = 200;
 
@@ -96,7 +96,7 @@ namespace osu.Game.Overlays.Mods
         /// <summary>
         /// Whether the column with available mod presets should be shown.
         /// </summary>
-        protected virtual bool ShowPresets => false;
+        public bool ShowPresets { get; init; }
 
         protected virtual ModColumn CreateModColumn(ModType modType) => new ModColumn(modType, false);
 
@@ -125,7 +125,7 @@ namespace osu.Game.Overlays.Mods
         [Resolved]
         private ScreenFooter? footer { get; set; }
 
-        protected ModSelectOverlay(OverlayColourScheme colourScheme = OverlayColourScheme.Green)
+        public ModSelectOverlay(OverlayColourScheme colourScheme = OverlayColourScheme.Green)
             : base(colourScheme)
         {
         }
diff --git a/osu.Game/Overlays/Music/PlaylistItem.cs b/osu.Game/Overlays/Music/PlaylistItem.cs
index 90fdfd0491..01b0472172 100644
--- a/osu.Game/Overlays/Music/PlaylistItem.cs
+++ b/osu.Game/Overlays/Music/PlaylistItem.cs
@@ -63,7 +63,6 @@ namespace osu.Game.Overlays.Music
                 {
                     sprite.Font = OsuFont.GetFont(size: 14, weight: FontWeight.Bold);
                     sprite.Colour = colours.Gray9;
-                    sprite.Padding = new MarginPadding { Top = 1 };
                 });
 
                 SelectedSet.BindValueChanged(set => updateSelectionState(set.NewValue));
diff --git a/osu.Game/Overlays/NotificationOverlayToastTray.cs b/osu.Game/Overlays/NotificationOverlayToastTray.cs
index ddb2e02fb8..dd60e303f6 100644
--- a/osu.Game/Overlays/NotificationOverlayToastTray.cs
+++ b/osu.Game/Overlays/NotificationOverlayToastTray.cs
@@ -174,7 +174,7 @@ namespace osu.Game.Overlays
                 }
 
                 height = toastFlow.DrawHeight + 120;
-                alpha = MathHelper.Clamp(toastFlow.DrawHeight / 41, 0, 1) * maxNotificationAlpha;
+                alpha = Math.Clamp(toastFlow.DrawHeight / 41, 0, 1) * maxNotificationAlpha;
             }
 
             toastContentBackground.Height = (float)Interpolation.DampContinuously(toastContentBackground.Height, height, 10, Clock.ElapsedFrameTime);
diff --git a/osu.Game/Overlays/Profile/Header/Components/PreviousUsernamesDisplay.cs b/osu.Game/Overlays/Profile/Header/Components/PreviousUsernamesDisplay.cs
index dce5c84d12..1cd09566fb 100644
--- a/osu.Game/Overlays/Profile/Header/Components/PreviousUsernamesDisplay.cs
+++ b/osu.Game/Overlays/Profile/Header/Components/PreviousUsernamesDisplay.cs
@@ -85,7 +85,6 @@ namespace osu.Game.Overlays.Profile.Header.Components
                             {
                                 RelativeSizeAxes = Axes.X,
                                 AutoSizeAxes = Axes.Y,
-                                Direction = FillDirection.Full,
                                 // Prevents the tooltip of having a sudden size reduction and flickering when the text is being faded out.
                                 // Also prevents a potential OnHover/HoverLost feedback loop.
                                 AlwaysPresent = true,
diff --git a/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs b/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs
index 00ffbc1120..e104bb7e39 100644
--- a/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs
@@ -45,6 +45,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
 
         private readonly BindableNumber<float> rotation = new BindableNumber<float> { MinValue = 0, MaxValue = 360 };
 
+        private readonly BindableNumber<float> pressureThreshold = new BindableNumber<float> { MinValue = 0.0f, MaxValue = 1.0f, Precision = 0.005f };
+
         [Resolved]
         private GameHost host { get; set; }
 
@@ -213,6 +215,13 @@ namespace osu.Game.Overlays.Settings.Sections.Input
                             Current = sizeY,
                             CanBeShown = { BindTarget = enabled }
                         },
+                        new SettingsPercentageSlider<float>
+                        {
+                            TransferValueOnCommit = true,
+                            LabelText = TabletSettingsStrings.TipPressureForClick,
+                            Current = pressureThreshold,
+                            CanBeShown = { BindTarget = enabled }
+                        },
                     }
                 },
             };
@@ -267,6 +276,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
                 aspectRatioApplication = Schedule(() => forceAspectRatio(aspect.NewValue));
             });
 
+            pressureThreshold.BindTo(tabletHandler.PressureThreshold);
+
             tablet.BindTo(tabletHandler.Tablet);
             tablet.BindValueChanged(val => Schedule(() =>
             {
diff --git a/osu.Game/Overlays/Settings/Sections/SkinSection.cs b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
index a89d5e2f4a..84767c8619 100644
--- a/osu.Game/Overlays/Settings/Sections/SkinSection.cs
+++ b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
@@ -27,6 +27,7 @@ using osu.Game.Screens.Select;
 using osu.Game.Skinning;
 using osuTK;
 using Realms;
+using WebCommonStrings = osu.Game.Resources.Localisation.Web.CommonStrings;
 
 namespace osu.Game.Overlays.Settings.Sections
 {
@@ -165,7 +166,7 @@ namespace osu.Game.Overlays.Settings.Sections
             [BackgroundDependencyLoader]
             private void load()
             {
-                Text = "Rename";
+                Text = CommonStrings.Rename;
                 Action = this.ShowPopover;
             }
 
@@ -193,7 +194,7 @@ namespace osu.Game.Overlays.Settings.Sections
             [BackgroundDependencyLoader]
             private void load()
             {
-                Text = "Export";
+                Text = CommonStrings.Export;
                 Action = export;
             }
 
@@ -231,7 +232,7 @@ namespace osu.Game.Overlays.Settings.Sections
             [BackgroundDependencyLoader]
             private void load()
             {
-                Text = "Delete";
+                Text = WebCommonStrings.ButtonsDelete;
                 Action = delete;
             }
 
diff --git a/osu.Game/Overlays/Settings/SettingsButton.cs b/osu.Game/Overlays/Settings/SettingsButton.cs
index 3f5d612eb8..196ddca953 100644
--- a/osu.Game/Overlays/Settings/SettingsButton.cs
+++ b/osu.Game/Overlays/Settings/SettingsButton.cs
@@ -6,13 +6,12 @@ using System.Collections.Generic;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
 using osu.Framework.Localisation;
 using osu.Game.Graphics.UserInterfaceV2;
 
 namespace osu.Game.Overlays.Settings
 {
-    public partial class SettingsButton : RoundedButton, IHasTooltip, IConditionalFilterable
+    public partial class SettingsButton : RoundedButton, IConditionalFilterable
     {
         public SettingsButton()
         {
@@ -25,8 +24,6 @@ namespace osu.Game.Overlays.Settings
         public BindableBool CanBeShown { get; } = new BindableBool(true);
         IBindable<bool> IConditionalFilterable.CanBeShown => CanBeShown;
 
-        public LocalisableString TooltipText { get; set; }
-
         public override IEnumerable<LocalisableString> FilterTerms
         {
             get
diff --git a/osu.Game/Overlays/SettingsOverlay.cs b/osu.Game/Overlays/SettingsOverlay.cs
index 1157860e03..630675a717 100644
--- a/osu.Game/Overlays/SettingsOverlay.cs
+++ b/osu.Game/Overlays/SettingsOverlay.cs
@@ -68,6 +68,9 @@ namespace osu.Game.Overlays
         public void ShowAtControl<T>()
             where T : Drawable
         {
+            // if search isn't cleared then the target control won't be visible if it doesn't match the query
+            SearchTextBox.Current.SetDefault();
+
             Show();
 
             // wait for load of sections
diff --git a/osu.Game/Overlays/SettingsPanel.cs b/osu.Game/Overlays/SettingsPanel.cs
index df50e0f339..9b268c573f 100644
--- a/osu.Game/Overlays/SettingsPanel.cs
+++ b/osu.Game/Overlays/SettingsPanel.cs
@@ -54,7 +54,7 @@ namespace osu.Game.Overlays
 
         public SettingsSectionsContainer SectionsContainer { get; private set; }
 
-        private SeekLimitedSearchTextBox searchTextBox;
+        protected SeekLimitedSearchTextBox SearchTextBox { get; private set; }
 
         protected override string PopInSampleName => "UI/settings-pop-in";
         protected override double PopInOutSampleBalance => -OsuGameBase.SFX_STEREO_STRENGTH;
@@ -135,7 +135,7 @@ namespace osu.Game.Overlays
                         },
                         Anchor = Anchor.TopCentre,
                         Origin = Anchor.TopCentre,
-                        Child = searchTextBox = new SettingsSearchTextBox
+                        Child = SearchTextBox = new SettingsSearchTextBox
                         {
                             RelativeSizeAxes = Axes.X,
                             Origin = Anchor.TopCentre,
@@ -183,8 +183,8 @@ namespace osu.Game.Overlays
             Sidebar?.MoveToX(0, TRANSITION_LENGTH, Easing.OutQuint);
             this.FadeTo(1, TRANSITION_LENGTH / 2, Easing.OutQuint);
 
-            searchTextBox.TakeFocus();
-            searchTextBox.HoldFocus = true;
+            SearchTextBox.TakeFocus();
+            SearchTextBox.HoldFocus = true;
         }
 
         protected virtual float ExpandedPosition => 0;
@@ -199,8 +199,8 @@ namespace osu.Game.Overlays
             Sidebar?.MoveToX(-sidebar_width, TRANSITION_LENGTH, Easing.OutQuint);
             this.FadeTo(0, TRANSITION_LENGTH / 2, Easing.OutQuint);
 
-            searchTextBox.HoldFocus = false;
-            if (searchTextBox.HasFocus)
+            SearchTextBox.HoldFocus = false;
+            if (SearchTextBox.HasFocus)
                 GetContainingFocusManager()!.ChangeFocus(null);
         }
 
@@ -208,7 +208,7 @@ namespace osu.Game.Overlays
 
         protected override void OnFocus(FocusEvent e)
         {
-            searchTextBox.TakeFocus();
+            SearchTextBox.TakeFocus();
             base.OnFocus(e);
         }
 
@@ -234,7 +234,7 @@ namespace osu.Game.Overlays
 
                 loading.Hide();
 
-                searchTextBox.Current.BindValueChanged(term => SectionsContainer.SearchTerm = term.NewValue, true);
+                SearchTextBox.Current.BindValueChanged(term => SectionsContainer.SearchTerm = term.NewValue, true);
 
                 loadSidebarButtons();
             });
diff --git a/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs b/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs
index 7b6bc37a61..59511973f7 100644
--- a/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs
+++ b/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs
@@ -17,19 +17,15 @@ namespace osu.Game.Rulesets.Difficulty
     {
         protected const int ATTRIB_ID_AIM = 1;
         protected const int ATTRIB_ID_SPEED = 3;
-        protected const int ATTRIB_ID_OVERALL_DIFFICULTY = 5;
-        protected const int ATTRIB_ID_APPROACH_RATE = 7;
         protected const int ATTRIB_ID_MAX_COMBO = 9;
         protected const int ATTRIB_ID_DIFFICULTY = 11;
-        protected const int ATTRIB_ID_GREAT_HIT_WINDOW = 13;
-        protected const int ATTRIB_ID_SCORE_MULTIPLIER = 15;
         protected const int ATTRIB_ID_FLASHLIGHT = 17;
         protected const int ATTRIB_ID_SLIDER_FACTOR = 19;
         protected const int ATTRIB_ID_SPEED_NOTE_COUNT = 21;
         protected const int ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT = 23;
         protected const int ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT = 25;
-        protected const int ATTRIB_ID_OK_HIT_WINDOW = 27;
         protected const int ATTRIB_ID_MONO_STAMINA_FACTOR = 29;
+        protected const int ATTRIB_ID_AIM_DIFFICULT_SLIDER_COUNT = 31;
 
         /// <summary>
         /// The mods which were applied to the beatmap.
diff --git a/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs b/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
index 14acc9b908..add24f7866 100644
--- a/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
+++ b/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
@@ -62,6 +62,11 @@ namespace osu.Game.Rulesets.Difficulty
         /// <returns>A structure describing the difficulty of the beatmap.</returns>
         public DifficultyAttributes Calculate([NotNull] IEnumerable<Mod> mods, CancellationToken cancellationToken = default)
         {
+            using var timedCancellationSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+
+            if (!cancellationToken.CanBeCanceled)
+                cancellationToken = timedCancellationSource.Token;
+
             cancellationToken.ThrowIfCancellationRequested();
             preProcess(mods, cancellationToken);
 
@@ -98,6 +103,11 @@ namespace osu.Game.Rulesets.Difficulty
         /// <returns>The set of <see cref="TimedDifficultyAttributes"/>.</returns>
         public List<TimedDifficultyAttributes> CalculateTimed([NotNull] IEnumerable<Mod> mods, CancellationToken cancellationToken = default)
         {
+            using var timedCancellationSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+
+            if (!cancellationToken.CanBeCanceled)
+                cancellationToken = timedCancellationSource.Token;
+
             cancellationToken.ThrowIfCancellationRequested();
             preProcess(mods, cancellationToken);
 
@@ -166,15 +176,10 @@ namespace osu.Game.Rulesets.Difficulty
         /// </summary>
         /// <param name="mods">The original list of <see cref="Mod"/>s.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
-        private void preProcess([NotNull] IEnumerable<Mod> mods, CancellationToken cancellationToken = default)
+        private void preProcess([NotNull] IEnumerable<Mod> mods, CancellationToken cancellationToken)
         {
             playableMods = mods.Select(m => m.DeepClone()).ToArray();
-
-            // Only pass through the cancellation token if it's non-default.
-            // This allows for the default timeout to be applied for playable beatmap construction.
-            Beatmap = cancellationToken == default
-                ? beatmap.GetPlayableBeatmap(ruleset, playableMods)
-                : beatmap.GetPlayableBeatmap(ruleset, playableMods, cancellationToken);
+            Beatmap = beatmap.GetPlayableBeatmap(ruleset, playableMods, cancellationToken);
 
             var track = new TrackVirtual(10000);
             playableMods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));
diff --git a/osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils.cs b/osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils.cs
index b9efcd683d..78df8a139b 100644
--- a/osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils.cs
+++ b/osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils.cs
@@ -2,10 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 
 namespace osu.Game.Rulesets.Difficulty.Utils
 {
-    public static class DifficultyCalculationUtils
+    public static partial class DifficultyCalculationUtils
     {
         /// <summary>
         /// Converts BPM value into milliseconds
@@ -46,5 +47,60 @@ namespace osu.Game.Rulesets.Difficulty.Utils
         /// <param name="exponent">Exponent</param>
         /// <returns>The output of logistic function</returns>
         public static double Logistic(double exponent, double maxValue = 1) => maxValue / (1 + Math.Exp(exponent));
+
+        /// <summary>
+        /// Returns the <i>p</i>-norm of an <i>n</i>-dimensional vector (https://en.wikipedia.org/wiki/Norm_(mathematics))
+        /// </summary>
+        /// <param name="p">The value of <i>p</i> to calculate the norm for.</param>
+        /// <param name="values">The coefficients of the vector.</param>
+        /// <returns>The <i>p</i>-norm of the vector.</returns>
+        public static double Norm(double p, params double[] values) => Math.Pow(values.Sum(x => Math.Pow(x, p)), 1 / p);
+
+        /// <summary>
+        /// Calculates a Gaussian-based bell curve function (https://en.wikipedia.org/wiki/Gaussian_function)
+        /// </summary>
+        /// <param name="x">Value to calculate the function for</param>
+        /// <param name="mean">The mean (center) of the bell curve</param>
+        /// <param name="width">The width (spread) of the curve</param>
+        /// <param name="multiplier">Multiplier to adjust the curve's height</param>
+        /// <returns>The output of the bell curve function of <paramref name="x"/></returns>
+        public static double BellCurve(double x, double mean, double width, double multiplier = 1.0) => multiplier * Math.Exp(Math.E * -(Math.Pow(x - mean, 2) / Math.Pow(width, 2)));
+
+        /// <summary>
+        /// Smoothstep function (https://en.wikipedia.org/wiki/Smoothstep)
+        /// </summary>
+        /// <param name="x">Value to calculate the function for</param>
+        /// <param name="start">Value at which function returns 0</param>
+        /// <param name="end">Value at which function returns 1</param>
+        public static double Smoothstep(double x, double start, double end)
+        {
+            x = Math.Clamp((x - start) / (end - start), 0.0, 1.0);
+
+            return x * x * (3.0 - 2.0 * x);
+        }
+
+        /// <summary>
+        /// Smootherstep function (https://en.wikipedia.org/wiki/Smoothstep#Variations)
+        /// </summary>
+        /// <param name="x">Value to calculate the function for</param>
+        /// <param name="start">Value at which function returns 0</param>
+        /// <param name="end">Value at which function returns 1</param>
+        public static double Smootherstep(double x, double start, double end)
+        {
+            x = Math.Clamp((x - start) / (end - start), 0.0, 1.0);
+
+            return x * x * x * (x * (6.0 * x - 15.0) + 10.0);
+        }
+
+        /// <summary>
+        /// Reverse linear interpolation function (https://en.wikipedia.org/wiki/Linear_interpolation)
+        /// </summary>
+        /// <param name="x">Value to calculate the function for</param>
+        /// <param name="start">Value at which function returns 0</param>
+        /// <param name="end">Value at which function returns 1</param>
+        public static double ReverseLerp(double x, double start, double end)
+        {
+            return Math.Clamp((x - start) / (end - start), 0.0, 1.0);
+        }
     }
 }
diff --git a/osu.Game/Utils/SpecialFunctions.cs b/osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils_ErrorFunction.cs
similarity index 99%
rename from osu.Game/Utils/SpecialFunctions.cs
rename to osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils_ErrorFunction.cs
index 795a84a973..4b89cbe7cc 100644
--- a/osu.Game/Utils/SpecialFunctions.cs
+++ b/osu.Game/Rulesets/Difficulty/Utils/DifficultyCalculationUtils_ErrorFunction.cs
@@ -3,7 +3,6 @@
 
 // All code is referenced from the following:
 // https://github.com/mathnet/mathnet-numerics/blob/master/src/Numerics/SpecialFunctions/Erf.cs
-// https://github.com/mathnet/mathnet-numerics/blob/master/src/Numerics/Optimization/NelderMeadSimplex.cs
 
 /*
  Copyright (c) 2002-2022 Math.NET
@@ -14,12 +13,10 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 using System;
 
-namespace osu.Game.Utils
+namespace osu.Game.Rulesets.Difficulty.Utils
 {
-    public class SpecialFunctions
+    public partial class DifficultyCalculationUtils
     {
-        private const double sqrt2_pi = 2.5066282746310005024157652848110452530069867406099d;
-
         /// <summary>
         /// **************************************
         /// COEFFICIENTS FOR METHOD ErfImp       *
diff --git a/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs b/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs
index d0b279f201..4129a6fb2c 100644
--- a/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs
+++ b/osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs
@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Edit
         private EditorClock editorClock { get; set; } = null!;
 
         [Resolved]
-        private EditorBeatmap editorBeatmap { get; set; } = null!;
+        protected EditorBeatmap EditorBeatmap { get; private set; } = null!;
 
         [Resolved]
         private IBeatSnapProvider beatSnapProvider { get; set; } = null!;
@@ -100,7 +100,7 @@ namespace osu.Game.Rulesets.Edit
                 }
             });
 
-            DistanceSpacingMultiplier.Value = editorBeatmap.DistanceSpacing;
+            DistanceSpacingMultiplier.Value = EditorBeatmap.DistanceSpacing;
             DistanceSpacingMultiplier.BindValueChanged(multiplier =>
             {
                 distanceSpacingSlider.ContractedLabelText = $"D. S. ({multiplier.NewValue:0.##x})";
@@ -109,7 +109,7 @@ namespace osu.Game.Rulesets.Edit
                 if (multiplier.NewValue != multiplier.OldValue)
                     onScreenDisplay?.Display(new DistanceSpacingToast(multiplier.NewValue.ToLocalisableString(@"0.##x"), multiplier));
 
-                editorBeatmap.DistanceSpacing = multiplier.NewValue;
+                EditorBeatmap.DistanceSpacing = multiplier.NewValue;
             }, true);
 
             DistanceSpacingMultiplier.BindDisabledChanged(disabled => distanceSpacingSlider.Alpha = disabled ? 0 : 1, true);
@@ -267,7 +267,7 @@ namespace osu.Game.Rulesets.Edit
 
         public virtual float GetBeatSnapDistance(IHasSliderVelocity? withVelocity = null)
         {
-            return (float)(100 * (withVelocity?.SliderVelocityMultiplier ?? 1) * editorBeatmap.Difficulty.SliderMultiplier * 1
+            return (float)(100 * (withVelocity?.SliderVelocityMultiplier ?? 1) * EditorBeatmap.Difficulty.SliderMultiplier * 1
                            / beatSnapProvider.BeatDivisor);
         }
 
diff --git a/osu.Game/Rulesets/Mods/DifficultyAdjustSettingsControl.cs b/osu.Game/Rulesets/Mods/DifficultyAdjustSettingsControl.cs
index d04d7636ec..6697a8d848 100644
--- a/osu.Game/Rulesets/Mods/DifficultyAdjustSettingsControl.cs
+++ b/osu.Game/Rulesets/Mods/DifficultyAdjustSettingsControl.cs
@@ -31,12 +31,7 @@ namespace osu.Game.Rulesets.Mods
 
         protected sealed override Drawable CreateControl() => new SliderControl(sliderDisplayCurrent, CreateSlider);
 
-        protected virtual RoundedSliderBar<float> CreateSlider(BindableNumber<float> current) => new RoundedSliderBar<float>
-        {
-            RelativeSizeAxes = Axes.X,
-            Current = current,
-            KeyboardStep = 0.1f,
-        };
+        protected virtual RoundedSliderBar<float> CreateSlider(BindableNumber<float> current) => new RoundedSliderBar<float>();
 
         /// <summary>
         /// Guards against beatmap values displayed on slider bars being transferred to user override.
@@ -111,7 +106,21 @@ namespace osu.Game.Rulesets.Mods
             {
                 InternalChildren = new Drawable[]
                 {
-                    createSlider(currentNumber)
+                    createSlider(currentNumber).With(slider =>
+                    {
+                        slider.RelativeSizeAxes = Axes.X;
+                        slider.Current = currentNumber;
+                        slider.KeyboardStep = 0.1f;
+                        // this looks redundant, but isn't because of the various games this component plays
+                        // (`Current` is nullable and represents the underlying setting value,
+                        // `currentNumber` is not nullable and represents what is getting displayed,
+                        // therefore without this, double-clicking the slider would reset `currentNumber` to its bogus default of 0).
+                        slider.ResetToDefault = () =>
+                        {
+                            if (!Current.Disabled)
+                                Current.SetDefault();
+                        };
+                    })
                 };
 
                 AutoSizeAxes = Axes.Y;
diff --git a/osu.Game/Rulesets/Objects/HitObject.cs b/osu.Game/Rulesets/Objects/HitObject.cs
index 9f980769e2..07e07b25d3 100644
--- a/osu.Game/Rulesets/Objects/HitObject.cs
+++ b/osu.Game/Rulesets/Objects/HitObject.cs
@@ -104,6 +104,8 @@ namespace osu.Game.Rulesets.Objects
         /// <param name="cancellationToken">The cancellation token.</param>
         public void ApplyDefaults(ControlPointInfo controlPointInfo, IBeatmapDifficultyInfo difficulty, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             nestedHitObjects.Clear();
@@ -114,6 +116,8 @@ namespace osu.Game.Rulesets.Objects
             {
                 foreach (HitObject hitObject in nestedHitObjects)
                 {
+                    cancellationToken.ThrowIfCancellationRequested();
+
                     if (hitObject is IHasComboInformation n)
                     {
                         n.ComboIndexBindable.BindTo(hasCombo.ComboIndexBindable);
diff --git a/osu.Game/Rulesets/Objects/SliderEventGenerator.cs b/osu.Game/Rulesets/Objects/SliderEventGenerator.cs
index f5146d1675..e5e15042ff 100644
--- a/osu.Game/Rulesets/Objects/SliderEventGenerator.cs
+++ b/osu.Game/Rulesets/Objects/SliderEventGenerator.cs
@@ -46,6 +46,8 @@ namespace osu.Game.Rulesets.Objects
 
             for (int span = 0; span < spanCount; span++)
             {
+                cancellationToken.ThrowIfCancellationRequested();
+
                 double spanStartTime = startTime + span * spanDuration;
                 bool reversed = span % 2 == 1;
 
diff --git a/osu.Game/Rulesets/Objects/SliderPath.cs b/osu.Game/Rulesets/Objects/SliderPath.cs
index 5550815370..eb591ec530 100644
--- a/osu.Game/Rulesets/Objects/SliderPath.cs
+++ b/osu.Game/Rulesets/Objects/SliderPath.cs
@@ -31,7 +31,10 @@ namespace osu.Game.Rulesets.Objects
         /// </summary>
         public readonly Bindable<double?> ExpectedDistance = new Bindable<double?>();
 
-        public bool HasValidLength => Precision.DefinitelyBigger(Distance, 0);
+        /// <summary>
+        /// Should be used to check whether placement can continue after a user editor operation.
+        /// </summary>
+        public bool HasValidLengthForPlacement => Precision.DefinitelyBigger(Distance, 0, 1);
 
         /// <summary>
         /// The control points of the path.
diff --git a/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs b/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
index 7841e65935..8b0076afa1 100644
--- a/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
+++ b/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
@@ -247,7 +247,12 @@ namespace osu.Game.Rulesets.UI.Scrolling
             // It is required that we set a lifetime end here to ensure that in scenarios like loading a Player instance to a seeked
             // location in a beatmap doesn't churn every hit object into a DrawableHitObject. Even in a pooled scenario, the overhead
             // of this can be quite crippling.
-            entry.LifetimeEnd = entry.HitObject.GetEndTime() + timeRange.Value;
+            //
+            // However, additionally do not attempt to alter lifetime of judged entries.
+            // This is to prevent freak accidents like objects suddenly becoming alive because of this estimate assigning a later lifetime
+            // than the object itself decided it should have when it underwent judgement.
+            if (!entry.Judged)
+                entry.LifetimeEnd = entry.HitObject.GetEndTime() + timeRange.Value;
         }
 
         private void updateLayoutRecursive(DrawableHitObject hitObject, double? parentHitObjectStartTime = null)
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/PreviewTimePart.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/PreviewTimePart.cs
index 67bb1ef500..72b58bcb5f 100644
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/PreviewTimePart.cs
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/PreviewTimePart.cs
@@ -3,6 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Localisation;
 using osu.Game.Extensions;
@@ -36,6 +37,10 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
                 : base(time)
             {
                 Alpha = 0.8f;
+
+                // Display as a small circle on the middle line as to not clash with other displays.
+                RelativeSizeAxes = Axes.None;
+                Height = Width = 5;
             }
 
             [BackgroundDependencyLoader]
diff --git a/osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs b/osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs
index c01481e840..568137cce1 100644
--- a/osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs
+++ b/osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs
@@ -52,13 +52,6 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary
                         },
                     }
                 },
-                new PreviewTimePart
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.TopCentre,
-                    RelativeSizeAxes = Axes.Both,
-                    Height = 0.4f,
-                },
                 new BreakPart
                 {
                     Anchor = Anchor.Centre,
@@ -85,6 +78,12 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary
                     RelativeSizeAxes = Axes.Both,
                     Height = 0.4f
                 },
+                new PreviewTimePart
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                },
                 new MarkerPart { RelativeSizeAxes = Axes.Both },
             };
         }
diff --git a/osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs
index 88e28df8e3..8322c67def 100644
--- a/osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs
@@ -159,7 +159,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             // in case 2, we want *flooring* to occur, to prevent a possible off-by-one
             // because of the rounding snapping forward by a chunk of time significantly too high to be considered a rounding error.
             // the tolerance margin chosen here is arbitrary and can be adjusted if more cases of this are found.
-            if (Precision.DefinitelyBigger(beatIndex, fractionalBeatIndex, 0.005))
+            if (Precision.DefinitelyBigger(beatIndex, fractionalBeatIndex, 0.01))
                 beatIndex = (int)Math.Floor(fractionalBeatIndex);
 
             var colour = BindableBeatDivisor.GetColourFor(BindableBeatDivisor.GetDivisorForBeatIndex(beatIndex + placementIndex + 1, beatDivisor.Value), Colours);
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs
index 39fff169b7..bfe7fe523f 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs
@@ -151,14 +151,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </summary>
         public virtual SelectionRotationHandler CreateRotationHandler() => new SelectionRotationHandler();
 
-        /// <summary>
-        /// Handles the selected items being scaled.
-        /// </summary>
-        /// <param name="scale">The delta scale to apply, in local coordinates.</param>
-        /// <param name="anchor">The point of reference where the scale is originating from.</param>
-        /// <returns>Whether any items could be scaled.</returns>
-        public virtual bool HandleScale(Vector2 scale, Anchor anchor) => false;
-
         /// <summary>
         /// Creates the handler to use for scale operations.
         /// </summary>
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
index 011ff17b30..c149a8f73a 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
@@ -18,6 +18,7 @@ using osu.Framework.Input.Events;
 using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -90,7 +91,9 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             {
                 placementBlueprint = CreateBlueprintFor(obj.NewValue).AsNonNull();
 
-                placementBlueprint.Colour = OsuColour.Gray(0.9f);
+                // just to show the border. using the selection state doesn't seem to backfire.
+                // if it does then we'll probably want to just make `new` object above rather than rely on `CreateBlueprintFor`.
+                placementBlueprint.State = SelectionState.Selected;
 
                 // TODO: this is out of order, causing incorrect stacking height.
                 SelectionBlueprints.Add(placementBlueprint);
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
index 6c0d5af247..f60d1b023b 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
@@ -441,7 +441,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                                     double lengthOfOneRepeat = repeatHitObject.Duration / (repeatHitObject.RepeatCount + 1);
                                     int proposedCount = Math.Max(0, (int)Math.Round(proposedDuration / lengthOfOneRepeat) - 1);
 
-                                    if (proposedCount == repeatHitObject.RepeatCount || Precision.AlmostEquals(lengthOfOneRepeat, 0))
+                                    if (proposedCount == repeatHitObject.RepeatCount || Precision.AlmostEquals(lengthOfOneRepeat, 0, 1))
                                         return;
 
                                     repeatHitObject.RepeatCount = proposedCount;
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/ZoomableScrollContainer.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/ZoomableScrollContainer.cs
index 9db14ce4c4..b483f23d1d 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/ZoomableScrollContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/ZoomableScrollContainer.cs
@@ -141,7 +141,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             if (e.AltPressed)
             {
                 // zoom when holding alt.
-                AdjustZoomRelatively(e.ScrollDelta.Y, zoomedContent.ToLocalSpace(e.ScreenSpaceMousePosition).X);
+                AdjustZoomRelatively(e.ScrollDelta.Y);
                 return true;
             }
 
diff --git a/osu.Game/Screens/Edit/DiscardUnsavedChangesDialog.cs b/osu.Game/Screens/Edit/DiscardUnsavedChangesDialog.cs
new file mode 100644
index 0000000000..1867b48830
--- /dev/null
+++ b/osu.Game/Screens/Edit/DiscardUnsavedChangesDialog.cs
@@ -0,0 +1,33 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Localisation;
+using osu.Game.Overlays.Dialog;
+
+namespace osu.Game.Screens.Edit
+{
+    public partial class DiscardUnsavedChangesDialog : PopupDialog
+    {
+        public DiscardUnsavedChangesDialog(Action exit)
+        {
+            HeaderText = EditorDialogsStrings.DiscardUnsavedChangesDialogHeader;
+
+            Icon = FontAwesome.Solid.Trash;
+
+            Buttons = new PopupDialogButton[]
+            {
+                new PopupDialogDangerousButton
+                {
+                    Text = EditorDialogsStrings.ForgetAllChanges,
+                    Action = exit
+                },
+                new PopupDialogCancelButton
+                {
+                    Text = EditorDialogsStrings.ContinueEditing,
+                },
+            };
+        }
+    }
+}
diff --git a/osu.Game/Screens/Edit/Editor.cs b/osu.Game/Screens/Edit/Editor.cs
index 219e14861f..f56380a34d 100644
--- a/osu.Game/Screens/Edit/Editor.cs
+++ b/osu.Game/Screens/Edit/Editor.cs
@@ -164,6 +164,7 @@ namespace osu.Game.Screens.Edit
         private bool switchingDifficulty;
 
         private string lastSavedHash;
+        private EditorMenuItem discardChangesMenuItem;
 
         private ScreenContainer screenContainer;
 
@@ -607,6 +608,8 @@ namespace osu.Game.Screens.Edit
         {
             base.Update();
             clock.ProcessFrame();
+
+            discardChangesMenuItem.Action.Disabled = !HasUnsavedChanges;
         }
 
         public bool OnPressed(KeyBindingPressEvent<PlatformAction> e)
@@ -821,6 +824,10 @@ namespace osu.Game.Screens.Edit
                 case GlobalAction.EditorTestGameplay:
                     bottomBar.TestGameplayButton.TriggerClick();
                     return true;
+
+                case GlobalAction.EditorDiscardUnsavedChanges:
+                    DiscardUnsavedChanges();
+                    return true;
             }
 
             return false;
@@ -1008,6 +1015,20 @@ namespace osu.Game.Screens.Edit
 
         protected void Redo() => changeHandler?.RestoreState(1);
 
+        protected void DiscardUnsavedChanges()
+        {
+            if (!HasUnsavedChanges)
+                return;
+
+            // we're not doing this via `changeHandler` because `changeHandler` has limited number of undo actions
+            // and therefore there's no guarantee that it even *has* the beatmap's last saved state in its history still.
+            dialogOverlay.Push(new DiscardUnsavedChangesDialog(() =>
+            {
+                updateLastSavedHash(); // without this a second dialog will show (the standard "save unsaved changes" one that shows on exit).
+                SwitchToDifficulty(editorBeatmap.BeatmapInfo);
+            }));
+        }
+
         protected void SetPreviewPointToCurrentTime()
         {
             editorBeatmap.PreviewTime.Value = (int)clock.CurrentTime;
@@ -1248,6 +1269,11 @@ namespace osu.Game.Screens.Edit
             saveRelatedMenuItems.Add(save);
             yield return save;
 
+            yield return discardChangesMenuItem = new EditorMenuItem(GlobalActionKeyBindingStrings.EditorDiscardUnsavedChanges, MenuItemType.Destructive, DiscardUnsavedChanges)
+            {
+                Hotkey = new Hotkey(GlobalAction.EditorDiscardUnsavedChanges)
+            };
+
             if (RuntimeInfo.OS != RuntimeInfo.Platform.Android)
             {
                 var export = createExportMenu();
@@ -1510,11 +1536,11 @@ namespace osu.Game.Screens.Edit
             loader?.CancelPendingDifficultySwitch();
         }
 
-        public Task<bool> Reload()
+        public Task<bool> SaveAndReload()
         {
             var tcs = new TaskCompletionSource<bool>();
 
-            dialogOverlay.Push(new ReloadEditorDialog(
+            dialogOverlay.Push(new SaveAndReloadEditorDialog(
                 reload: () =>
                 {
                     bool reloadedSuccessfully = attemptMutationOperation(() =>
diff --git a/osu.Game/Screens/Edit/ReloadEditorDialog.cs b/osu.Game/Screens/Edit/SaveAndReloadEditorDialog.cs
similarity index 86%
rename from osu.Game/Screens/Edit/ReloadEditorDialog.cs
rename to osu.Game/Screens/Edit/SaveAndReloadEditorDialog.cs
index 72a9f81347..b73c7cfff8 100644
--- a/osu.Game/Screens/Edit/ReloadEditorDialog.cs
+++ b/osu.Game/Screens/Edit/SaveAndReloadEditorDialog.cs
@@ -8,9 +8,9 @@ using osu.Game.Localisation;
 
 namespace osu.Game.Screens.Edit
 {
-    public partial class ReloadEditorDialog : PopupDialog
+    public partial class SaveAndReloadEditorDialog : PopupDialog
     {
-        public ReloadEditorDialog(Action reload, Action cancel)
+        public SaveAndReloadEditorDialog(Action reload, Action cancel)
         {
             HeaderText = EditorDialogsStrings.EditorReloadDialogHeader;
 
diff --git a/osu.Game/Screens/Edit/Setup/ColoursSection.cs b/osu.Game/Screens/Edit/Setup/ColoursSection.cs
index 8de7f86523..865fe05c54 100644
--- a/osu.Game/Screens/Edit/Setup/ColoursSection.cs
+++ b/osu.Game/Screens/Edit/Setup/ColoursSection.cs
@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
+using osu.Game.Beatmaps.Formats;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
 using osu.Game.Skinning;
@@ -54,6 +55,8 @@ namespace osu.Game.Screens.Edit.Setup
                     Beatmap.BeatmapSkin.ComboColours.Clear();
                     Beatmap.BeatmapSkin.ComboColours.AddRange(comboColours.Colours);
 
+                    updateAddButtonVisibility();
+
                     syncingColours = false;
                 }
             });
@@ -68,8 +71,14 @@ namespace osu.Game.Screens.Edit.Setup
                 comboColours.Colours.Clear();
                 comboColours.Colours.AddRange(Beatmap.BeatmapSkin?.ComboColours);
 
+                updateAddButtonVisibility();
+
                 syncingColours = false;
             });
+
+            updateAddButtonVisibility();
+
+            void updateAddButtonVisibility() => comboColours.CanAdd.Value = comboColours.Colours.Count < LegacyBeatmapDecoder.MAX_COMBO_COLOUR_COUNT;
         }
     }
 }
diff --git a/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs b/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs
index 66139bacec..2ea710d3ab 100644
--- a/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs
+++ b/osu.Game/Screens/Edit/Submission/BeatmapSubmissionScreen.cs
@@ -285,7 +285,7 @@ namespace osu.Game.Screens.Edit.Submission
                     continue;
                 }
 
-                if (localHash != onlineHash)
+                if (!localHash.Equals(onlineHash, StringComparison.OrdinalIgnoreCase))
                     filesToUpdate.Add(filename);
             }
 
@@ -304,7 +304,7 @@ namespace osu.Game.Screens.Edit.Submission
                 Logger.Log($"Beatmap submission failed on upload: {ex}");
                 allowExit();
             };
-            patchRequest.Progressed += (current, total) => uploadStep.SetInProgress((float)current / total);
+            patchRequest.Progressed += (current, total) => uploadStep.SetInProgress(total > 0 ? (float)current / total : null);
 
             api.Queue(patchRequest);
             uploadStep.SetInProgress();
diff --git a/osu.Game/Screens/Menu/KiaiMenuFountains.cs b/osu.Game/Screens/Menu/KiaiMenuFountains.cs
index 7978e9fa91..b57012eaf7 100644
--- a/osu.Game/Screens/Menu/KiaiMenuFountains.cs
+++ b/osu.Game/Screens/Menu/KiaiMenuFountains.cs
@@ -4,8 +4,11 @@
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Platform;
 using osu.Framework.Utils;
+using osu.Game.Audio;
 using osu.Game.Graphics.Containers;
+using osu.Game.Skinning;
 
 namespace osu.Game.Screens.Menu
 {
@@ -14,12 +17,17 @@ namespace osu.Game.Screens.Menu
         private StarFountain leftFountain = null!;
         private StarFountain rightFountain = null!;
 
+        [Resolved]
+        private GameHost host { get; set; } = null!;
+
+        private SkinnableSound? sample;
+
         [BackgroundDependencyLoader]
         private void load()
         {
             RelativeSizeAxes = Axes.Both;
 
-            Children = new[]
+            Children = new Drawable[]
             {
                 leftFountain = new StarFountain
                 {
@@ -33,6 +41,7 @@ namespace osu.Game.Screens.Menu
                     Origin = Anchor.BottomRight,
                     X = -250,
                 },
+                sample = new SkinnableSound(new SampleInfo("Gameplay/fountain-shoot"))
             };
         }
 
@@ -73,6 +82,10 @@ namespace osu.Game.Screens.Menu
                     rightFountain.Shoot(1);
                     break;
             }
+
+            // Don't play SFX when game is in background as it can be a bit noisy.
+            if (host.IsActive.Value)
+                sample?.Play();
         }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Components/ListingPollingComponent.cs b/osu.Game/Screens/OnlinePlay/Components/ListingPollingComponent.cs
deleted file mode 100644
index 21452727b8..0000000000
--- a/osu.Game/Screens/OnlinePlay/Components/ListingPollingComponent.cs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Linq;
-using System.Threading.Tasks;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Game.Online.Rooms;
-using osu.Game.Screens.OnlinePlay.Lounge.Components;
-
-namespace osu.Game.Screens.OnlinePlay.Components
-{
-    /// <summary>
-    /// A <see cref="RoomPollingComponent"/> that polls for the lounge listing.
-    /// </summary>
-    public partial class ListingPollingComponent : RoomPollingComponent
-    {
-        public IBindable<bool> InitialRoomsReceived => initialRoomsReceived;
-        private readonly Bindable<bool> initialRoomsReceived = new Bindable<bool>();
-
-        public readonly Bindable<FilterCriteria?> Filter = new Bindable<FilterCriteria?>();
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Filter.BindValueChanged(_ =>
-            {
-                RoomManager.ClearRooms();
-                initialRoomsReceived.Value = false;
-
-                if (IsLoaded)
-                    PollImmediately();
-            });
-        }
-
-        private GetRoomsRequest? lastPollRequest;
-
-        protected override Task Poll()
-        {
-            if (!API.IsLoggedIn)
-                return base.Poll();
-
-            if (Filter.Value == null)
-                return base.Poll();
-
-            var tcs = new TaskCompletionSource<bool>();
-
-            lastPollRequest?.Cancel();
-
-            var req = new GetRoomsRequest(Filter.Value);
-
-            req.Success += result =>
-            {
-                result = result.Where(r => r.Category != RoomCategory.DailyChallenge).ToList();
-
-                foreach (var existing in RoomManager.Rooms.ToArray())
-                {
-                    if (result.All(r => r.RoomID != existing.RoomID))
-                        RoomManager.RemoveRoom(existing);
-                }
-
-                foreach (var incoming in result)
-                    RoomManager.AddOrUpdateRoom(incoming);
-
-                initialRoomsReceived.Value = true;
-                tcs.SetResult(true);
-            };
-
-            req.Failure += _ => tcs.SetResult(false);
-
-            API.Queue(req);
-
-            lastPollRequest = req;
-            return tcs.Task;
-        }
-    }
-}
diff --git a/osu.Game/Screens/OnlinePlay/Components/ReadyButton.cs b/osu.Game/Screens/OnlinePlay/Components/ReadyButton.cs
index 2e669fd1b2..56e2719e9c 100644
--- a/osu.Game/Screens/OnlinePlay/Components/ReadyButton.cs
+++ b/osu.Game/Screens/OnlinePlay/Components/ReadyButton.cs
@@ -3,7 +3,6 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Graphics.Cursor;
 using osu.Framework.Localisation;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Online;
@@ -11,7 +10,7 @@ using osu.Game.Online.Rooms;
 
 namespace osu.Game.Screens.OnlinePlay.Components
 {
-    public abstract partial class ReadyButton : RoundedButton, IHasTooltip
+    public abstract partial class ReadyButton : RoundedButton
     {
         public new readonly BindableBool Enabled = new BindableBool();
 
@@ -29,7 +28,7 @@ namespace osu.Game.Screens.OnlinePlay.Components
         private void updateState() =>
             base.Enabled.Value = availability.Value.State == DownloadState.LocallyAvailable && Enabled.Value;
 
-        public virtual LocalisableString TooltipText
+        public override LocalisableString TooltipText
         {
             get
             {
diff --git a/osu.Game/Screens/OnlinePlay/Components/RoomManager.cs b/osu.Game/Screens/OnlinePlay/Components/RoomManager.cs
deleted file mode 100644
index 73f980f0a3..0000000000
--- a/osu.Game/Screens/OnlinePlay/Components/RoomManager.cs
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Framework.Development;
-using osu.Framework.Graphics;
-using osu.Framework.Logging;
-using osu.Game.Online.API;
-using osu.Game.Online.Rooms;
-
-namespace osu.Game.Screens.OnlinePlay.Components
-{
-    public partial class RoomManager : Component, IRoomManager
-    {
-        public event Action? RoomsUpdated;
-
-        private readonly BindableList<Room> rooms = new BindableList<Room>();
-
-        public IBindableList<Room> Rooms => rooms;
-
-        protected IBindable<Room?> JoinedRoom => joinedRoom;
-        private readonly Bindable<Room?> joinedRoom = new Bindable<Room?>();
-
-        [Resolved]
-        private IAPIProvider api { get; set; } = null!;
-
-        public RoomManager()
-        {
-            RelativeSizeAxes = Axes.Both;
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            PartRoom();
-        }
-
-        public virtual void CreateRoom(Room room, Action<Room>? onSuccess = null, Action<string>? onError = null)
-        {
-            room.Host = api.LocalUser.Value;
-
-            var req = new CreateRoomRequest(room);
-
-            req.Success += result =>
-            {
-                joinedRoom.Value = room;
-
-                AddOrUpdateRoom(result);
-                room.CopyFrom(result); // Also copy back to the source model, since this is likely to have been stored elsewhere.
-
-                // The server may not contain all properties (such as password), so invoke success with the given room.
-                onSuccess?.Invoke(room);
-            };
-
-            req.Failure += exception =>
-            {
-                onError?.Invoke(req.Response?.Error ?? exception.Message);
-            };
-
-            api.Queue(req);
-        }
-
-        private JoinRoomRequest? currentJoinRoomRequest;
-
-        public virtual void JoinRoom(Room room, string? password = null, Action<Room>? onSuccess = null, Action<string>? onError = null)
-        {
-            currentJoinRoomRequest?.Cancel();
-            currentJoinRoomRequest = new JoinRoomRequest(room, password);
-
-            currentJoinRoomRequest.Success += result =>
-            {
-                joinedRoom.Value = room;
-
-                AddOrUpdateRoom(result);
-                room.CopyFrom(result); // Also copy back to the source model, since this is likely to have been stored elsewhere.
-
-                onSuccess?.Invoke(room);
-            };
-
-            currentJoinRoomRequest.Failure += exception =>
-            {
-                if (exception is OperationCanceledException)
-                    return;
-
-                onError?.Invoke(exception.Message);
-            };
-
-            api.Queue(currentJoinRoomRequest);
-        }
-
-        public virtual void PartRoom()
-        {
-            currentJoinRoomRequest?.Cancel();
-
-            if (joinedRoom.Value == null)
-                return;
-
-            if (api.State.Value == APIState.Online)
-                api.Queue(new PartRoomRequest(joinedRoom.Value));
-
-            joinedRoom.Value = null;
-        }
-
-        private readonly HashSet<long> ignoredRooms = new HashSet<long>();
-
-        public void AddOrUpdateRoom(Room room)
-        {
-            Debug.Assert(ThreadSafety.IsUpdateThread);
-            Debug.Assert(room.RoomID != null);
-
-            if (ignoredRooms.Contains(room.RoomID.Value))
-                return;
-
-            try
-            {
-                var existing = rooms.FirstOrDefault(e => e.RoomID == room.RoomID);
-                if (existing == null)
-                    rooms.Add(room);
-                else
-                    existing.CopyFrom(room);
-            }
-            catch (Exception ex)
-            {
-                Logger.Error(ex, $"Failed to update room: {room.Name}.");
-
-                ignoredRooms.Add(room.RoomID.Value);
-                rooms.Remove(room);
-            }
-
-            notifyRoomsUpdated();
-        }
-
-        public void RemoveRoom(Room room)
-        {
-            Debug.Assert(ThreadSafety.IsUpdateThread);
-
-            rooms.Remove(room);
-            notifyRoomsUpdated();
-        }
-
-        public void ClearRooms()
-        {
-            Debug.Assert(ThreadSafety.IsUpdateThread);
-
-            rooms.Clear();
-            notifyRoomsUpdated();
-        }
-
-        private void notifyRoomsUpdated()
-        {
-            Scheduler.AddOnce(invokeRoomsUpdated);
-
-            void invokeRoomsUpdated() => RoomsUpdated?.Invoke();
-        }
-    }
-}
diff --git a/osu.Game/Screens/OnlinePlay/Components/RoomPollingComponent.cs b/osu.Game/Screens/OnlinePlay/Components/RoomPollingComponent.cs
deleted file mode 100644
index 0ba7f20f1c..0000000000
--- a/osu.Game/Screens/OnlinePlay/Components/RoomPollingComponent.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Game.Online;
-using osu.Game.Online.API;
-
-namespace osu.Game.Screens.OnlinePlay.Components
-{
-    public abstract partial class RoomPollingComponent : PollingComponent
-    {
-        [Resolved]
-        protected IAPIProvider API { get; private set; } = null!;
-
-        [Resolved]
-        protected IRoomManager RoomManager { get; private set; } = null!;
-    }
-}
diff --git a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs
index 249cad8ca3..6de11ec34c 100644
--- a/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs
+++ b/osu.Game/Screens/OnlinePlay/DailyChallenge/DailyChallenge.cs
@@ -34,7 +34,6 @@ using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.DailyChallenge.Events;
 using osu.Game.Screens.OnlinePlay.Match;
 using osu.Game.Screens.OnlinePlay.Match.Components;
@@ -71,9 +70,6 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
         [Cached]
         private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Plum);
 
-        [Cached(Type = typeof(IRoomManager))]
-        private RoomManager roomManager { get; set; }
-
         [Cached]
         private readonly OnlinePlayBeatmapAvailabilityTracker beatmapAvailabilityTracker = new OnlinePlayBeatmapAvailabilityTracker();
 
@@ -115,7 +111,6 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
         {
             this.room = room;
             playlistItem = room.Playlist.Single();
-            roomManager = new RoomManager();
             Padding = new MarginPadding { Horizontal = -HORIZONTAL_OVERFLOW_PADDING };
         }
 
@@ -131,7 +126,6 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
                 {
-                    roomManager,
                     beatmapAvailabilityTracker,
                     new ScreenStack(new RoomBackgroundScreen(playlistItem))
                     {
@@ -426,7 +420,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
             base.OnEntering(e);
 
             waves.Show();
-            roomManager.JoinRoom(room);
+            API.Queue(new JoinRoomRequest(room, null));
             startLoopingTrack(this, musicController);
 
             metadataClient.BeginWatchingMultiplayerRoom(room.RoomID!.Value).ContinueWith(t =>
@@ -480,7 +474,7 @@ namespace osu.Game.Screens.OnlinePlay.DailyChallenge
             previewTrackManager.StopAnyPlaying(this);
             this.Delay(WaveContainer.DISAPPEAR_DURATION).FadeOut();
 
-            roomManager.PartRoom();
+            API.Queue(new PartRoomRequest(room));
             metadataClient.EndWatchingMultiplayerRoom(room.RoomID!.Value).FireAndForget();
 
             return base.OnExiting(e);
diff --git a/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs b/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs
index 207e0bdf55..c9d8365852 100644
--- a/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs
+++ b/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs
@@ -204,7 +204,7 @@ namespace osu.Game.Screens.OnlinePlay
                 ScrollContainer.ScrollIntoView(drawableItem);
         }
 
-        #region Key selection logic (shared with BeatmapCarousel and RoomsContainer)
+        #region Key selection logic (shared with BeatmapCarousel and RoomListing)
 
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
diff --git a/osu.Game/Screens/OnlinePlay/IRoomManager.cs b/osu.Game/Screens/OnlinePlay/IRoomManager.cs
deleted file mode 100644
index ed4fb7b15e..0000000000
--- a/osu.Game/Screens/OnlinePlay/IRoomManager.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Framework.Allocation;
-using osu.Framework.Bindables;
-using osu.Game.Online.Rooms;
-
-namespace osu.Game.Screens.OnlinePlay
-{
-    [Cached(typeof(IRoomManager))]
-    public interface IRoomManager
-    {
-        /// <summary>
-        /// Invoked when the <see cref="Room"/>s have been updated.
-        /// </summary>
-        event Action RoomsUpdated;
-
-        /// <summary>
-        /// All the active <see cref="Room"/>s.
-        /// </summary>
-        IBindableList<Room> Rooms { get; }
-
-        /// <summary>
-        /// Adds a <see cref="Room"/> to this <see cref="IRoomManager"/>.
-        /// If already existing, the local room will be updated with the given one.
-        /// </summary>
-        /// <param name="room">The incoming <see cref="Room"/>.</param>
-        void AddOrUpdateRoom(Room room);
-
-        /// <summary>
-        /// Removes a <see cref="Room"/> from this <see cref="IRoomManager"/>.
-        /// </summary>
-        /// <param name="room">The <see cref="Room"/> to remove.</param>
-        void RemoveRoom(Room room);
-
-        /// <summary>
-        /// Removes all <see cref="Room"/>s from this <see cref="IRoomManager"/>.
-        /// </summary>
-        void ClearRooms();
-
-        /// <summary>
-        /// Creates a new <see cref="Room"/>.
-        /// </summary>
-        /// <param name="room">The <see cref="Room"/> to create.</param>
-        /// <param name="onSuccess">An action to be invoked if the creation succeeds.</param>
-        /// <param name="onError">An action to be invoked if an error occurred.</param>
-        void CreateRoom(Room room, Action<Room>? onSuccess = null, Action<string>? onError = null);
-
-        /// <summary>
-        /// Joins a <see cref="Room"/>.
-        /// </summary>
-        /// <param name="room">The <see cref="Room"/> to join. <see cref="Room.RoomID"/> must be populated.</param>
-        /// <param name="password">An optional password to use for the join operation.</param>
-        /// <param name="onSuccess"></param>
-        /// <param name="onError"></param>
-        void JoinRoom(Room room, string? password = null, Action<Room>? onSuccess = null, Action<string>? onError = null);
-
-        /// <summary>
-        /// Parts the currently-joined <see cref="Room"/>.
-        /// </summary>
-        void PartRoom();
-    }
-}
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
similarity index 68%
rename from osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs
rename to osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
index 6eda993f94..0276601656 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomListing.cs
@@ -7,14 +7,13 @@ using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
-using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
-using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Input.Bindings;
 using osu.Game.Online.Rooms;
@@ -22,51 +21,71 @@ using osuTK;
 
 namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 {
-    public partial class RoomsContainer : CompositeDrawable, IKeyBindingHandler<GlobalAction>
+    public partial class RoomListing : CompositeDrawable, IKeyBindingHandler<GlobalAction>
     {
-        public readonly Bindable<Room?> SelectedRoom = new Bindable<Room?>();
+        /// <summary>
+        /// Rooms which should be displayed. Should be managed externally.
+        /// </summary>
+        public readonly BindableList<Room> Rooms = new BindableList<Room>();
+
+        /// <summary>
+        /// The current filter criteria. Should be managed externally.
+        /// </summary>
         public readonly Bindable<FilterCriteria?> Filter = new Bindable<FilterCriteria?>();
 
-        public IReadOnlyList<DrawableRoom> Rooms => roomFlow.FlowingChildren.Cast<DrawableRoom>().ToArray();
+        /// <summary>
+        /// The currently user-selected room.
+        /// </summary>
+        public IBindable<Room?> SelectedRoom => selectedRoom;
 
-        private readonly IBindableList<Room> rooms = new BindableList<Room>();
+        private readonly Bindable<Room?> selectedRoom = new Bindable<Room?>();
+
+        public IReadOnlyList<DrawableRoom> DrawableRooms => roomFlow.FlowingChildren.Cast<DrawableRoom>().ToArray();
+
+        private readonly ScrollContainer<Drawable> scroll;
         private readonly FillFlowContainer<DrawableLoungeRoom> roomFlow;
 
-        [Resolved]
-        private IRoomManager roomManager { get; set; } = null!;
+        private const float display_scale = 0.8f;
 
         // handle deselection
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
-        public RoomsContainer()
+        public RoomListing()
         {
-            RelativeSizeAxes = Axes.X;
-            AutoSizeAxes = Axes.Y;
-
-            // account for the fact we are in a scroll container and want a bit of spacing from the scroll bar.
-            Padding = new MarginPadding { Right = 5 };
-
-            InternalChild = new OsuContextMenuContainer
+            InternalChild = scroll = new Scroll
             {
-                RelativeSizeAxes = Axes.X,
-                AutoSizeAxes = Axes.Y,
-                Child = roomFlow = new FillFlowContainer<DrawableLoungeRoom>
+                Masking = false,
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre,
+                Width = display_scale,
+                ScrollbarOverlapsContent = false,
+                Padding = new MarginPadding { Right = 5 },
+                Child = new OsuContextMenuContainer
                 {
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
-                    Direction = FillDirection.Vertical,
-                    Spacing = new Vector2(10),
+                    Child = roomFlow = new FillFlowContainer<DrawableLoungeRoom>
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(5),
+                        Margin = new MarginPadding { Vertical = 10 },
+                    }
                 }
             };
         }
 
+        private partial class Scroll : OsuScrollContainer
+        {
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
+        }
+
         protected override void LoadComplete()
         {
-            rooms.CollectionChanged += roomsChanged;
-            roomManager.RoomsUpdated += updateSorting;
-
-            rooms.BindTo(roomManager.Rooms);
-
+            SelectedRoom.BindValueChanged(onSelectedRoomChanged, true);
+            Rooms.BindCollectionChanged(roomsChanged, true);
             Filter.BindValueChanged(criteria => applyFilterCriteria(criteria.NewValue), true);
         }
 
@@ -128,6 +147,14 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             }
         }
 
+        private void onSelectedRoomChanged(ValueChangedEvent<Room?> room)
+        {
+            // scroll selected room into view on selection.
+            var drawable = DrawableRooms.FirstOrDefault(r => r.Room == room.NewValue);
+            if (drawable != null)
+                scroll.ScrollIntoView(drawable);
+        }
+
         private void roomsChanged(object? sender, NotifyCollectionChangedEventArgs args)
         {
             switch (args.Action)
@@ -155,7 +182,21 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         private void addRooms(IEnumerable<Room> rooms)
         {
             foreach (var room in rooms)
-                roomFlow.Add(new DrawableLoungeRoom(room) { SelectedRoom = SelectedRoom });
+            {
+                var drawableRoom = new DrawableLoungeRoom(room)
+                {
+                    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));
+            }
 
             applyFilterCriteria(Filter.Value);
         }
@@ -168,7 +209,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
                 // selection may have a lease due to being in a sub screen.
                 if (SelectedRoom.Value == r && !SelectedRoom.Disabled)
-                    SelectedRoom.Value = null;
+                    selectedRoom.Value = null;
             }
         }
 
@@ -178,24 +219,13 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
             // selection may have a lease due to being in a sub screen.
             if (!SelectedRoom.Disabled)
-                SelectedRoom.Value = null;
-        }
-
-        private void updateSorting()
-        {
-            foreach (var room in roomFlow)
-            {
-                roomFlow.SetLayoutPosition(room, room.Room.Category > RoomCategory.Normal
-                    // Always show spotlight playlists at the top of the listing.
-                    ? float.MinValue
-                    : -(room.Room.RoomID ?? 0));
-            }
+                selectedRoom.Value = null;
         }
 
         protected override bool OnClick(ClickEvent e)
         {
             if (!SelectedRoom.Disabled)
-                SelectedRoom.Value = null;
+                selectedRoom.Value = null;
             return base.OnClick(e);
         }
 
@@ -226,7 +256,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             if (SelectedRoom.Disabled)
                 return;
 
-            var visibleRooms = Rooms.AsEnumerable().Where(r => r.IsPresent);
+            var visibleRooms = DrawableRooms.AsEnumerable().Where(r => r.IsPresent);
 
             Room? room;
 
@@ -242,17 +272,9 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
 
             // we already have a valid selection only change selection if we still have a room to switch to.
             if (room != null)
-                SelectedRoom.Value = room;
+                selectedRoom.Value = room;
         }
 
         #endregion
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-
-            if (roomManager.IsNotNull())
-                roomManager.RoomsUpdated -= updateSorting;
-        }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs b/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs
index 1cabb22e30..d369722e5f 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/DrawableLoungeRoom.cs
@@ -24,7 +24,6 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Input.Bindings;
 using osu.Game.Online.API;
-using osu.Game.Online.API.Requests;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Screens.OnlinePlay.Components;
@@ -51,7 +50,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
         }
 
         [Resolved(canBeNull: true)]
-        private LoungeSubScreen? lounge { get; set; }
+        private IOnlinePlayLounge? lounge { get; set; }
 
         [Resolved]
         private IDialogOverlay? dialogOverlay { get; set; }
@@ -170,12 +169,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
                 {
                     items.Add(new OsuMenuItem("Close playlist", MenuItemType.Destructive, () =>
                     {
-                        dialogOverlay?.Push(new ClosePlaylistDialog(Room, () =>
-                        {
-                            var request = new ClosePlaylistRequest(Room.RoomID!.Value);
-                            request.Success += () => lounge?.RefreshRooms();
-                            api.Queue(request);
-                        }));
+                        dialogOverlay?.Push(new ClosePlaylistDialog(Room, () => lounge?.Close(Room)));
                     }));
                 }
 
@@ -238,7 +232,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
             private readonly Room room;
 
             [Resolved(canBeNull: true)]
-            private LoungeSubScreen? lounge { get; set; }
+            private IOnlinePlayLounge? lounge { get; set; }
 
             public override bool HandleNonPositionalInput => true;
 
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/IOnlinePlayLounge.cs b/osu.Game/Screens/OnlinePlay/Lounge/IOnlinePlayLounge.cs
new file mode 100644
index 0000000000..73ab84af13
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Lounge/IOnlinePlayLounge.cs
@@ -0,0 +1,32 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Online.Rooms;
+
+namespace osu.Game.Screens.OnlinePlay.Lounge
+{
+    public interface IOnlinePlayLounge
+    {
+        /// <summary>
+        /// Attempts to join the given room.
+        /// </summary>
+        /// <param name="room">The room to join.</param>
+        /// <param name="password">The password.</param>
+        /// <param name="onSuccess">A delegate to invoke if the user joined the room.</param>
+        /// <param name="onFailure">A delegate to invoke if the user is not able join the room.</param>
+        void Join(Room room, string? password, Action<Room>? onSuccess = null, Action<string>? onFailure = null);
+
+        /// <summary>
+        /// Copies the given room and opens it as a fresh (not-yet-created) one.
+        /// </summary>
+        /// <param name="room">The room to copy.</param>
+        void OpenCopy(Room room);
+
+        /// <summary>
+        /// Closes the given room.
+        /// </summary>
+        /// <param name="room">The room to close.</param>
+        void Close(Room room);
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/LoungeListingPoller.cs b/osu.Game/Screens/OnlinePlay/Lounge/LoungeListingPoller.cs
new file mode 100644
index 0000000000..d92ae7eb6e
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Lounge/LoungeListingPoller.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 System;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Game.Online;
+using osu.Game.Online.API;
+using osu.Game.Online.Rooms;
+using osu.Game.Screens.OnlinePlay.Lounge.Components;
+
+namespace osu.Game.Screens.OnlinePlay.Lounge
+{
+    /// <summary>
+    /// Polls for rooms for the main lounge listing.
+    /// </summary>
+    public partial class LoungeListingPoller : PollingComponent
+    {
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        public required Action<Room[]> RoomsReceived { get; init; }
+        public readonly IBindable<FilterCriteria?> Filter = new Bindable<FilterCriteria?>();
+
+        private GetRoomsRequest? lastPollRequest;
+
+        protected override Task Poll()
+        {
+            if (!api.IsLoggedIn)
+                return base.Poll();
+
+            if (Filter.Value == null)
+                return base.Poll();
+
+            lastPollRequest?.Cancel();
+
+            var tcs = new TaskCompletionSource<bool>();
+            var req = new GetRoomsRequest(Filter.Value);
+
+            req.Success += result =>
+            {
+                RoomsReceived(result.Where(r => r.Category != RoomCategory.DailyChallenge).ToArray());
+                tcs.SetResult(true);
+            };
+
+            req.Failure += _ => tcs.SetResult(false);
+
+            api.Queue(req);
+
+            lastPollRequest = req;
+
+            return tcs.Task;
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
index f00cf7427c..c84f49fef6 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
@@ -8,38 +8,41 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Events;
 using osu.Framework.Logging;
 using osu.Framework.Screens;
 using osu.Framework.Threading;
 using osu.Game.Configuration;
-using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Input;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Screens.OnlinePlay.Match;
 using osu.Game.Users;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Screens.OnlinePlay.Lounge
 {
     [Cached]
-    public abstract partial class LoungeSubScreen : OnlinePlaySubScreen
+    [Cached(typeof(IOnlinePlayLounge))]
+    public abstract partial class LoungeSubScreen : OnlinePlaySubScreen, IOnlinePlayLounge
     {
         public override string Title => "Lounge";
 
         protected override BackgroundScreen CreateBackground() => new LoungeBackgroundScreen
         {
-            SelectedRoom = { BindTarget = SelectedRoom }
+            SelectedRoom = { BindTarget = roomListing.SelectedRoom }
         };
 
         protected override UserActivity InitialActivity => new UserActivity.SearchingForLobby();
@@ -51,10 +54,6 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
             AutoSizeAxes = Axes.Both
         };
 
-        protected ListingPollingComponent ListingPollingComponent { get; private set; } = null!;
-
-        protected readonly Bindable<Room?> SelectedRoom = new Bindable<Room?>();
-
         [Resolved]
         private MusicController music { get; set; } = null!;
 
@@ -73,15 +72,16 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
         [Resolved]
         protected OsuConfigManager Config { get; private set; } = null!;
 
-        private IDisposable? joiningRoomOperation { get; set; }
-        private LeasedBindable<Room?>? selectionLease;
+        private IDisposable? joiningRoomOperation;
 
         private readonly Bindable<FilterCriteria?> filter = new Bindable<FilterCriteria?>();
+        private readonly Bindable<bool> hasListingResults = new Bindable<bool>();
         private readonly IBindable<bool> operationInProgress = new Bindable<bool>();
         private readonly IBindable<bool> isIdle = new BindableBool();
+        private RoomListing roomListing = null!;
+        private LoungeListingPoller listingPoller = null!;
         private PopoverContainer popoverContainer = null!;
         private LoadingLayer loadingLayer = null!;
-        private RoomsContainer roomsContainer = null!;
         private SearchTextBox searchTextBox = null!;
 
         protected Dropdown<RoomModeFilter> StatusDropdown { get; private set; } = null!;
@@ -89,16 +89,22 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
         [BackgroundDependencyLoader(true)]
         private void load()
         {
+            Masking = true;
+
             const float controls_area_height = 25f;
 
             if (idleTracker != null)
                 isIdle.BindTo(idleTracker.IsIdle);
 
-            OsuScrollContainer scrollContainer;
+            Color4 bg = Color4Extensions.FromHex("#070405");
 
             InternalChildren = new Drawable[]
             {
-                ListingPollingComponent = CreatePollingComponent().With(c => c.Filter.BindTarget = filter),
+                listingPoller = new LoungeListingPoller
+                {
+                    RoomsReceived = onListingReceived,
+                    Filter = { BindTarget = filter }
+                },
                 popoverContainer = new PopoverContainer
                 {
                     Name = @"Rooms area",
@@ -108,78 +114,89 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
                         Horizontal = WaveOverlayContainer.WIDTH_PADDING,
                         Top = Header.HEIGHT + controls_area_height + 20,
                     },
-                    Child = scrollContainer = new OsuScrollContainer
+                    Child = roomListing = new RoomListing
                     {
                         RelativeSizeAxes = Axes.Both,
-                        ScrollbarOverlapsContent = false,
-                        Child = roomsContainer = new RoomsContainer
-                        {
-                            Filter = { BindTarget = filter },
-                            SelectedRoom = { BindTarget = SelectedRoom }
-                        }
-                    },
+                        Filter = { BindTarget = filter },
+                    }
                 },
                 loadingLayer = new LoadingLayer(true),
-                new FillFlowContainer
+                new Container
                 {
-                    Name = @"Header area flow",
+                    Name = "Header area",
                     RelativeSizeAxes = Axes.X,
                     AutoSizeAxes = Axes.Y,
-                    Padding = new MarginPadding { Horizontal = WaveOverlayContainer.WIDTH_PADDING },
-                    Direction = FillDirection.Vertical,
                     Children = new Drawable[]
                     {
-                        new Container
+                        new Box
                         {
-                            RelativeSizeAxes = Axes.X,
-                            Height = Header.HEIGHT,
-                            Child = searchTextBox = new BasicSearchTextBox
-                            {
-                                Anchor = Anchor.CentreRight,
-                                Origin = Anchor.CentreRight,
-                                RelativeSizeAxes = Axes.X,
-                                Width = 0.6f,
-                            },
+                            Colour = ColourInfo.GradientVertical(bg, bg.Opacity(0.75f)),
+                            RelativeSizeAxes = Axes.Both,
+                            Height = 0.8f,
                         },
-                        new Container
+                        new Box
                         {
+                            Colour = ColourInfo.GradientVertical(bg.Opacity(0.75f), bg.Opacity(0)),
+                            RelativeSizeAxes = Axes.Both,
+                            RelativePositionAxes = Axes.Both,
+                            Y = 0.8f,
+                            // Intentionally taller than the header for a more gradual fade
+                            Height = 0.5f,
+                        },
+                        new FillFlowContainer
+                        {
+                            Name = @"Header area flow",
                             RelativeSizeAxes = Axes.X,
-                            Height = controls_area_height,
+                            AutoSizeAxes = Axes.Y,
+                            Padding = new MarginPadding { Horizontal = WaveOverlayContainer.WIDTH_PADDING },
+                            Direction = FillDirection.Vertical,
                             Children = new Drawable[]
                             {
-                                Buttons.WithChild(CreateNewRoomButton().With(d =>
+                                new Container
                                 {
-                                    d.Anchor = Anchor.BottomLeft;
-                                    d.Origin = Anchor.BottomLeft;
-                                    d.Size = new Vector2(150, 37.5f);
-                                    d.Action = () => Open();
-                                })),
-                                new FillFlowContainer
-                                {
-                                    Anchor = Anchor.TopRight,
-                                    Origin = Anchor.TopRight,
-                                    AutoSizeAxes = Axes.Both,
-                                    Direction = FillDirection.Horizontal,
-                                    Spacing = new Vector2(10),
-                                    ChildrenEnumerable = CreateFilterControls().Select(f => f.With(d =>
+                                    RelativeSizeAxes = Axes.X,
+                                    Height = Header.HEIGHT,
+                                    Child = searchTextBox = new BasicSearchTextBox
                                     {
-                                        d.Anchor = Anchor.TopRight;
-                                        d.Origin = Anchor.TopRight;
-                                    }))
+                                        Anchor = Anchor.CentreRight,
+                                        Origin = Anchor.CentreRight,
+                                        RelativeSizeAxes = Axes.X,
+                                        Width = 0.6f,
+                                    },
+                                },
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    Height = controls_area_height,
+                                    Children = new Drawable[]
+                                    {
+                                        Buttons.WithChild(CreateNewRoomButton().With(d =>
+                                        {
+                                            d.Anchor = Anchor.BottomLeft;
+                                            d.Origin = Anchor.BottomLeft;
+                                            d.Size = new Vector2(150, 37.5f);
+                                            d.Action = () => Open();
+                                        })),
+                                        new FillFlowContainer
+                                        {
+                                            Anchor = Anchor.TopRight,
+                                            Origin = Anchor.TopRight,
+                                            AutoSizeAxes = Axes.Both,
+                                            Direction = FillDirection.Horizontal,
+                                            Spacing = new Vector2(10),
+                                            ChildrenEnumerable = CreateFilterControls().Select(f => f.With(d =>
+                                            {
+                                                d.Anchor = Anchor.TopRight;
+                                                d.Origin = Anchor.TopRight;
+                                            }))
+                                        }
+                                    }
                                 }
-                            }
-                        }
-                    },
+                            },
+                        },
+                    }
                 },
             };
-
-            // scroll selected room into view on selection.
-            SelectedRoom.BindValueChanged(val =>
-            {
-                var drawable = roomsContainer.Rooms.FirstOrDefault(r => r.Room == val.NewValue);
-                if (drawable != null)
-                    scrollContainer.ScrollIntoView(drawable);
-            });
         }
 
         protected override void LoadComplete()
@@ -188,7 +205,6 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
 
             searchTextBox.Current.BindValueChanged(_ => updateFilterDebounced());
             ruleset.BindValueChanged(_ => UpdateFilter());
-
             isIdle.BindValueChanged(_ => updatePollingRate(this.IsCurrentScreen()), true);
 
             if (ongoingOperationTracker != null)
@@ -197,11 +213,38 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
                 operationInProgress.BindValueChanged(_ => updateLoadingLayer());
             }
 
-            ListingPollingComponent.InitialRoomsReceived.BindValueChanged(_ => updateLoadingLayer(), true);
+            hasListingResults.BindValueChanged(_ => updateLoadingLayer());
+
+            filter.BindValueChanged(_ =>
+            {
+                roomListing.Rooms.Clear();
+                hasListingResults.Value = false;
+                listingPoller.PollImmediately();
+            });
 
             updateFilter();
         }
 
+        private void onListingReceived(Room[] result)
+        {
+            Dictionary<long, Room> localRoomsById = roomListing.Rooms.ToDictionary(r => r.RoomID!.Value);
+            Dictionary<long, Room> resultRoomsById = result.ToDictionary(r => r.RoomID!.Value);
+
+            // Remove all local rooms no longer in the result set.
+            roomListing.Rooms.RemoveAll(r => !resultRoomsById.ContainsKey(r.RoomID!.Value));
+
+            // Add or update local rooms with the result set.
+            foreach (var r in result)
+            {
+                if (localRoomsById.TryGetValue(r.RoomID!.Value, out Room? existingRoom))
+                    existingRoom.CopyFrom(r);
+                else
+                    roomListing.Rooms.Add(r);
+            }
+
+            hasListingResults.Value = true;
+        }
+
         #region Filtering
 
         public void UpdateFilter() => Scheduler.AddOnce(updateFilter);
@@ -252,17 +295,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
         {
             base.OnResuming(e);
 
-            Debug.Assert(selectionLease != null);
-
-            selectionLease.Return();
-            selectionLease = null;
-
-            if (SelectedRoom.Value?.RoomID == null)
-                SelectedRoom.Value = new Room();
-
             music.EnsurePlayingSomething();
 
             onReturning();
+
+            // Poll for any newly-created rooms (including potentially the user's own).
+            listingPoller.PollImmediately();
         }
 
         public override bool OnExiting(ScreenExitEvent e)
@@ -297,14 +335,14 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
             popoverContainer.HidePopover();
         }
 
-        public virtual void Join(Room room, string? password, Action<Room>? onSuccess = null, Action<string>? onFailure = null) => Schedule(() =>
+        public void Join(Room room, string? password, Action<Room>? onSuccess = null, Action<string>? onFailure = null) => Schedule(() =>
         {
             if (joiningRoomOperation != null)
                 return;
 
             joiningRoomOperation = ongoingOperationTracker?.BeginOperation();
 
-            RoomManager?.JoinRoom(room, password, _ =>
+            JoinInternal(room, password, r =>
             {
                 Open(room);
                 joiningRoomOperation?.Dispose();
@@ -318,10 +356,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
             });
         });
 
-        /// <summary>
-        /// Copies a room and opens it as a fresh (not-yet-created) one.
-        /// </summary>
-        /// <param name="room">The room to copy.</param>
+        protected abstract void JoinInternal(Room room, string? password, Action<Room> onSuccess, Action<string> onFailure);
+
         public void OpenCopy(Room room)
         {
             Debug.Assert(room.RoomID != null);
@@ -358,6 +394,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
             api.Queue(req);
         }
 
+        public abstract void Close(Room room);
+
         /// <summary>
         /// Push a room as a new subscreen.
         /// </summary>
@@ -371,20 +409,13 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
             OpenNewRoom(room ?? CreateNewRoom());
         });
 
-        protected virtual void OpenNewRoom(Room room)
-        {
-            selectionLease = SelectedRoom.BeginLease(false);
-            Debug.Assert(selectionLease != null);
-            selectionLease.Value = room;
+        protected virtual void OpenNewRoom(Room room) => this.Push(CreateRoomSubScreen(room));
 
-            this.Push(CreateRoomSubScreen(room));
-        }
-
-        public void RefreshRooms() => ListingPollingComponent.PollImmediately();
+        public void RefreshRooms() => listingPoller.PollImmediately();
 
         private void updateLoadingLayer()
         {
-            if (operationInProgress.Value || !ListingPollingComponent.InitialRoomsReceived.Value)
+            if (operationInProgress.Value || !hasListingResults.Value)
                 loadingLayer.Show();
             else
                 loadingLayer.Hide();
@@ -393,11 +424,11 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
         private void updatePollingRate(bool isCurrentScreen)
         {
             if (!isCurrentScreen)
-                ListingPollingComponent.TimeBetweenPolls.Value = 0;
+                listingPoller.TimeBetweenPolls.Value = 0;
             else
-                ListingPollingComponent.TimeBetweenPolls.Value = isIdle.Value ? 120000 : 15000;
+                listingPoller.TimeBetweenPolls.Value = isIdle.Value ? 120000 : 15000;
 
-            Logger.Log($"Polling adjusted (listing: {ListingPollingComponent.TimeBetweenPolls.Value})");
+            Logger.Log($"Polling adjusted (listing: {listingPoller.TimeBetweenPolls.Value})");
         }
 
         protected abstract OsuButton CreateNewRoomButton();
@@ -409,7 +440,5 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
         protected abstract Room CreateNewRoom();
 
         protected abstract RoomSubScreen CreateRoomSubScreen(Room room);
-
-        protected abstract ListingPollingComponent CreatePollingComponent();
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Match/DrawableMatchRoom.cs b/osu.Game/Screens/OnlinePlay/Match/DrawableMatchRoom.cs
index 08bcf32edf..b10e83a05c 100644
--- a/osu.Game/Screens/OnlinePlay/Match/DrawableMatchRoom.cs
+++ b/osu.Game/Screens/OnlinePlay/Match/DrawableMatchRoom.cs
@@ -25,12 +25,13 @@ namespace osu.Game.Screens.OnlinePlay.Match
             set => selectedItem.Current = value;
         }
 
+        public Drawable? ChangeSettingsButton { get; private set; }
+
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
         private readonly BindableWithCurrent<PlaylistItem?> selectedItem = new BindableWithCurrent<PlaylistItem?>();
         private readonly bool allowEdit;
-        private Drawable? editButton;
 
         public DrawableMatchRoom(Room room, bool allowEdit = true)
             : base(room)
@@ -45,7 +46,7 @@ namespace osu.Game.Screens.OnlinePlay.Match
         {
             if (allowEdit)
             {
-                ButtonsContainer.Add(editButton = new PurpleRoundedButton
+                ButtonsContainer.Add(ChangeSettingsButton = new PurpleRoundedButton
                 {
                     RelativeSizeAxes = Axes.Y,
                     Anchor = Anchor.Centre,
@@ -73,8 +74,8 @@ namespace osu.Game.Screens.OnlinePlay.Match
 
         private void updateRoomHost()
         {
-            if (editButton != null)
-                editButton.Alpha = Room.Host?.Equals(api.LocalUser.Value) == true ? 1 : 0;
+            if (ChangeSettingsButton != null)
+                ChangeSettingsButton.Alpha = Room.Host?.Equals(api.LocalUser.Value) == true ? 1 : 0;
         }
 
         protected override UpdateableBeatmapBackgroundSprite CreateBackground() => base.CreateBackground().With(d =>
diff --git a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
index 59acd3c17f..f924ff6980 100644
--- a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
@@ -360,7 +360,9 @@ namespace osu.Game.Screens.OnlinePlay.Match
             if (!ensureExitConfirmed())
                 return true;
 
-            RoomManager?.PartRoom();
+            if (Room.RoomID != null)
+                PartRoom();
+
             Mods.Value = Array.Empty<Mod>();
 
             onLeaving();
@@ -368,6 +370,11 @@ namespace osu.Game.Screens.OnlinePlay.Match
             return base.OnExiting(e);
         }
 
+        /// <summary>
+        /// Parts from the current room.
+        /// </summary>
+        protected abstract void PartRoom();
+
         private bool ensureExitConfirmed()
         {
             if (ExitConfirmed)
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs
index 1372054149..42d240c60e 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs
@@ -29,12 +29,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
 {
     public partial class MultiplayerMatchSettingsOverlay : RoomSettingsOverlay
     {
-        public required Bindable<PlaylistItem?> SelectedItem
-        {
-            get => selectedItem;
-            set => selectedItem.Current = value;
-        }
-
         protected override OsuButton SubmitButton => settings.ApplyButton;
         protected override bool IsLoading => ongoingOperationTracker.InProgress.Value;
 
@@ -56,7 +50,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
             RelativeSizeAxes = Axes.Both,
             RelativePositionAxes = Axes.Y,
             SettingsApplied = Hide,
-            SelectedItem = { BindTarget = SelectedItem }
         };
 
         protected partial class MatchSettings : CompositeDrawable
@@ -65,7 +58,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
 
             public override bool IsPresent => base.IsPresent || Scheduler.HasPendingTasks;
 
-            public readonly Bindable<PlaylistItem?> SelectedItem = new Bindable<PlaylistItem?>();
             public Action? SettingsApplied;
 
             public OsuTextBox NameField = null!;
@@ -86,9 +78,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
             [Resolved]
             private MultiplayerMatchSubScreen matchSubScreen { get; set; } = null!;
 
-            [Resolved]
-            private IRoomManager manager { get; set; } = null!;
-
             [Resolved]
             private MultiplayerClient client { get; set; } = null!;
 
@@ -279,7 +268,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
                                                         {
                                                             RelativeSizeAxes = Axes.X,
                                                             Height = DrawableRoomPlaylistItem.HEIGHT,
-                                                            SelectedItem = { BindTarget = SelectedItem }
                                                         },
                                                         selectBeatmapButton = new RoundedButton
                                                         {
@@ -377,8 +365,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
                 updateRoomMaxParticipants();
                 updateRoomAutoStartDuration();
                 updateRoomPlaylist();
-
-                drawablePlaylist.Items.BindCollectionChanged((_, __) => room.Playlist = drawablePlaylist.Items.ToArray());
             }
 
             private void onRoomPropertyChanged(object? sender, PropertyChangedEventArgs e)
@@ -456,7 +442,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
                 if (!ApplyButton.Enabled.Value)
                     return;
 
-                hideError();
+                ErrorText.FadeOut(50);
 
                 Debug.Assert(applyingSettingsOperation == null);
                 applyingSettingsOperation = ongoingOperationTracker.BeginOperation();
@@ -475,32 +461,32 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
                           .ContinueWith(t => Schedule(() =>
                           {
                               if (t.IsCompletedSuccessfully)
-                                  onSuccess(room);
+                                  onSuccess();
                               else
-                                  onError(t.Exception?.AsSingular().Message ?? "Error changing settings.");
+                                  onError(t.Exception, "Error changing settings");
                           }));
                 }
                 else
                 {
                     room.Name = NameField.Text;
+                    room.Password = PasswordTextBox.Text;
                     room.Type = TypePicker.Current.Value;
-                    room.Password = PasswordTextBox.Current.Value;
                     room.QueueMode = QueueModeDropdown.Current.Value;
                     room.AutoStartDuration = TimeSpan.FromSeconds((int)startModeDropdown.Current.Value);
                     room.AutoSkip = AutoSkipCheckbox.Current.Value;
+                    room.Playlist = drawablePlaylist.Items.ToArray();
 
-                    if (int.TryParse(MaxParticipantsField.Text, out int max))
-                        room.MaxParticipants = max;
-                    else
-                        room.MaxParticipants = null;
-
-                    manager.CreateRoom(room, onSuccess, onError);
+                    client.CreateRoom(room).ContinueWith(t => Schedule(() =>
+                    {
+                        if (t.IsCompletedSuccessfully)
+                            onSuccess();
+                        else
+                            onError(t.Exception, "Error creating room");
+                    }));
                 }
             }
 
-            private void hideError() => ErrorText.FadeOut(50);
-
-            private void onSuccess(Room room) => Schedule(() =>
+            private void onSuccess() => Schedule(() =>
             {
                 Debug.Assert(applyingSettingsOperation != null);
 
@@ -510,28 +496,31 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
                 applyingSettingsOperation = null;
             });
 
-            private void onError(string text) => Schedule(() =>
+            private void onError(Exception? exception, string description)
             {
-                Debug.Assert(applyingSettingsOperation != null);
+                if (exception is AggregateException aggregateException)
+                    exception = aggregateException.AsSingular();
 
-                // see https://github.com/ppy/osu-web/blob/2c97aaeb64fb4ed97c747d8383a35b30f57428c7/app/Models/Multiplayer/PlaylistItem.php#L48.
-                const string not_found_prefix = "beatmaps not found:";
+                string message = exception?.GetHubExceptionMessage() ?? $"{description} ({exception?.Message})";
 
-                if (text.StartsWith(not_found_prefix, StringComparison.Ordinal))
+                Schedule(() =>
                 {
-                    ErrorText.Text = "The selected beatmap is not available online.";
-                    SelectedItem.Value?.MarkInvalid();
-                }
-                else
-                {
-                    ErrorText.Text = text;
-                }
+                    Debug.Assert(applyingSettingsOperation != null);
 
-                ErrorText.FadeIn(50);
+                    // see https://github.com/ppy/osu-web/blob/2c97aaeb64fb4ed97c747d8383a35b30f57428c7/app/Models/Multiplayer/PlaylistItem.php#L48.
+                    const string not_found_prefix = "beatmaps not found:";
 
-                applyingSettingsOperation.Dispose();
-                applyingSettingsOperation = null;
-            });
+                    if (message.StartsWith(not_found_prefix, StringComparison.Ordinal))
+                        ErrorText.Text = "The selected beatmap is not available online.";
+                    else
+                        ErrorText.Text = message;
+
+                    ErrorText.FadeIn(50);
+
+                    applyingSettingsOperation.Dispose();
+                    applyingSettingsOperation = null;
+                });
+            }
 
             protected override void Dispose(bool isDisposing)
             {
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Multiplayer.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Multiplayer.cs
index bf316bb3da..0b06a16d98 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Multiplayer.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Multiplayer.cs
@@ -8,7 +8,6 @@ using osu.Framework.Logging;
 using osu.Framework.Screens;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 
 namespace osu.Game.Screens.OnlinePlay.Multiplayer
@@ -29,11 +28,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
 
         private void onRoomUpdated()
         {
-            if (client.Room == null)
+            if (client.Room == null || client.LocalUser == null)
                 return;
 
-            Debug.Assert(client.LocalUser != null);
-
             // If the user exits gameplay before score submission completes, we'll transition to idle when results has been prepared.
             if (client.LocalUser.State == MultiplayerUserState.Results && this.IsCurrentScreen())
                 transitionFromResults();
@@ -63,11 +60,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         {
             base.OnResuming(e);
 
-            if (client.Room == null)
+            if (client.Room == null || client.LocalUser == null)
                 return;
 
-            Debug.Assert(client.LocalUser != null);
-
             if (!(e.Last is MultiplayerPlayerLoader playerLoader))
                 return;
 
@@ -97,8 +92,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
 
         protected override string ScreenTitle => "Multiplayer";
 
-        protected override RoomManager CreateRoomManager() => new MultiplayerRoomManager();
-
         protected override LoungeSubScreen CreateLounge() => new MultiplayerLoungeSubScreen();
 
         public void Join(Room room, string? password) => Schedule(() => Lounge.Join(room, password));
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerLoungeSubScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerLoungeSubScreen.cs
index dd61caa3db..54aa2003fa 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerLoungeSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerLoungeSubScreen.cs
@@ -1,12 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
+using osu.Framework.Extensions.ExceptionExtensions;
 using osu.Framework.Logging;
-using osu.Framework.Screens;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Configuration;
@@ -14,7 +13,6 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Screens.OnlinePlay.Match;
@@ -32,19 +30,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         private Dropdown<RoomPermissionsFilter> roomAccessTypeDropdown = null!;
         private OsuCheckbox showInProgress = null!;
 
-        public override void OnResuming(ScreenTransitionEvent e)
-        {
-            base.OnResuming(e);
-
-            // Upon having left a room, we don't know whether we were the only participant, and whether the room is now closed as a result of leaving it.
-            // To work around this, temporarily remove the room and trigger an immediate listing poll.
-            if (e.Last is MultiplayerMatchSubScreen match)
-            {
-                RoomManager?.RemoveRoom(match.Room);
-                ListingPollingComponent.PollImmediately();
-            }
-        }
-
         protected override IEnumerable<Drawable> CreateFilterControls()
         {
             foreach (var control in base.CreateFilterControls())
@@ -91,7 +76,31 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
 
         protected override RoomSubScreen CreateRoomSubScreen(Room room) => new MultiplayerMatchSubScreen(room);
 
-        protected override ListingPollingComponent CreatePollingComponent() => new MultiplayerListingPollingComponent();
+        protected override void JoinInternal(Room room, string? password, Action<Room> onSuccess, Action<string> onFailure)
+        {
+            client.JoinRoom(room, password).ContinueWith(result =>
+            {
+                if (result.IsCompletedSuccessfully)
+                    onSuccess(room);
+                else
+                {
+                    Exception? exception = result.Exception?.AsSingular();
+
+                    if (exception?.GetHubExceptionMessage() is string message)
+                        onFailure(message);
+                    else
+                    {
+                        const string generic_failure_message = "Failed to join multiplayer room.";
+                        if (result.Exception != null)
+                            Logger.Error(result.Exception, generic_failure_message);
+                        onFailure(generic_failure_message);
+                    }
+                }
+            });
+        }
+
+        public override void Close(Room room)
+            => throw new NotSupportedException("Cannot close multiplayer rooms.");
 
         protected override void OpenNewRoom(Room room)
         {
@@ -103,37 +112,5 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
 
             base.OpenNewRoom(room);
         }
-
-        private partial class MultiplayerListingPollingComponent : ListingPollingComponent
-        {
-            [Resolved]
-            private MultiplayerClient client { get; set; } = null!;
-
-            private readonly IBindable<bool> isConnected = new Bindable<bool>();
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                isConnected.BindTo(client.IsConnected);
-                isConnected.BindValueChanged(_ => Scheduler.AddOnce(poll), true);
-            }
-
-            private void poll()
-            {
-                if (isConnected.Value && IsLoaded)
-                    PollImmediately();
-            }
-
-            protected override Task Poll()
-            {
-                if (!isConnected.Value)
-                    return Task.CompletedTask;
-
-                if (client.Room != null)
-                    return Task.CompletedTask;
-
-                return base.Poll();
-            }
-        }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
index 083c8e070e..5a2da5a555 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
@@ -259,10 +259,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             SelectedItem = SelectedItem
         };
 
-        protected override RoomSettingsOverlay CreateRoomSettingsOverlay(Room room) => new MultiplayerMatchSettingsOverlay(room)
-        {
-            SelectedItem = SelectedItem
-        };
+        protected override RoomSettingsOverlay CreateRoomSettingsOverlay(Room room) => new MultiplayerMatchSettingsOverlay(room);
 
         protected override APIMod[] GetGameplayMods()
         {
@@ -313,6 +310,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
             return base.OnExiting(e);
         }
 
+        protected override void PartRoom() => client.LeaveRoom();
+
         private ModSettingChangeTracker? modSettingChangeTracker;
         private ScheduledDelegate? debouncedModSettingsUpdate;
 
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayerLoader.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayerLoader.cs
index 7eb7f6610e..dd9cb56862 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayerLoader.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerPlayerLoader.cs
@@ -18,6 +18,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         [Resolved]
         private MultiplayerClient multiplayerClient { get; set; } = null!;
 
+        [Resolved]
+        private OsuGame? game { get; set; }
+
         private Player? player;
 
         public MultiplayerPlayerLoader(Func<Player> createPlayer)
@@ -39,6 +42,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         {
             base.OnPlayerLoaded();
 
+            game?.Window?.Flash();
+
             multiplayerClient.ChangeState(MultiplayerUserState.Loaded)
                              .ContinueWith(task => failAndBail(task.Exception?.Message ?? "Server error"), TaskContinuationOptions.NotOnRanToCompletion);
         }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomManager.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomManager.cs
deleted file mode 100644
index 7f09c9cbe9..0000000000
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomManager.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Diagnostics;
-using osu.Framework.Allocation;
-using osu.Framework.Extensions.ExceptionExtensions;
-using osu.Framework.Logging;
-using osu.Game.Online.Multiplayer;
-using osu.Game.Online.Rooms;
-using osu.Game.Screens.OnlinePlay.Components;
-
-namespace osu.Game.Screens.OnlinePlay.Multiplayer
-{
-    public partial class MultiplayerRoomManager : RoomManager
-    {
-        [Resolved]
-        private MultiplayerClient multiplayerClient { get; set; } = null!;
-
-        public override void CreateRoom(Room room, Action<Room>? onSuccess = null, Action<string>? onError = null)
-            => base.CreateRoom(room, r => joinMultiplayerRoom(r, r.Password, onSuccess, onError), onError);
-
-        public override void JoinRoom(Room room, string? password = null, Action<Room>? onSuccess = null, Action<string>? onError = null)
-        {
-            if (!multiplayerClient.IsConnected.Value)
-            {
-                onError?.Invoke("Not currently connected to the multiplayer server.");
-                return;
-            }
-
-            // this is done here as a pre-check to avoid clicking on already closed rooms in the lounge from triggering a server join.
-            // should probably be done at a higher level, but due to the current structure of things this is the easiest place for now.
-            if (room.HasEnded)
-            {
-                onError?.Invoke("Cannot join an ended room.");
-                return;
-            }
-
-            base.JoinRoom(room, password, r => joinMultiplayerRoom(r, password, onSuccess, onError), onError);
-        }
-
-        public override void PartRoom()
-        {
-            if (JoinedRoom.Value == null)
-                return;
-
-            base.PartRoom();
-            multiplayerClient.LeaveRoom();
-        }
-
-        private void joinMultiplayerRoom(Room room, string? password, Action<Room>? onSuccess = null, Action<string>? onError = null)
-        {
-            Debug.Assert(room.RoomID != null);
-
-            multiplayerClient.JoinRoom(room, password).ContinueWith(t =>
-            {
-                if (t.IsCompletedSuccessfully)
-                    Schedule(() => onSuccess?.Invoke(room));
-                else if (t.IsFaulted)
-                {
-                    const string message = "Failed to join multiplayer room.";
-
-                    if (t.Exception != null)
-                        Logger.Error(t.Exception, message);
-
-                    PartRoom();
-                    Schedule(() => onError?.Invoke(t.Exception?.AsSingular().Message ?? message));
-                }
-            });
-        }
-    }
-}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomSounds.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomSounds.cs
index d53e485c86..cdf4e96bad 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomSounds.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerRoomSounds.cs
@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -20,7 +19,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         private Sample? userJoinedSample;
         private Sample? userLeftSample;
         private Sample? userKickedSample;
-        private MultiplayerRoomUser? host;
 
         [BackgroundDependencyLoader]
         private void load(AudioManager audio)
@@ -35,25 +33,10 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         {
             base.LoadComplete();
 
-            client.RoomUpdated += onRoomUpdated;
             client.UserJoined += onUserJoined;
             client.UserLeft += onUserLeft;
             client.UserKicked += onUserKicked;
-            updateState();
-        }
-
-        private void onRoomUpdated() => Scheduler.AddOnce(updateState);
-
-        private void updateState()
-        {
-            if (EqualityComparer<MultiplayerRoomUser>.Default.Equals(host, client.Room?.Host))
-                return;
-
-            // only play sound when the host changes from an already-existing host.
-            if (host != null)
-                Scheduler.AddOnce(() => hostChangedSample?.Play());
-
-            host = client.Room?.Host;
+            client.HostChanged += onHostChanged;
         }
 
         private void onUserJoined(MultiplayerRoomUser user)
@@ -65,16 +48,22 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         private void onUserKicked(MultiplayerRoomUser user)
             => Scheduler.AddOnce(() => userKickedSample?.Play());
 
+        private void onHostChanged(MultiplayerRoomUser? host)
+        {
+            if (host != null)
+                Scheduler.AddOnce(() => hostChangedSample?.Play());
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
 
             if (client.IsNotNull())
             {
-                client.RoomUpdated -= onRoomUpdated;
                 client.UserJoined -= onUserJoined;
                 client.UserLeft -= onUserLeft;
                 client.UserKicked -= onUserKicked;
+                client.HostChanged -= onHostChanged;
             }
         }
     }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorResultsScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorResultsScreen.cs
index c240bbea0c..3cf1661c8d 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorResultsScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorResultsScreen.cs
@@ -1,9 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
-using osu.Game.Online.API;
+using System.Threading.Tasks;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 
@@ -23,8 +21,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
             Scheduler.AddDelayed(() => StatisticsPanel.ToggleVisibility(), 1000);
         }
 
-        protected override APIRequest? FetchScores(Action<IEnumerable<ScoreInfo>> scoresCallback) => null;
+        protected override Task<ScoreInfo[]> FetchScores() => Task.FromResult<ScoreInfo[]>([]);
 
-        protected override APIRequest? FetchNextPage(int direction, Action<IEnumerable<ScoreInfo>> scoresCallback) => null;
+        protected override Task<ScoreInfo[]> FetchNextPage(int direction) => Task.FromResult<ScoreInfo[]>([]);
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs b/osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs
index 17fb667e14..812e42479b 100644
--- a/osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs
@@ -11,7 +11,6 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Users;
 
@@ -36,9 +35,6 @@ namespace osu.Game.Screens.OnlinePlay
         private readonly ScreenStack screenStack = new OnlinePlaySubScreenStack { RelativeSizeAxes = Axes.Both };
         private OnlinePlayScreenWaveContainer waves = null!;
 
-        [Cached(Type = typeof(IRoomManager))]
-        protected RoomManager RoomManager { get; private set; }
-
         [Cached]
         private readonly OngoingOperationTracker ongoingOperationTracker = new OngoingOperationTracker();
 
@@ -51,8 +47,6 @@ namespace osu.Game.Screens.OnlinePlay
             Origin = Anchor.Centre;
             RelativeSizeAxes = Axes.Both;
             Padding = new MarginPadding { Horizontal = -HORIZONTAL_OVERFLOW_PADDING };
-
-            RoomManager = CreateRoomManager();
         }
 
         private readonly IBindable<APIState> apiState = new Bindable<APIState>();
@@ -67,7 +61,6 @@ namespace osu.Game.Screens.OnlinePlay
                 {
                     screenStack,
                     new Header(ScreenTitle, screenStack),
-                    RoomManager,
                     ongoingOperationTracker,
                 }
             };
@@ -165,8 +158,6 @@ namespace osu.Game.Screens.OnlinePlay
                 subScreen.Exit();
             }
 
-            RoomManager.PartRoom();
-
             waves.Hide();
 
             this.Delay(WaveContainer.DISAPPEAR_DURATION).FadeOut();
@@ -224,8 +215,6 @@ namespace osu.Game.Screens.OnlinePlay
 
         protected abstract string ScreenTitle { get; }
 
-        protected virtual RoomManager CreateRoomManager() => new RoomManager();
-
         protected abstract LoungeSubScreen CreateLounge();
 
         ScreenStack IHasSubScreenStack.SubScreenStack => screenStack;
diff --git a/osu.Game/Screens/OnlinePlay/OnlinePlaySubScreen.cs b/osu.Game/Screens/OnlinePlay/OnlinePlaySubScreen.cs
index fa1ee004c9..9b35a794a3 100644
--- a/osu.Game/Screens/OnlinePlay/OnlinePlaySubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/OnlinePlaySubScreen.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.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Screens;
 
@@ -15,9 +14,6 @@ namespace osu.Game.Screens.OnlinePlay
 
         protected sealed override bool PlayExitSound => false;
 
-        [Resolved]
-        protected IRoomManager? RoomManager { get; private set; }
-
         protected OnlinePlaySubScreen()
         {
             Anchor = Anchor.Centre;
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/AddPlaylistToCollectionButton.cs b/osu.Game/Screens/OnlinePlay/Playlists/AddPlaylistToCollectionButton.cs
index 741173f9a3..47629981f1 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/AddPlaylistToCollectionButton.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/AddPlaylistToCollectionButton.cs
@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics.Cursor;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Collections;
@@ -18,7 +17,7 @@ using Realms;
 
 namespace osu.Game.Screens.OnlinePlay.Playlists
 {
-    public partial class AddPlaylistToCollectionButton : RoundedButton, IHasTooltip
+    public partial class AddPlaylistToCollectionButton : RoundedButton
     {
         private readonly Room room;
 
@@ -161,7 +160,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             collectionSubscription?.Dispose();
         }
 
-        public LocalisableString TooltipText
+        public override LocalisableString TooltipText
         {
             get
             {
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemResultsScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemResultsScreen.cs
index 13ef5d6f64..0e539936d8 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemResultsScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemResultsScreen.cs
@@ -5,11 +5,17 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading.Tasks;
 using osu.Framework.Allocation;
 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.UserInterface;
+using osu.Game.Models;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
@@ -38,6 +44,12 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         [Resolved]
         protected RulesetStore Rulesets { get; private set; } = null!;
 
+        [Resolved]
+        private BeatmapLookupCache beatmapLookupCache { get; set; } = null!;
+
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; } = null!;
+
         protected PlaylistItemResultsScreen(ScoreInfo? score, long roomId, PlaylistItem playlistItem)
             : base(score)
         {
@@ -76,16 +88,21 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
         protected abstract APIRequest<MultiplayerScore> CreateScoreRequest();
 
-        protected sealed override APIRequest FetchScores(Action<IEnumerable<ScoreInfo>> scoresCallback)
+        protected override async Task<ScoreInfo[]> FetchScores()
         {
             // This performs two requests:
             // 1. A request to show the relevant score (and scores around).
             // 2. If that fails, a request to index the room starting from the highest score.
 
+            var requestTaskSource = new TaskCompletionSource<MultiplayerScore>();
             var userScoreReq = CreateScoreRequest();
+            userScoreReq.Success += requestTaskSource.SetResult;
+            userScoreReq.Failure += requestTaskSource.SetException;
+            API.Queue(userScoreReq);
 
-            userScoreReq.Success += userScore =>
+            try
             {
+                var userScore = await requestTaskSource.Task.ConfigureAwait(false);
                 var allScores = new List<MultiplayerScore> { userScore };
 
                 // Other scores could have arrived between score submission and entering the results screen. Ensure the local player score position is up to date.
@@ -113,98 +130,157 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                     setPositions(lowerScores, userScore.Position.Value, 1);
                 }
 
-                Schedule(() =>
-                {
-                    PerformSuccessCallback(scoresCallback, allScores);
-                    hideLoadingSpinners();
-                });
-            };
-
-            // On failure, fallback to a normal index.
-            userScoreReq.Failure += _ => API.Queue(createIndexRequest(scoresCallback));
-
-            return userScoreReq;
+                return await transformScores(allScores).ConfigureAwait(false);
+            }
+            catch
+            {
+                return await fetchScoresAround().ConfigureAwait(false);
+            }
         }
 
-        protected override APIRequest? FetchNextPage(int direction, Action<IEnumerable<ScoreInfo>> scoresCallback)
+        protected override async Task<ScoreInfo[]> FetchNextPage(int direction)
         {
             Debug.Assert(direction == 1 || direction == -1);
 
             MultiplayerScores? pivot = direction == -1 ? higherScores : lowerScores;
-
             if (pivot?.Cursor == null)
-                return null;
+                return [];
 
-            if (pivot == higherScores)
-                LeftSpinner.Show();
-            else
-                RightSpinner.Show();
+            Schedule(() =>
+            {
+                if (pivot == higherScores)
+                    LeftSpinner.Show();
+                else
+                    RightSpinner.Show();
+            });
 
-            return createIndexRequest(scoresCallback, pivot);
+            return await fetchScoresAround(pivot).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Creates a <see cref="IndexPlaylistScoresRequest"/> with an optional score pivot.
         /// </summary>
         /// <remarks>Does not queue the request.</remarks>
-        /// <param name="scoresCallback">The callback to perform with the resulting scores.</param>
         /// <param name="pivot">An optional score pivot to retrieve scores around. Can be null to retrieve scores from the highest score.</param>
-        /// <returns>The indexing <see cref="APIRequest"/>.</returns>
-        private APIRequest createIndexRequest(Action<IEnumerable<ScoreInfo>> scoresCallback, MultiplayerScores? pivot = null)
+        private async Task<ScoreInfo[]> fetchScoresAround(MultiplayerScores? pivot = null)
         {
+            var requestTaskSource = new TaskCompletionSource<IndexedMultiplayerScores>();
             var indexReq = pivot != null
                 ? new IndexPlaylistScoresRequest(RoomId, PlaylistItem.ID, pivot.Cursor, pivot.Params)
                 : new IndexPlaylistScoresRequest(RoomId, PlaylistItem.ID);
+            indexReq.Success += requestTaskSource.SetResult;
+            indexReq.Failure += requestTaskSource.SetException;
+            API.Queue(indexReq);
 
-            indexReq.Success += r =>
+            try
             {
+                var index = await requestTaskSource.Task.ConfigureAwait(false);
+
                 if (pivot == lowerScores)
                 {
-                    lowerScores = r;
-                    setPositions(r, pivot, 1);
+                    lowerScores = index;
+                    setPositions(index, pivot, 1);
                 }
                 else
                 {
-                    higherScores = r;
-                    setPositions(r, pivot, -1);
+                    higherScores = index;
+                    setPositions(index, pivot, -1);
+
+                    // when paginating the results, it's possible for the user's score to naturally fall down the rankings.
+                    // unmitigated, this can cause scores at the very top of the rankings to have zero or negative positions
+                    // because the positions are counted backwards from the user's score, which has increased in this case during pagination.
+                    // if this happens, just give the top score the first position.
+                    // note that this isn't 100% correct, but it *is* however the most reliable way to mask the problem.
+                    int smallestPosition = index.Scores.Min(s => s.Position ?? 1);
+
+                    if (smallestPosition < 1)
+                    {
+                        int offset = 1 - smallestPosition;
+
+                        foreach (var scorePanel in ScorePanelList.GetScorePanels())
+                            scorePanel.ScorePosition.Value += offset;
+
+                        foreach (var score in index.Scores)
+                            score.Position += offset;
+                    }
                 }
 
-                Schedule(() =>
-                {
-                    PerformSuccessCallback(scoresCallback, r.Scores, r);
-                    hideLoadingSpinners(r);
-                });
-            };
-
-            indexReq.Failure += _ => hideLoadingSpinners(pivot);
-
-            return indexReq;
+                return await transformScores(index.Scores).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Failed to fetch scores (room: {RoomId}, item: {PlaylistItem.ID}): {ex}");
+                return [];
+            }
         }
 
         /// <summary>
-        /// Transforms returned <see cref="MultiplayerScores"/> into <see cref="ScoreInfo"/>s, ensure the <see cref="ScorePanelList"/> is put into a sane state, and invokes a given success callback.
+        /// Transforms returned <see cref="MultiplayerScores"/> into <see cref="ScoreInfo"/>s.
         /// </summary>
-        /// <param name="callback">The callback to invoke with the final <see cref="ScoreInfo"/>s.</param>
         /// <param name="scores">The <see cref="MultiplayerScore"/>s that were retrieved from <see cref="APIRequest"/>s.</param>
-        /// <param name="pivot">An optional pivot around which the scores were retrieved.</param>
-        protected virtual ScoreInfo[] PerformSuccessCallback(Action<IEnumerable<ScoreInfo>> callback, List<MultiplayerScore> scores, MultiplayerScores? pivot = null)
+        private async Task<ScoreInfo[]> transformScores(List<MultiplayerScore> scores)
         {
-            var scoreInfos = scores.Select(s => s.CreateScoreInfo(ScoreManager, Rulesets, Beatmap.Value.BeatmapInfo)).OrderByTotalScore().ToArray();
+            int[] allBeatmapIds = scores.Select(s => s.BeatmapId).Distinct().ToArray();
+            BeatmapInfo[] localBeatmaps = allBeatmapIds.Select(id => beatmapManager.QueryBeatmap(b => b.OnlineID == id))
+                                                       .Where(b => b != null)
+                                                       .ToArray()!;
 
-            // Invoke callback to add the scores. Exclude the score provided to this screen since it's added already.
-            callback.Invoke(scoreInfos.Where(s => s.OnlineID != Score?.OnlineID));
+            int[] missingBeatmapIds = allBeatmapIds.Except(localBeatmaps.Select(b => b.OnlineID)).ToArray();
+            APIBeatmap[] onlineBeatmaps = (await beatmapLookupCache.GetBeatmapsAsync(missingBeatmapIds).ConfigureAwait(false)).Where(b => b != null).ToArray()!;
 
-            return scoreInfos;
+            Dictionary<int, BeatmapInfo> beatmapsById = new Dictionary<int, BeatmapInfo>();
+
+            foreach (var beatmap in localBeatmaps)
+                beatmapsById[beatmap.OnlineID] = beatmap;
+
+            foreach (var beatmap in onlineBeatmaps)
+            {
+                // Minimal data required to get various components in this screen to display correctly.
+                beatmapsById[beatmap.OnlineID] = new BeatmapInfo
+                {
+                    Difficulty = new BeatmapDifficulty(beatmap.Difficulty),
+                    Metadata =
+                    {
+                        Artist = beatmap.Metadata.Artist,
+                        Title = beatmap.Metadata.Title,
+                        Author = new RealmUser
+                        {
+                            Username = beatmap.Metadata.Author.Username,
+                            OnlineID = beatmap.Metadata.Author.OnlineID,
+                        }
+                    },
+                    DifficultyName = beatmap.DifficultyName,
+                    StarRating = beatmap.StarRating,
+                    Length = beatmap.Length,
+                    BPM = beatmap.BPM
+                };
+            }
+
+            // Validate that we have all beatmaps we need.
+            foreach (int id in allBeatmapIds)
+            {
+                if (!beatmapsById.ContainsKey(id))
+                {
+                    Logger.Log($"Failed to fetch beatmap {id} to display scores for playlist item {PlaylistItem.ID}");
+                    beatmapsById[id] = Beatmap.Value.BeatmapInfo;
+                }
+            }
+
+            // Exclude the score provided to this screen since it's added already.
+            return scores
+                   .Where(s => s.ID != Score?.OnlineID)
+                   .Select(s => s.CreateScoreInfo(ScoreManager, Rulesets, beatmapsById[s.BeatmapId]))
+                   .OrderByTotalScore()
+                   .ToArray();
         }
 
-        private void hideLoadingSpinners(MultiplayerScores? pivot = null)
+        protected override void OnScoresAdded(ScoreInfo[] scores)
         {
-            CentreSpinner.Hide();
+            base.OnScoresAdded(scores);
 
-            if (pivot == lowerScores)
-                RightSpinner.Hide();
-            else if (pivot == higherScores)
-                LeftSpinner.Hide();
+            CentreSpinner.Hide();
+            RightSpinner.Hide();
+            LeftSpinner.Hide();
         }
 
         /// <summary>
@@ -213,7 +289,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         /// <param name="scores">The <see cref="MultiplayerScores"/> to set positions on.</param>
         /// <param name="pivot">The pivot.</param>
         /// <param name="increment">The amount to increment the pivot position by for each <see cref="MultiplayerScore"/> in <paramref name="scores"/>.</param>
-        private void setPositions(MultiplayerScores scores, MultiplayerScores? pivot, int increment)
+        private static void setPositions(MultiplayerScores scores, MultiplayerScores? pivot, int increment)
             => setPositions(scores, pivot?.Scores[^1].Position ?? 0, increment);
 
         /// <summary>
@@ -222,7 +298,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         /// <param name="scores">The <see cref="MultiplayerScores"/> to set positions on.</param>
         /// <param name="pivotPosition">The pivot position.</param>
         /// <param name="increment">The amount to increment the pivot position by for each <see cref="MultiplayerScore"/> in <paramref name="scores"/>.</param>
-        private void setPositions(MultiplayerScores scores, int pivotPosition, int increment)
+        private static void setPositions(MultiplayerScores scores, int pivotPosition, int increment)
         {
             foreach (var s in scores.Scores)
             {
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemScoreResultsScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemScoreResultsScreen.cs
index 05c03a4b28..74b12b6d3c 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemScoreResultsScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemScoreResultsScreen.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
@@ -31,11 +29,10 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
         protected override APIRequest<MultiplayerScore> CreateScoreRequest() => new ShowPlaylistScoreRequest(RoomId, PlaylistItem.ID, scoreId);
 
-        protected override ScoreInfo[] PerformSuccessCallback(Action<IEnumerable<ScoreInfo>> callback, List<MultiplayerScore> scores, MultiplayerScores? pivot = null)
+        protected override void OnScoresAdded(ScoreInfo[] scores)
         {
-            var scoreInfos = base.PerformSuccessCallback(callback, scores, pivot);
-            Schedule(() => SelectedScore.Value ??= scoreInfos.SingleOrDefault(s => s.OnlineID == scoreId));
-            return scoreInfos;
+            base.OnScoresAdded(scores);
+            SelectedScore.Value ??= scores.SingleOrDefault(s => s.OnlineID == scoreId);
         }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemUserBestResultsScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemUserBestResultsScreen.cs
index 5b20496dba..866b094178 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemUserBestResultsScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistItemUserBestResultsScreen.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
@@ -25,17 +23,12 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
         protected override APIRequest<MultiplayerScore> CreateScoreRequest() => new ShowPlaylistUserScoreRequest(RoomId, PlaylistItem.ID, userId);
 
-        protected override ScoreInfo[] PerformSuccessCallback(Action<IEnumerable<ScoreInfo>> callback, List<MultiplayerScore> scores, MultiplayerScores? pivot = null)
+        protected override void OnScoresAdded(ScoreInfo[] scores)
         {
-            var scoreInfos = base.PerformSuccessCallback(callback, scores, pivot);
+            base.OnScoresAdded(scores);
 
-            Schedule(() =>
-            {
-                // Prefer selecting the local user's score, or otherwise default to the first visible score.
-                SelectedScore.Value ??= scoreInfos.FirstOrDefault(s => s.UserID == userId) ?? scoreInfos.FirstOrDefault();
-            });
-
-            return scoreInfos;
+            // Prefer selecting the local user's score, or otherwise default to the first visible score.
+            SelectedScore.Value ??= scores.FirstOrDefault(s => s.UserID == userId) ?? scores.FirstOrDefault();
         }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsLoungeSubScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsLoungeSubScreen.cs
index d66b4f844c..09fb26e090 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsLoungeSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsLoungeSubScreen.cs
@@ -1,16 +1,18 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
 using osu.Game.Online.Rooms;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
 using osu.Game.Screens.OnlinePlay.Match;
@@ -59,6 +61,29 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             return criteria;
         }
 
+        protected override void JoinInternal(Room room, string? password, Action<Room> onSuccess, Action<string> onFailure)
+        {
+            var joinRoomRequest = new JoinRoomRequest(room, password);
+
+            joinRoomRequest.Success += r => onSuccess(r);
+            joinRoomRequest.Failure += exception =>
+            {
+                if (exception is not OperationCanceledException)
+                    onFailure(exception.Message);
+            };
+
+            api.Queue(joinRoomRequest);
+        }
+
+        public override void Close(Room room)
+        {
+            Debug.Assert(room.RoomID != null);
+
+            var request = new ClosePlaylistRequest(room.RoomID.Value);
+            request.Success += RefreshRooms;
+            api.Queue(request);
+        }
+
         protected override OsuButton CreateNewRoomButton() => new CreatePlaylistsRoomButton();
 
         protected override Room CreateNewRoom()
@@ -72,8 +97,6 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
         protected override RoomSubScreen CreateRoomSubScreen(Room room) => new PlaylistsRoomSubScreen(room);
 
-        protected override ListingPollingComponent CreatePollingComponent() => new ListingPollingComponent();
-
         private enum PlaylistsCategory
         {
             Any,
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSettingsOverlay.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSettingsOverlay.cs
index 88af161cc8..9c0363f40e 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSettingsOverlay.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSettingsOverlay.cs
@@ -75,9 +75,6 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
             private PurpleRoundedButton editPlaylistButton = null!;
 
-            [Resolved]
-            private IRoomManager? manager { get; set; }
-
             [Resolved]
             private IAPIProvider api { get; set; } = null!;
 
@@ -440,7 +437,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                 if (!ApplyButton.Enabled.Value)
                     return;
 
-                hideError();
+                ErrorText.FadeOut(50);
 
                 room.Name = NameField.Text;
                 room.Availability = AvailabilityPicker.Current.Value;
@@ -449,13 +446,13 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                 room.Duration = DurationField.Current.Value;
 
                 loadingLayer.Show();
-                manager?.CreateRoom(room, onSuccess, onError);
+
+                var req = new CreateRoomRequest(room);
+                req.Success += _ => loadingLayer.Hide();
+                req.Failure += e => onError(req.Response?.Error ?? e.Message);
+                api.Queue(req);
             }
 
-            private void hideError() => ErrorText.FadeOut(50);
-
-            private void onSuccess(Room room) => loadingLayer.Hide();
-
             private void onError(string text)
             {
                 // see https://github.com/ppy/osu-web/blob/2c97aaeb64fb4ed97c747d8383a35b30f57428c7/app/Models/Multiplayer/PlaylistItem.php#L48.
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
index c64dffa1e3..f62198ad1b 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
@@ -44,7 +44,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         private IdleTracker? idleTracker { get; set; }
 
         private MatchLeaderboard leaderboard = null!;
-        private SelectionPollingComponent selectionPollingComponent = null!;
+        private PlaylistsRoomUpdater roomUpdater = null!;
         private FillFlowContainer progressSection = null!;
         private DrawableRoomPlaylist drawablePlaylist = null!;
 
@@ -64,7 +64,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             if (idleTracker != null)
                 isIdle.BindTo(idleTracker.IsIdle);
 
-            AddInternal(selectionPollingComponent = new SelectionPollingComponent(Room));
+            AddInternal(roomUpdater = new PlaylistsRoomUpdater(Room));
         }
 
         protected override void LoadComplete()
@@ -330,8 +330,8 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
         private void updatePollingRate()
         {
-            selectionPollingComponent.TimeBetweenPolls.Value = isIdle.Value ? 30000 : 5000;
-            Logger.Log($"Polling adjusted (selection: {selectionPollingComponent.TimeBetweenPolls.Value})");
+            roomUpdater.TimeBetweenPolls.Value = isIdle.Value ? 30000 : 5000;
+            Logger.Log($"Polling adjusted (selection: {roomUpdater.TimeBetweenPolls.Value})");
         }
 
         private void closePlaylist()
@@ -344,6 +344,8 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
             }));
         }
 
+        protected override void PartRoom() => api.Queue(new PartRoomRequest(Room));
+
         protected override Screen CreateGameplayScreen(PlaylistItem selectedItem)
         {
             return new PlayerLoader(() => new PlaylistsPlayer(Room, selectedItem)
diff --git a/osu.Game/Screens/OnlinePlay/Components/SelectionPollingComponent.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomUpdater.cs
similarity index 65%
rename from osu.Game/Screens/OnlinePlay/Components/SelectionPollingComponent.cs
rename to osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomUpdater.cs
index 7cee8b3546..f68703750a 100644
--- a/osu.Game/Screens/OnlinePlay/Components/SelectionPollingComponent.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomUpdater.cs
@@ -2,18 +2,24 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Game.Online;
+using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
 
-namespace osu.Game.Screens.OnlinePlay.Components
+namespace osu.Game.Screens.OnlinePlay.Playlists
 {
     /// <summary>
-    /// A <see cref="RoomPollingComponent"/> that polls for the currently-selected room.
+    /// A <see cref="PollingComponent"/> that polls for and updates a room.
     /// </summary>
-    public partial class SelectionPollingComponent : RoomPollingComponent
+    public partial class PlaylistsRoomUpdater : PollingComponent
     {
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
         private readonly Room room;
 
-        public SelectionPollingComponent(Room room)
+        public PlaylistsRoomUpdater(Room room)
         {
             this.room = room;
         }
@@ -22,27 +28,26 @@ namespace osu.Game.Screens.OnlinePlay.Components
 
         protected override Task Poll()
         {
-            if (!API.IsLoggedIn)
+            if (!api.IsLoggedIn)
                 return base.Poll();
 
             if (room.RoomID == null)
                 return base.Poll();
 
-            var tcs = new TaskCompletionSource<bool>();
-
             lastPollRequest?.Cancel();
 
+            var tcs = new TaskCompletionSource<bool>();
             var req = new GetRoomRequest(room.RoomID.Value);
 
             req.Success += result =>
             {
-                RoomManager.AddOrUpdateRoom(result);
+                room.CopyFrom(result);
                 tcs.SetResult(true);
             };
 
             req.Failure += _ => tcs.SetResult(false);
 
-            API.Queue(req);
+            api.Queue(req);
 
             lastPollRequest = req;
 
diff --git a/osu.Game/Screens/Play/HUD/PlayerTeamFlag.cs b/osu.Game/Screens/Play/HUD/PlayerTeamFlag.cs
index f8ef03c58c..3f72099a45 100644
--- a/osu.Game/Screens/Play/HUD/PlayerTeamFlag.cs
+++ b/osu.Game/Screens/Play/HUD/PlayerTeamFlag.cs
@@ -3,8 +3,10 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Database;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Skinning;
@@ -40,10 +42,19 @@ namespace osu.Game.Screens.Play.HUD
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(UserLookupCache userLookupCache)
         {
             if (gameplayState != null)
-                flag.Team = gameplayState.Score.ScoreInfo.User.Team;
+            {
+                if (gameplayState.Score.ScoreInfo.User.Team != null)
+                    flag.Team = gameplayState.Score.ScoreInfo.User.Team;
+                else
+                {
+                    // We only store very basic information about a user to realm, so there's a high chance we don't have the team information.
+                    userLookupCache.GetUserAsync(gameplayState.Score.ScoreInfo.User.Id)
+                                   .ContinueWith(task => Schedule(() => flag.Team = task.GetResultSafely()?.Team));
+                }
+            }
             else
             {
                 apiUser = api.LocalUser.GetBoundCopy();
diff --git a/osu.Game/Screens/Play/HUD/SpectatorList.cs b/osu.Game/Screens/Play/HUD/SpectatorList.cs
index 4297c62712..0660c1c8db 100644
--- a/osu.Game/Screens/Play/HUD/SpectatorList.cs
+++ b/osu.Game/Screens/Play/HUD/SpectatorList.cs
@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Linq;
 using osu.Framework.Allocation;
@@ -13,12 +12,10 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Pooling;
-using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Online.Chat;
 using osu.Game.Localisation.HUD;
-using osu.Game.Localisation.SkinComponents;
+using osu.Game.Online.Chat;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Spectator;
 using osu.Game.Skinning;
@@ -31,15 +28,14 @@ namespace osu.Game.Screens.Play.HUD
     {
         private const int max_spectators_displayed = 10;
 
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.Font), nameof(SkinnableComponentStrings.FontDescription))]
-        public Bindable<Typeface> Font { get; } = new Bindable<Typeface>(Typeface.Torus);
-
-        [SettingSource(typeof(SkinnableComponentStrings), nameof(SkinnableComponentStrings.TextColour), nameof(SkinnableComponentStrings.TextColourDescription))]
+        public Bindable<Typeface> HeaderFont { get; } = new Bindable<Typeface>(Typeface.Torus);
         public BindableColour4 HeaderColour { get; } = new BindableColour4(Colour4.White);
 
-        private BindableList<SpectatorUser> watchingUsers { get; } = new BindableList<SpectatorUser>();
+        private IBindableList<SpectatorUser> watchingUsers { get; } = new BindableList<SpectatorUser>();
+        private IBindableList<int> multiplayerPlayers { get; } = new BindableList<int>();
+        private BindableList<SpectatorUser> actualSpectators { get; } = new BindableList<SpectatorUser>();
+
         private Bindable<LocalUserPlayingState> userPlayingState { get; } = new Bindable<LocalUserPlayingState>();
-        private int displayedSpectatorCount;
 
         private OsuSpriteText header = null!;
         private FillFlowContainer mainFlow = null!;
@@ -91,35 +87,69 @@ namespace osu.Game.Screens.Play.HUD
         {
             base.LoadComplete();
 
-            ((IBindableList<SpectatorUser>)watchingUsers).BindTo(client.WatchingUsers);
             ((IBindable<LocalUserPlayingState>)userPlayingState).BindTo(gameplayState.PlayingState);
 
-            watchingUsers.BindCollectionChanged(onSpectatorsChanged, true);
+            multiplayerPlayers.BindTo(multiplayerClient.CurrentMatchPlayingUserIds);
+            multiplayerPlayers.BindCollectionChanged((_, _) => removePlayersFromMultiplayerRoom());
+
+            watchingUsers.BindTo(client.WatchingUsers);
+            watchingUsers.BindCollectionChanged(onWatchingUsersChanged, true);
+
+            actualSpectators.BindCollectionChanged(onSpectatorsChanged, true);
             userPlayingState.BindValueChanged(_ => updateVisibility());
 
-            Font.BindValueChanged(_ => updateAppearance());
+            HeaderFont.BindValueChanged(_ => updateAppearance());
             HeaderColour.BindValueChanged(_ => updateAppearance(), true);
             FinishTransforms(true);
 
             this.FadeInFromZero(200, Easing.OutQuint);
         }
 
-        private void onSpectatorsChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        private void onWatchingUsersChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        {
+            switch (e.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                {
+                    for (int i = 0; i < e.NewItems!.Count; i++)
+                        actualSpectators.Add((SpectatorUser)e.NewItems![i]!);
+
+                    break;
+                }
+
+                case NotifyCollectionChangedAction.Remove:
+                {
+                    for (int i = 0; i < e.OldItems!.Count; i++)
+                        actualSpectators.Remove((SpectatorUser)e.OldItems![i]!);
+
+                    break;
+                }
+
+                case NotifyCollectionChangedAction.Reset:
+                {
+                    actualSpectators.Clear();
+                    break;
+                }
+
+                default:
+                    throw new NotSupportedException();
+            }
+
+            removePlayersFromMultiplayerRoom();
+        }
+
+        private void removePlayersFromMultiplayerRoom()
         {
             // the multiplayer gameplay leaderboard relies on calling `SpectatorClient.WatchUser()` to get updates on users' total scores.
             // this has an unfortunate side effect of other players showing up in `SpectatorClient.WatchingUsers`.
             //
             // we do not generally wish to display other players in the room as spectators due to that implementation detail,
             // therefore this code is intended to filter out those players on the client side.
-            //
-            // note that the way that this is done is rather specific to the multiplayer use case and therefore carries a lot of assumptions
-            // (e.g. that the `MultiplayerRoomUser`s have the correct `State` at the point wherein they issue the `WatchUser()` calls).
-            // the more proper way to do this (which is by subscribing to `WatchingUsers` and `RoomUpdated`, and doing a proper diff to a third list on any change of either)
-            // is a lot more difficult to write correctly, given that we also rely on `BindableList`'s collection changed event arguments to properly animate this component.
-            var excludedUserIds = new HashSet<int>();
-            if (multiplayerClient.Room != null)
-                excludedUserIds.UnionWith(multiplayerClient.Room.Users.Where(u => u.State != MultiplayerUserState.Spectating).Select(u => u.UserID));
+            actualSpectators.RemoveAll(s => multiplayerPlayers.Contains(s.OnlineID));
+        }
 
+        private void onSpectatorsChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        {
             switch (e.Action)
             {
                 case NotifyCollectionChangedAction.Add:
@@ -129,9 +159,6 @@ namespace osu.Game.Screens.Play.HUD
                         var spectator = (SpectatorUser)e.NewItems![i]!;
                         int index = Math.Max(e.NewStartingIndex, 0) + i;
 
-                        if (excludedUserIds.Contains(spectator.OnlineID))
-                            continue;
-
                         if (index >= max_spectators_displayed)
                             break;
 
@@ -148,10 +175,10 @@ namespace osu.Game.Screens.Play.HUD
                     for (int i = 0; i < spectatorsFlow.Count; i++)
                         spectatorsFlow.SetLayoutPosition(spectatorsFlow[i], i);
 
-                    if (watchingUsers.Count >= max_spectators_displayed && spectatorsFlow.Count < max_spectators_displayed)
+                    if (actualSpectators.Count >= max_spectators_displayed && spectatorsFlow.Count < max_spectators_displayed)
                     {
                         for (int i = spectatorsFlow.Count; i < max_spectators_displayed; i++)
-                            addNewSpectatorToList(i, watchingUsers[i]);
+                            addNewSpectatorToList(i, actualSpectators[i]);
                     }
 
                     break;
@@ -167,8 +194,7 @@ namespace osu.Game.Screens.Play.HUD
                     throw new NotSupportedException();
             }
 
-            displayedSpectatorCount = watchingUsers.Count(s => !excludedUserIds.Contains(s.OnlineID));
-            header.Text = SpectatorListStrings.SpectatorCount(displayedSpectatorCount).ToUpper();
+            header.Text = SpectatorListStrings.SpectatorCount(actualSpectators.Count).ToUpper();
             updateVisibility();
 
             for (int i = 0; i < spectatorsFlow.Count; i++)
@@ -193,12 +219,12 @@ namespace osu.Game.Screens.Play.HUD
         private void updateVisibility()
         {
             // We don't want to show spectators when we are watching a replay.
-            mainFlow.FadeTo(displayedSpectatorCount > 0 && userPlayingState.Value != LocalUserPlayingState.NotPlaying ? 1 : 0, 250, Easing.OutQuint);
+            mainFlow.FadeTo(actualSpectators.Count > 0 && userPlayingState.Value != LocalUserPlayingState.NotPlaying ? 1 : 0, 250, Easing.OutQuint);
         }
 
         private void updateAppearance()
         {
-            header.Font = OsuFont.GetFont(Font.Value, 12, FontWeight.Bold);
+            header.Font = OsuFont.GetFont(HeaderFont.Value, 12, FontWeight.Bold);
             header.Colour = HeaderColour.Value;
 
             Width = header.DrawWidth;
diff --git a/osu.Game/Screens/Play/HUDOverlay.cs b/osu.Game/Screens/Play/HUDOverlay.cs
index 8bfa8dd6ff..78c602d8f1 100644
--- a/osu.Game/Screens/Play/HUDOverlay.cs
+++ b/osu.Game/Screens/Play/HUDOverlay.cs
@@ -277,18 +277,18 @@ namespace osu.Game.Screens.Play
             if (rulesetComponents != null)
                 processDrawables(rulesetComponents);
 
-            if (lowestTopScreenSpaceRight.HasValue)
-                TopRightElements.Y = MathHelper.Clamp(ToLocalSpace(new Vector2(0, lowestTopScreenSpaceRight.Value)).Y, 0, DrawHeight - TopRightElements.DrawHeight);
+            if (lowestTopScreenSpaceRight.HasValue && DrawHeight - TopRightElements.DrawHeight > 0)
+                TopRightElements.Y = Math.Clamp(ToLocalSpace(new Vector2(0, lowestTopScreenSpaceRight.Value)).Y, 0, DrawHeight - TopRightElements.DrawHeight);
             else
                 TopRightElements.Y = 0;
 
-            if (lowestTopScreenSpaceLeft.HasValue)
-                LeaderboardFlow.Y = MathHelper.Clamp(ToLocalSpace(new Vector2(0, lowestTopScreenSpaceLeft.Value)).Y, 0, DrawHeight - LeaderboardFlow.DrawHeight);
+            if (lowestTopScreenSpaceLeft.HasValue && DrawHeight - LeaderboardFlow.DrawHeight > 0)
+                LeaderboardFlow.Y = Math.Clamp(ToLocalSpace(new Vector2(0, lowestTopScreenSpaceLeft.Value)).Y, 0, DrawHeight - LeaderboardFlow.DrawHeight);
             else
                 LeaderboardFlow.Y = 0;
 
-            if (highestBottomScreenSpace.HasValue)
-                bottomRightElements.Y = BottomScoringElementsHeight = -MathHelper.Clamp(DrawHeight - ToLocalSpace(highestBottomScreenSpace.Value).Y, 0, DrawHeight - bottomRightElements.DrawHeight);
+            if (highestBottomScreenSpace.HasValue && DrawHeight - bottomRightElements.DrawHeight > 0)
+                bottomRightElements.Y = BottomScoringElementsHeight = -Math.Clamp(DrawHeight - ToLocalSpace(highestBottomScreenSpace.Value).Y, 0, DrawHeight - bottomRightElements.DrawHeight);
             else
                 bottomRightElements.Y = 0;
 
diff --git a/osu.Game/Screens/Play/KiaiGameplayFountains.cs b/osu.Game/Screens/Play/KiaiGameplayFountains.cs
index d4e61dc5a0..017e66253f 100644
--- a/osu.Game/Screens/Play/KiaiGameplayFountains.cs
+++ b/osu.Game/Screens/Play/KiaiGameplayFountains.cs
@@ -6,9 +6,11 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Utils;
+using osu.Game.Audio;
 using osu.Game.Configuration;
 using osu.Game.Graphics.Containers;
 using osu.Game.Screens.Menu;
+using osu.Game.Skinning;
 
 namespace osu.Game.Screens.Play
 {
@@ -19,6 +21,8 @@ namespace osu.Game.Screens.Play
 
         private Bindable<bool> kiaiStarFountains = null!;
 
+        private SkinnableSound? sample;
+
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
@@ -26,7 +30,7 @@ namespace osu.Game.Screens.Play
 
             RelativeSizeAxes = Axes.Both;
 
-            Children = new[]
+            Children = new Drawable[]
             {
                 leftFountain = new GameplayStarFountain
                 {
@@ -40,6 +44,7 @@ namespace osu.Game.Screens.Play
                     Origin = Anchor.BottomRight,
                     X = -75,
                 },
+                sample = new SkinnableSound(new SampleInfo("Gameplay/fountain-shoot"))
             };
         }
 
@@ -66,6 +71,8 @@ namespace osu.Game.Screens.Play
         {
             leftFountain.Shoot(1);
             rightFountain.Shoot(-1);
+
+            sample?.Play();
         }
 
         public partial class GameplayStarFountain : StarFountain
diff --git a/osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs b/osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs
index 4bc559694a..0190a6f959 100644
--- a/osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs
+++ b/osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs
@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -16,6 +14,7 @@ using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -41,10 +40,10 @@ namespace osu.Game.Screens.Ranking.Expanded
 
         private readonly List<StatisticDisplay> statisticDisplays = new List<StatisticDisplay>();
 
-        private RollingCounter<long> scoreCounter;
+        private RollingCounter<long> scoreCounter = null!;
 
         [Resolved]
-        private ScoreManager scoreManager { get; set; }
+        private ScoreManager scoreManager { get; set; } = null!;
 
         /// <summary>
         /// Creates a new <see cref="ExpandedPanelMiddleContent"/>.
@@ -63,12 +62,19 @@ namespace osu.Game.Screens.Ranking.Expanded
         }
 
         [BackgroundDependencyLoader]
-        private void load(BeatmapDifficultyCache beatmapDifficultyCache)
+        private void load(RealmAccess realmAccess, BeatmapDifficultyCache beatmapDifficultyCache)
         {
             var beatmap = score.BeatmapInfo!;
             var metadata = beatmap.BeatmapSet?.Metadata ?? beatmap.Metadata;
             string creator = metadata.Author.Username;
 
+            StarDifficulty starDifficulty = new StarDifficulty(beatmap.StarRating, 0);
+
+            // In some cases, the beatmap ferried through ScoreInfo actually represents an online beatmap.
+            // If it isn't, we may be able to compute a more accurate difficulty from the ruleset and mods.
+            if (realmAccess.Run(r => r.Find<BeatmapInfo>(score.BeatmapInfo!.ID)) != null)
+                starDifficulty = beatmapDifficultyCache.GetDifficultyAsync(score.BeatmapInfo!, score.Ruleset, score.Mods).GetResultSafely() ?? starDifficulty;
+
             var topStatistics = new List<StatisticDisplay>
             {
                 new AccuracyStatistic(score.Accuracy),
@@ -146,7 +152,7 @@ namespace osu.Game.Screens.Ranking.Expanded
                                 Spacing = new Vector2(5, 0),
                                 Children = new Drawable[]
                                 {
-                                    new StarRatingDisplay(beatmapDifficultyCache.GetDifficultyAsync(beatmap, score.Ruleset, score.Mods).GetResultSafely() ?? default)
+                                    new StarRatingDisplay(starDifficulty)
                                     {
                                         Anchor = Anchor.CentreLeft,
                                         Origin = Anchor.CentreLeft
diff --git a/osu.Game/Screens/Ranking/ResultsScreen.cs b/osu.Game/Screens/Ranking/ResultsScreen.cs
index fe0d805cee..24b40968d6 100644
--- a/osu.Game/Screens/Ranking/ResultsScreen.cs
+++ b/osu.Game/Screens/Ranking/ResultsScreen.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
@@ -23,9 +24,9 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Input.Bindings;
 using osu.Game.Localisation;
-using osu.Game.Online.API;
 using osu.Game.Online.Placeholders;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Volume;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking.Expanded.Accuracy;
@@ -60,15 +61,12 @@ namespace osu.Game.Screens.Ranking
 
         private bool skipExitTransition;
 
-        [Resolved]
-        private IAPIProvider api { get; set; } = null!;
-
         protected StatisticsPanel StatisticsPanel { get; private set; } = null!;
 
         private Drawable bottomPanel = null!;
         private Container<ScorePanel> detachedPanelContainer = null!;
 
-        private bool lastFetchCompleted;
+        private Task lastFetchTask = Task.CompletedTask;
 
         /// <summary>
         /// Whether the user can retry the beatmap from the results screen.
@@ -122,6 +120,7 @@ namespace osu.Game.Screens.Ranking
                                     RelativeSizeAxes = Axes.Both,
                                     Children = new Drawable[]
                                     {
+                                        new GlobalScrollAdjustsVolume(),
                                         StatisticsPanel = createStatisticsPanel().With(panel =>
                                         {
                                             panel.RelativeSizeAxes = Axes.Both;
@@ -237,33 +236,19 @@ namespace osu.Game.Screens.Ranking
         {
             base.LoadComplete();
 
-            var req = FetchScores(fetchScoresCallback);
-
-            if (req != null)
-                api.Queue(req);
-
             StatisticsPanel.State.BindValueChanged(onStatisticsStateChanged, true);
+
+            fetchScores(null);
         }
 
         protected override void Update()
         {
             base.Update();
 
-            if (lastFetchCompleted)
-            {
-                APIRequest? nextPageRequest = null;
-
-                if (ScorePanelList.IsScrolledToStart)
-                    nextPageRequest = FetchNextPage(-1, fetchScoresCallback);
-                else if (ScorePanelList.IsScrolledToEnd)
-                    nextPageRequest = FetchNextPage(1, fetchScoresCallback);
-
-                if (nextPageRequest != null)
-                {
-                    lastFetchCompleted = false;
-                    api.Queue(nextPageRequest);
-                }
-            }
+            if (ScorePanelList.IsScrolledToStart)
+                fetchScores(-1);
+            else if (ScorePanelList.IsScrolledToEnd)
+                fetchScores(1);
         }
 
         #region Applause
@@ -327,19 +312,46 @@ namespace osu.Game.Screens.Ranking
         #endregion
 
         /// <summary>
-        /// Performs a fetch/refresh of scores to be displayed.
+        /// Fetches the next page of scores in the given direction.
         /// </summary>
-        /// <param name="scoresCallback">A callback which should be called when fetching is completed. Scheduling is not required.</param>
-        /// <returns>An <see cref="APIRequest"/> responsible for the fetch operation. This will be queued and performed automatically.</returns>
-        protected virtual APIRequest? FetchScores(Action<IEnumerable<ScoreInfo>> scoresCallback) => null;
+        /// <param name="direction">The direction, or <c>null</c> to fetch any scores.</param>
+        private void fetchScores(int? direction)
+        {
+            Debug.Assert(direction == null || direction == -1 || direction == 1);
+
+            if (!lastFetchTask.IsCompleted)
+                return;
+
+            lastFetchTask = Task.Run(async () =>
+            {
+                ScoreInfo[] scores;
+
+                switch (direction)
+                {
+                    default:
+                        scores = await FetchScores().ConfigureAwait(false);
+                        break;
+
+                    case -1:
+                    case 1:
+                        scores = await FetchNextPage(direction.Value).ConfigureAwait(false);
+                        break;
+                }
+
+                await addScores(scores).ConfigureAwait(false);
+            });
+        }
 
         /// <summary>
-        /// Performs a fetch of the next page of scores. This is invoked every frame until a non-null <see cref="APIRequest"/> is returned.
+        /// Performs a fetch/refresh of scores to be displayed.
+        /// </summary>
+        protected virtual Task<ScoreInfo[]> FetchScores() => Task.FromResult<ScoreInfo[]>([]);
+
+        /// <summary>
+        /// Performs a fetch of the next page of scores. This is invoked every frame.
         /// </summary>
         /// <param name="direction">The fetch direction. -1 to fetch scores greater than the current start of the list, and 1 to fetch scores lower than the current end of the list.</param>
-        /// <param name="scoresCallback">A callback which should be called when fetching is completed. Scheduling is not required.</param>
-        /// <returns>An <see cref="APIRequest"/> responsible for the fetch operation. This will be queued and performed automatically.</returns>
-        protected virtual APIRequest? FetchNextPage(int direction, Action<IEnumerable<ScoreInfo>> scoresCallback) => null;
+        protected virtual Task<ScoreInfo[]> FetchNextPage(int direction) => Task.FromResult<ScoreInfo[]>([]);
 
         /// <summary>
         /// Creates the <see cref="Statistics.StatisticsPanel"/> to be used to display extended information about scores.
@@ -351,20 +363,41 @@ namespace osu.Game.Screens.Ranking
                 : new StatisticsPanel();
         }
 
-        private void fetchScoresCallback(IEnumerable<ScoreInfo> scores) => Schedule(() =>
+        private Task addScores(ScoreInfo[] scores)
         {
-            foreach (var s in scores)
-                addScore(s);
+            var tcs = new TaskCompletionSource();
 
-            // allow a frame for scroll container to adjust its dimensions with the added scores before fetching again.
-            Schedule(() => lastFetchCompleted = true);
-
-            if (ScorePanelList.IsEmpty)
+            Schedule(() =>
             {
-                // This can happen if for example a beatmap that is part of a playlist hasn't been played yet.
-                VerticalScrollContent.Add(new MessagePlaceholder(LeaderboardStrings.NoRecordsYet));
-            }
-        });
+                foreach (var s in scores)
+                {
+                    var panel = ScorePanelList.AddScore(s);
+                    if (detachedPanel != null)
+                        panel.Alpha = 0;
+                }
+
+                // allow a frame for scroll container to adjust its dimensions with the added scores before fetching again.
+                Schedule(() => tcs.SetResult());
+
+                if (ScorePanelList.IsEmpty)
+                {
+                    // This can happen if for example a beatmap that is part of a playlist hasn't been played yet.
+                    VerticalScrollContent.Add(new MessagePlaceholder(LeaderboardStrings.NoRecordsYet));
+                }
+
+                OnScoresAdded(scores);
+            });
+
+            return tcs.Task;
+        }
+
+        /// <summary>
+        /// Invoked after online scores are fetched and added to the list.
+        /// </summary>
+        /// <param name="scores">The scores that were added.</param>
+        protected virtual void OnScoresAdded(ScoreInfo[] scores)
+        {
+        }
 
         public override void OnEntering(ScreenTransitionEvent e)
         {
@@ -409,14 +442,6 @@ namespace osu.Game.Screens.Ranking
             return false;
         }
 
-        private void addScore(ScoreInfo score)
-        {
-            var panel = ScorePanelList.AddScore(score);
-
-            if (detachedPanel != null)
-                panel.Alpha = 0;
-        }
-
         private ScorePanel? detachedPanel;
 
         private void onStatisticsStateChanged(ValueChangedEvent<Visibility> state)
@@ -503,12 +528,24 @@ namespace osu.Game.Screens.Ranking
         {
         }
 
+        protected override bool OnScroll(ScrollEvent e)
+        {
+            // Match stable behaviour of only alt-scroll adjusting volume.
+            // This is the same behaviour as the song selection screen.
+            if (!e.CurrentState.Keyboard.AltPressed)
+                return true;
+
+            return base.OnScroll(e);
+        }
+
         protected partial class VerticalScrollContainer : OsuScrollContainer
         {
             protected override Container<Drawable> Content => content;
 
             private readonly Container content;
 
+            protected override bool OnScroll(ScrollEvent e) => !e.ControlPressed && !e.AltPressed && !e.ShiftPressed && !e.SuperPressed;
+
             public VerticalScrollContainer()
             {
                 Masking = false;
diff --git a/osu.Game/Screens/Ranking/SoloResultsScreen.cs b/osu.Game/Screens/Ranking/SoloResultsScreen.cs
index 9f7604aa82..3486d81e8a 100644
--- a/osu.Game/Screens/Ranking/SoloResultsScreen.cs
+++ b/osu.Game/Screens/Ranking/SoloResultsScreen.cs
@@ -4,11 +4,14 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading.Tasks;
 using osu.Framework.Allocation;
+using osu.Framework.Logging;
 using osu.Game.Beatmaps;
 using osu.Game.Extensions;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
 
@@ -21,26 +24,36 @@ namespace osu.Game.Screens.Ranking
         [Resolved]
         private RulesetStore rulesets { get; set; } = null!;
 
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
         public SoloResultsScreen(ScoreInfo score)
             : base(score)
         {
         }
 
-        protected override APIRequest? FetchScores(Action<IEnumerable<ScoreInfo>> scoresCallback)
+        protected override async Task<ScoreInfo[]> FetchScores()
         {
             Debug.Assert(Score != null);
 
             if (Score.BeatmapInfo!.OnlineID <= 0 || Score.BeatmapInfo.Status <= BeatmapOnlineStatus.Pending)
-                return null;
+                return [];
+
+            var requestTaskSource = new TaskCompletionSource<APIScoresCollection>();
 
             getScoreRequest = new GetScoresRequest(Score.BeatmapInfo, Score.Ruleset);
-            getScoreRequest.Success += r =>
+            getScoreRequest.Success += requestTaskSource.SetResult;
+            getScoreRequest.Failure += requestTaskSource.SetException;
+            api.Queue(getScoreRequest);
+
+            try
             {
+                var scores = await requestTaskSource.Task.ConfigureAwait(false);
                 var toDisplay = new List<ScoreInfo>();
 
-                for (int i = 0; i < r.Scores.Count; ++i)
+                for (int i = 0; i < scores.Scores.Count; ++i)
                 {
-                    var score = r.Scores[i];
+                    var score = scores.Scores[i];
                     int position = i + 1;
 
                     if (score.MatchesOnlineID(Score))
@@ -58,9 +71,13 @@ namespace osu.Game.Screens.Ranking
                     }
                 }
 
-                scoresCallback.Invoke(toDisplay);
-            };
-            return getScoreRequest;
+                return toDisplay.ToArray();
+            }
+            catch (Exception ex)
+            {
+                Logger.Log($"Failed to fetch scores (beatmap: {Score.BeatmapInfo}, ruleset: {Score.Ruleset}): {ex}");
+                return [];
+            }
         }
 
         protected override void Dispose(bool isDisposing)
diff --git a/osu.Game/Screens/Ranking/UserTag.cs b/osu.Game/Screens/Ranking/UserTag.cs
new file mode 100644
index 0000000000..d44e531330
--- /dev/null
+++ b/osu.Game/Screens/Ranking/UserTag.cs
@@ -0,0 +1,25 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Screens.Ranking
+{
+    public record UserTag
+    {
+        public long Id { get; }
+        public string Name { get; }
+        public string Description { get; }
+
+        public BindableInt VoteCount { get; } = new BindableInt();
+        public BindableBool Voted { get; } = new BindableBool();
+
+        public UserTag(APITag tag)
+        {
+            Id = tag.Id;
+            Name = tag.Name;
+            Description = tag.Description;
+        }
+    }
+}
diff --git a/osu.Game/Screens/Ranking/UserTagControl.cs b/osu.Game/Screens/Ranking/UserTagControl.cs
new file mode 100644
index 0000000000..7600d0aaae
--- /dev/null
+++ b/osu.Game/Screens/Ranking/UserTagControl.cs
@@ -0,0 +1,576 @@
+// 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.Specialized;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Caching;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Extensions;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Screens.Ranking
+{
+    public partial class UserTagControl : CompositeDrawable
+    {
+        public override bool HandlePositionalInput => true;
+
+        private readonly Cached layout = new Cached();
+
+        private FillFlowContainer<DrawableUserTag> tagFlow = null!;
+        private LoadingLayer loadingLayer = null!;
+
+        private BindableList<UserTag> displayedTags { get; } = new BindableList<UserTag>();
+        private BindableList<UserTag> extraTags { get; } = new BindableList<UserTag>();
+
+        private Bindable<APITag[]?> allTags = null!;
+        private readonly Bindable<APIBeatmap?> apiBeatmap = new Bindable<APIBeatmap?>();
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        [Resolved]
+        private Bindable<WorkingBeatmap> beatmap { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(SessionStatics sessionStatics)
+        {
+            AutoSizeAxes = Axes.Y;
+            InternalChildren = new Drawable[]
+            {
+                new FillFlowContainer
+                {
+                    Direction = FillDirection.Vertical,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Spacing = new Vector2(8),
+                    Children = new Drawable[]
+                    {
+                        tagFlow = new FillFlowContainer<DrawableUserTag>
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Full,
+                            LayoutDuration = 300,
+                            LayoutEasing = Easing.OutQuint,
+                            Spacing = new Vector2(4),
+                        },
+                        new AddTagsButton
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                            OnTagSelected = onExtraTagSelected,
+                            AvailableTags = { BindTarget = extraTags },
+                        },
+                    },
+                },
+                loadingLayer = new LoadingLayer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    State = { Value = Visibility.Visible }
+                },
+            };
+
+            allTags = sessionStatics.GetBindable<APITag[]?>(Static.AllBeatmapTags);
+
+            if (allTags.Value == null)
+            {
+                var listTagsRequest = new ListTagsRequest();
+                listTagsRequest.Success += tags => allTags.Value = tags.Tags.ToArray();
+                api.Queue(listTagsRequest);
+            }
+
+            var getBeatmapSetRequest = new GetBeatmapSetRequest(beatmap.Value.BeatmapInfo.BeatmapSet!.OnlineID);
+            getBeatmapSetRequest.Success += set => apiBeatmap.Value = set.Beatmaps.SingleOrDefault(b => b.MatchesOnlineID(beatmap.Value.BeatmapInfo));
+            api.Queue(getBeatmapSetRequest);
+        }
+
+        private void onExtraTagSelected(UserTag tag)
+        {
+            loadingLayer.Show();
+            extraTags.Remove(tag);
+
+            var req = new AddBeatmapTagRequest(beatmap.Value.BeatmapInfo.OnlineID, tag.Id);
+            req.Success += () =>
+            {
+                tag.Voted.Value = true;
+                tag.VoteCount.Value += 1;
+                displayedTags.Add(tag);
+                loadingLayer.Hide();
+            };
+            req.Failure += _ => extraTags.Add(tag);
+            api.Queue(req);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            allTags.BindValueChanged(_ => updateTags());
+            apiBeatmap.BindValueChanged(_ => updateTags());
+            updateTags();
+
+            displayedTags.BindCollectionChanged(displayTags, true);
+        }
+
+        private void updateTags()
+        {
+            if (allTags.Value == null || apiBeatmap.Value?.TopTags == null)
+                return;
+
+            var allTagsById = allTags.Value.ToDictionary(t => t.Id);
+            var ownTagIds = apiBeatmap.Value.OwnTagIds?.ToHashSet() ?? new HashSet<long>();
+
+            foreach (var topTag in apiBeatmap.Value.TopTags)
+            {
+                if (allTagsById.Remove(topTag.TagId, out var tag))
+                {
+                    displayedTags.Add(new UserTag(tag)
+                    {
+                        VoteCount = { Value = topTag.VoteCount },
+                        Voted = { Value = ownTagIds.Contains(tag.Id) }
+                    });
+                }
+            }
+
+            extraTags.AddRange(allTagsById.Select(t => new UserTag(t.Value)));
+
+            loadingLayer.Hide();
+        }
+
+        private void displayTags(object? sender, NotifyCollectionChangedEventArgs e)
+        {
+            var oldItems = tagFlow.ToArray();
+
+            switch (e.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                {
+                    for (int i = 0; i < e.NewItems!.Count; i++)
+                    {
+                        var tag = (UserTag)e.NewItems[i]!;
+                        var drawableTag = new DrawableUserTag(tag);
+                        tagFlow.Insert(tagFlow.Count, drawableTag);
+                        tag.VoteCount.BindValueChanged(voteCountChanged, true);
+                        layout.Invalidate();
+                    }
+
+                    break;
+                }
+
+                case NotifyCollectionChangedAction.Remove:
+                {
+                    for (int i = 0; i < e.OldItems!.Count; i++)
+                    {
+                        var tag = (UserTag)e.OldItems[i]!;
+                        tag.VoteCount.ValueChanged -= voteCountChanged;
+                        tagFlow.Remove(oldItems[e.OldStartingIndex + i], true);
+                    }
+
+                    break;
+                }
+
+                case NotifyCollectionChangedAction.Reset:
+                {
+                    tagFlow.Clear();
+                    break;
+                }
+            }
+        }
+
+        private void voteCountChanged(ValueChangedEvent<int> _)
+        {
+            var tagsWithNoVotes = displayedTags.Where(t => t.VoteCount.Value == 0).ToArray();
+
+            foreach (var tag in tagsWithNoVotes)
+            {
+                displayedTags.Remove(tag);
+                extraTags.Add(tag);
+            }
+
+            layout.Invalidate();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (!layout.IsValid && !IsHovered)
+            {
+                var sortedTags = new Dictionary<UserTag, int>(
+                    displayedTags.OrderByDescending(t => t.VoteCount.Value)
+                                 .ThenByDescending(t => t.Voted.Value)
+                                 .Select((tag, index) => new KeyValuePair<UserTag, int>(tag, index)));
+
+                foreach (var drawableTag in tagFlow)
+                    tagFlow.SetLayoutPosition(drawableTag, sortedTags[drawableTag.UserTag]);
+
+                layout.Validate();
+            }
+        }
+
+        private partial class DrawableUserTag : OsuAnimatedButton
+        {
+            public readonly UserTag UserTag;
+
+            private readonly Bindable<int> voteCount = new Bindable<int>();
+            private readonly BindableBool voted = new BindableBool();
+            private readonly Bindable<bool> confirmed = new BindableBool();
+
+            private Box mainBackground = null!;
+            private Box voteBackground = null!;
+            private OsuSpriteText tagNameText = null!;
+            private OsuSpriteText voteCountText = null!;
+            private LoadingSpinner spinner = null!;
+
+            [Resolved]
+            private OsuColour colours { get; set; } = null!;
+
+            [Resolved]
+            private Bindable<WorkingBeatmap> beatmap { get; set; } = null!;
+
+            [Resolved]
+            private IAPIProvider api { get; set; } = null!;
+
+            private APIRequest? requestInFlight;
+
+            public DrawableUserTag(UserTag userTag)
+            {
+                UserTag = userTag;
+                voteCount.BindTo(userTag.VoteCount);
+                voted.BindTo(userTag.Voted);
+
+                AutoSizeAxes = Axes.Both;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+                CornerRadius = 8;
+                Masking = true;
+                EdgeEffect = new EdgeEffectParameters
+                {
+                    Colour = colours.Lime1,
+                    Radius = 5,
+                    Type = EdgeEffectType.Glow,
+                };
+                Content.AddRange(new Drawable[]
+                {
+                    mainBackground = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Depth = float.MaxValue,
+                    },
+                    new FillFlowContainer
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Direction = FillDirection.Horizontal,
+                        Padding = new MarginPadding { Left = 6, Right = 3, Vertical = 3, },
+                        Spacing = new Vector2(5),
+                        Children = new Drawable[]
+                        {
+                            tagNameText = new OsuSpriteText
+                            {
+                                Text = UserTag.Name,
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                            },
+                            new Container
+                            {
+                                AutoSizeAxes = Axes.Both,
+                                CornerRadius = 5,
+                                Masking = true,
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                Children = new Drawable[]
+                                {
+                                    voteBackground = new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                    },
+                                    voteCountText = new OsuSpriteText
+                                    {
+                                        Margin = new MarginPadding { Horizontal = 6, Vertical = 3, },
+                                    },
+                                    spinner = new LoadingSpinner(withBox: true)
+                                    {
+                                        Alpha = 0,
+                                        Size = new Vector2(18),
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+
+                TooltipText = UserTag.Description;
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                const double transition_duration = 300;
+
+                voteCount.BindValueChanged(_ =>
+                {
+                    voteCountText.Text = voteCount.Value.ToLocalisableString();
+                    confirmed.Value = voteCount.Value >= 10;
+                }, true);
+                voted.BindValueChanged(v =>
+                {
+                    if (v.NewValue)
+                    {
+                        voteBackground.FadeColour(colours.Lime3, transition_duration, Easing.OutQuint);
+                        voteCountText.FadeColour(Colour4.Black, transition_duration, Easing.OutQuint);
+                    }
+                    else
+                    {
+                        voteBackground.FadeColour(colours.Gray2, transition_duration, Easing.OutQuint);
+                        voteCountText.FadeColour(Colour4.White, transition_duration, Easing.OutQuint);
+                    }
+                }, true);
+                confirmed.BindValueChanged(c =>
+                {
+                    if (c.NewValue)
+                    {
+                        mainBackground.FadeColour(colours.Lime1, transition_duration, Easing.OutQuint);
+                        tagNameText.FadeColour(Colour4.Black, transition_duration, Easing.OutQuint);
+                        FadeEdgeEffectTo(0.5f, transition_duration, Easing.OutQuint);
+                    }
+                    else
+                    {
+                        mainBackground.FadeColour(colours.Gray4, transition_duration, Easing.OutQuint);
+                        tagNameText.FadeColour(Colour4.White, transition_duration, Easing.OutQuint);
+                        FadeEdgeEffectTo(0f, transition_duration, Easing.OutQuint);
+                    }
+                }, true);
+                FinishTransforms(true);
+
+                Action = () =>
+                {
+                    if (requestInFlight != null)
+                        return;
+
+                    spinner.Show();
+
+                    APIRequest request;
+
+                    switch (voted.Value)
+                    {
+                        case true:
+                            var removeReq = new RemoveBeatmapTagRequest(beatmap.Value.BeatmapInfo.OnlineID, UserTag.Id);
+                            removeReq.Success += () =>
+                            {
+                                voteCount.Value -= 1;
+                                voted.Value = false;
+                            };
+                            request = removeReq;
+                            break;
+
+                        case false:
+                            var addReq = new AddBeatmapTagRequest(beatmap.Value.BeatmapInfo.OnlineID, UserTag.Id);
+                            addReq.Success += () =>
+                            {
+                                voteCount.Value += 1;
+                                voted.Value = true;
+                            };
+                            request = addReq;
+                            break;
+                    }
+
+                    request.Success += () =>
+                    {
+                        spinner.Hide();
+                        requestInFlight = null;
+                    };
+                    request.Failure += _ =>
+                    {
+                        spinner.Hide();
+                        requestInFlight = null;
+                    };
+                    api.Queue(requestInFlight = request);
+                };
+            }
+        }
+
+        private partial class AddTagsButton : GrayButton, IHasPopover
+        {
+            public BindableList<UserTag> AvailableTags { get; } = new BindableList<UserTag>();
+
+            public Action<UserTag>? OnTagSelected { get; set; }
+
+            public AddTagsButton()
+                : base(FontAwesome.Solid.Plus)
+            {
+                Size = new Vector2(30);
+
+                Action = this.ShowPopover;
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                AvailableTags.BindCollectionChanged((_, _) => Enabled.Value = AvailableTags.Count > 0, true);
+            }
+
+            public Popover GetPopover() => new AddTagsPopover
+            {
+                AvailableTags = { BindTarget = AvailableTags },
+                OnSelected = OnTagSelected,
+            };
+        }
+
+        private partial class AddTagsPopover : OsuPopover
+        {
+            private SearchTextBox searchBox = null!;
+            private SearchContainer searchContainer = null!;
+
+            public BindableList<UserTag> AvailableTags { get; } = new BindableList<UserTag>();
+
+            public Action<UserTag>? OnSelected { get; set; }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Child = new OsuScrollContainer
+                {
+                    Width = 250,
+                    Height = 250,
+                    ScrollbarOverlapsContent = false,
+                    Children = new Drawable[]
+                    {
+                        searchBox = new SearchTextBox
+                        {
+                            HoldFocus = true,
+                            RelativeSizeAxes = Axes.X,
+                        },
+                        searchContainer = new SearchContainer
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Vertical,
+                            Padding = new MarginPadding { Right = 5, Top = 50, },
+                            Spacing = new Vector2(10),
+                            ChildrenEnumerable = AvailableTags.Select(tag => new DrawableAddableTag(tag)
+                            {
+                                Action = () => select(tag)
+                            })
+                        }
+                    },
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                searchBox.Current.BindValueChanged(_ => searchContainer.SearchTerm = searchBox.Current.Value, true);
+            }
+
+            protected override bool OnKeyDown(KeyDownEvent e)
+            {
+                var visibleItems = searchContainer.OfType<DrawableAddableTag>().Where(d => d.IsPresent).ToArray();
+
+                if (e.Key == Key.Enter)
+                {
+                    if (visibleItems.Length == 1)
+                        select(visibleItems.Single().Tag);
+
+                    return true;
+                }
+
+                return base.OnKeyDown(e);
+            }
+
+            private void select(UserTag tag)
+            {
+                OnSelected?.Invoke(tag);
+                this.HidePopover();
+            }
+
+            private partial class DrawableAddableTag : OsuAnimatedButton, IFilterable
+            {
+                public readonly UserTag Tag;
+
+                public DrawableAddableTag(UserTag tag)
+                {
+                    Tag = tag;
+
+                    RelativeSizeAxes = Axes.X;
+                    AutoSizeAxes = Axes.Y;
+                    Anchor = Origin = Anchor.Centre;
+                }
+
+                [BackgroundDependencyLoader]
+                private void load(OsuColour colours)
+                {
+                    Content.AddRange(new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = colours.GreySeaFoamDark,
+                            Depth = float.MaxValue,
+                        },
+                        new FillFlowContainer
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Vertical,
+                            Spacing = new Vector2(2),
+                            Padding = new MarginPadding(5),
+                            Children = new Drawable[]
+                            {
+                                new OsuTextFlowContainer(t => t.Font = OsuFont.Default.With(weight: FontWeight.Bold))
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Text = Tag.Name,
+                                },
+                                new OsuTextFlowContainer(t => t.Font = OsuFont.Default.With(size: 14))
+                                {
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Text = Tag.Description,
+                                }
+                            }
+                        }
+                    });
+                }
+
+                public IEnumerable<LocalisableString> FilterTerms => [Tag.Name, Tag.Description];
+
+                public bool MatchingFilter { set => Alpha = value ? 1 : 0; }
+                public bool FilteringActive { set { } }
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/Select/SongSelect.cs b/osu.Game/Screens/Select/SongSelect.cs
index c20dcb8593..1496eb96f9 100644
--- a/osu.Game/Screens/Select/SongSelect.cs
+++ b/osu.Game/Screens/Select/SongSelect.cs
@@ -426,7 +426,10 @@ namespace osu.Game.Screens.Select
             (beatmapOptionsButton = new FooterButtonOptions(), BeatmapOptions)
         };
 
-        protected virtual ModSelectOverlay CreateModSelectOverlay() => new SoloModSelectOverlay();
+        protected virtual ModSelectOverlay CreateModSelectOverlay() => new UserModSelectOverlay
+        {
+            ShowPresets = true,
+        };
 
         private DependencyContainer dependencies = null!;
 
@@ -1152,10 +1155,5 @@ namespace osu.Game.Screens.Select
                 return base.OnHover(e);
             }
         }
-
-        internal partial class SoloModSelectOverlay : UserModSelectOverlay
-        {
-            protected override bool ShowPresets => true;
-        }
     }
 }
diff --git a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
index c6bce228dc..1c1f6fa7fb 100644
--- a/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapCarousel.cs
@@ -10,6 +10,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Pooling;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Graphics.UserInterface;
@@ -20,6 +21,8 @@ namespace osu.Game.Screens.SelectV2
     [Cached]
     public partial class BeatmapCarousel : Carousel<BeatmapInfo>
     {
+        public Action<BeatmapInfo>? RequestPresentBeatmap { private get; init; }
+
         public const float SPACING = 5f;
 
         private IBindableList<BeatmapSetInfo> detachedBeatmaps = null!;
@@ -128,6 +131,12 @@ namespace osu.Game.Screens.SelectV2
                     return;
 
                 case BeatmapInfo beatmapInfo:
+                    if (ReferenceEquals(CurrentSelection, beatmapInfo))
+                    {
+                        RequestPresentBeatmap?.Invoke(beatmapInfo);
+                        return;
+                    }
+
                     CurrentSelection = beatmapInfo;
                     return;
             }
@@ -252,6 +261,29 @@ namespace osu.Game.Screens.SelectV2
 
         #endregion
 
+        #region Animation
+
+        /// <summary>
+        /// Moves non-selected beatmaps to the right, hiding off-screen.
+        /// </summary>
+        public bool VisuallyFocusSelected { get; set; }
+
+        private float selectionFocusOffset;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            selectionFocusOffset = (float)Interpolation.DampContinuously(selectionFocusOffset, VisuallyFocusSelected ? 300 : 0, 100, Time.Elapsed);
+        }
+
+        protected override float GetPanelXOffset(Drawable panel)
+        {
+            return base.GetPanelXOffset(panel) + (((ICarouselPanel)panel).Selected.Value ? 0 : selectionFocusOffset);
+        }
+
+        #endregion
+
         #region Filtering
 
         public FilterCriteria Criteria { get; private set; } = new FilterCriteria();
diff --git a/osu.Game/Screens/SelectV2/BeatmapSetPanelBackground.cs b/osu.Game/Screens/SelectV2/BeatmapSetPanelBackground.cs
index 435a0ad262..798acf62ee 100644
--- a/osu.Game/Screens/SelectV2/BeatmapSetPanelBackground.cs
+++ b/osu.Game/Screens/SelectV2/BeatmapSetPanelBackground.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Screens.SelectV2
 {
     public partial class BeatmapSetPanelBackground : ModelBackedDrawable<WorkingBeatmap>
     {
-        protected override bool TransformImmediately => true;
+        protected override double TransformDuration => 400;
 
         public WorkingBeatmap? Beatmap
         {
diff --git a/osu.Game/Screens/SelectV2/Carousel.cs b/osu.Game/Screens/SelectV2/Carousel.cs
index e50281e713..5339b5358b 100644
--- a/osu.Game/Screens/SelectV2/Carousel.cs
+++ b/osu.Game/Screens/SelectV2/Carousel.cs
@@ -75,7 +75,7 @@ namespace osu.Game.Screens.SelectV2
         /// <summary>
         /// The number of items currently actualised into drawables.
         /// </summary>
-        public int VisibleItems => scroll.Panels.Count;
+        public int VisibleItems => Scroll.Panels.Count;
 
         /// <summary>
         /// The currently selected model. Generally of type T.
@@ -185,7 +185,7 @@ namespace osu.Game.Screens.SelectV2
         /// <param name="item">The item to find a related drawable representation.</param>
         /// <returns>The drawable representation if it exists.</returns>
         protected Drawable? GetMaterialisedDrawableForItem(CarouselItem item) =>
-            scroll.Panels.SingleOrDefault(p => ((ICarouselPanel)p).Item == item);
+            Scroll.Panels.SingleOrDefault(p => ((ICarouselPanel)p).Item == item);
 
         /// <summary>
         /// When a user is traversing the carousel via group selection keys, assert whether the item provided is a valid target.
@@ -222,11 +222,11 @@ namespace osu.Game.Screens.SelectV2
 
         #region Initialisation
 
-        private readonly CarouselScrollContainer scroll;
+        protected readonly CarouselScrollContainer Scroll;
 
         protected Carousel()
         {
-            InternalChild = scroll = new CarouselScrollContainer
+            InternalChild = Scroll = new CarouselScrollContainer
             {
                 RelativeSizeAxes = Axes.Both,
             };
@@ -499,13 +499,13 @@ namespace osu.Game.Screens.SelectV2
             // If a keyboard selection is currently made, we want to keep the view stable around the selection.
             // That means that we should offset the immediate scroll position by any change in Y position for the selection.
             if (prevKeyboard.YPosition != null && currentKeyboardSelection.YPosition != prevKeyboard.YPosition)
-                scroll.OffsetScrollPosition((float)(currentKeyboardSelection.YPosition!.Value - prevKeyboard.YPosition.Value));
+                Scroll.OffsetScrollPosition((float)(currentKeyboardSelection.YPosition!.Value - prevKeyboard.YPosition.Value));
         }
 
         private void scrollToSelection()
         {
             if (currentKeyboardSelection.CarouselItem != null)
-                scroll.ScrollTo(currentKeyboardSelection.CarouselItem.CarouselYPosition - visibleHalfHeight);
+                Scroll.ScrollTo(currentKeyboardSelection.CarouselItem.CarouselYPosition - visibleHalfHeight);
         }
 
         #endregion
@@ -519,12 +519,12 @@ namespace osu.Game.Screens.SelectV2
         /// <summary>
         /// The position of the lower visible bound with respect to the current scroll position.
         /// </summary>
-        private float visibleBottomBound => (float)(scroll.Current + DrawHeight + BleedBottom);
+        private float visibleBottomBound => (float)(Scroll.Current + DrawHeight + BleedBottom);
 
         /// <summary>
         /// The position of the upper visible bound with respect to the current scroll position.
         /// </summary>
-        private float visibleUpperBound => (float)(scroll.Current - BleedTop);
+        private float visibleUpperBound => (float)(Scroll.Current - BleedTop);
 
         /// <summary>
         /// Half the height of the visible content.
@@ -557,7 +557,7 @@ namespace osu.Game.Screens.SelectV2
 
             double selectedYPos = currentSelection.CarouselItem?.CarouselYPosition ?? 0;
 
-            foreach (var panel in scroll.Panels)
+            foreach (var panel in Scroll.Panels)
             {
                 var c = (ICarouselPanel)panel;
 
@@ -566,15 +566,12 @@ namespace osu.Game.Screens.SelectV2
                     continue;
 
                 float normalisedDepth = (float)(Math.Abs(selectedYPos - c.DrawYPosition) / DrawHeight);
-                scroll.Panels.ChangeChildDepth(panel, c.Item.DepthLayer + normalisedDepth);
+                Scroll.Panels.ChangeChildDepth(panel, c.Item.DepthLayer + normalisedDepth);
 
                 if (c.DrawYPosition != c.Item.CarouselYPosition)
                     c.DrawYPosition = Interpolation.DampContinuously(c.DrawYPosition, c.Item.CarouselYPosition, 50, Time.Elapsed);
 
-                Vector2 posInScroll = scroll.ToLocalSpace(panel.ScreenSpaceDrawQuad.Centre);
-                float dist = Math.Abs(1f - posInScroll.Y / visibleHalfHeight);
-
-                panel.X = offsetX(dist, visibleHalfHeight);
+                panel.X = GetPanelXOffset(panel);
 
                 c.Selected.Value = c.Item == currentSelection?.CarouselItem;
                 c.KeyboardSelected.Value = c.Item == currentKeyboardSelection?.CarouselItem;
@@ -582,6 +579,14 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
+        protected virtual float GetPanelXOffset(Drawable panel)
+        {
+            Vector2 posInScroll = Scroll.ToLocalSpace(panel.ScreenSpaceDrawQuad.Centre);
+            float dist = Math.Abs(1f - posInScroll.Y / visibleHalfHeight);
+
+            return offsetX(dist, visibleHalfHeight);
+        }
+
         /// <summary>
         /// Computes the x-offset of currently visible items. Makes the carousel appear round.
         /// </summary>
@@ -628,7 +633,7 @@ namespace osu.Game.Screens.SelectV2
             toDisplay.RemoveAll(i => !i.IsVisible);
 
             // Iterate over all panels which are already displayed and figure which need to be displayed / removed.
-            foreach (var panel in scroll.Panels)
+            foreach (var panel in Scroll.Panels)
             {
                 var carouselPanel = (ICarouselPanel)panel;
 
@@ -658,7 +663,7 @@ namespace osu.Game.Screens.SelectV2
                 carouselPanel.DrawYPosition = item.CarouselYPosition;
                 carouselPanel.Item = item;
 
-                scroll.Add(drawable);
+                Scroll.Add(drawable);
             }
 
             // Update the total height of all items (to make the scroll container scrollable through the full height even though
@@ -666,10 +671,10 @@ namespace osu.Game.Screens.SelectV2
             if (carouselItems.Count > 0)
             {
                 var lastItem = carouselItems[^1];
-                scroll.SetLayoutHeight((float)(lastItem.CarouselYPosition + lastItem.DrawHeight + visibleHalfHeight));
+                Scroll.SetLayoutHeight((float)(lastItem.CarouselYPosition + lastItem.DrawHeight + visibleHalfHeight));
             }
             else
-                scroll.SetLayoutHeight(0);
+                Scroll.SetLayoutHeight(0);
         }
 
         private static void expirePanelImmediately(Drawable panel)
@@ -713,7 +718,7 @@ namespace osu.Game.Screens.SelectV2
         /// Implementation of scroll container which handles very large vertical lists by internally using <c>double</c> precision
         /// for pre-display Y values.
         /// </summary>
-        private partial class CarouselScrollContainer : UserTrackingScrollContainer, IKeyBindingHandler<GlobalAction>
+        protected partial class CarouselScrollContainer : UserTrackingScrollContainer, IKeyBindingHandler<GlobalAction>
         {
             public readonly Container Panels;
 
diff --git a/osu.Game/Screens/SelectV2/Leaderboards/LeaderboardScoreV2.cs b/osu.Game/Screens/SelectV2/Leaderboards/LeaderboardScoreV2.cs
index 978d6eca32..b54f007f38 100644
--- a/osu.Game/Screens/SelectV2/Leaderboards/LeaderboardScoreV2.cs
+++ b/osu.Game/Screens/SelectV2/Leaderboards/LeaderboardScoreV2.cs
@@ -780,8 +780,11 @@ namespace osu.Game.Screens.SelectV2.Leaderboards
             {
                 List<MenuItem> items = new List<MenuItem>();
 
-                if (score.Mods.Length > 0)
-                    items.Add(new OsuMenuItem("Use these mods", MenuItemType.Highlighted, () => SelectedMods.Value = score.Mods.Where(m => IsValidMod.Invoke(m)).ToArray()));
+                // system mods should never be copied across regardless of anything.
+                var copyableMods = score.Mods.Where(m => IsValidMod.Invoke(m) && m.Type != ModType.System).ToArray();
+
+                if (copyableMods.Length > 0)
+                    items.Add(new OsuMenuItem("Use these mods", MenuItemType.Highlighted, () => SelectedMods.Value = copyableMods));
 
                 if (score.OnlineID > 0)
                     items.Add(new OsuMenuItem(CommonStrings.CopyLink, MenuItemType.Standard, () => clipboard?.SetText($@"{api.Endpoints.WebsiteUrl}/scores/{score.OnlineID}")));
diff --git a/osu.Game/Screens/SelectV2/PanelBase.cs b/osu.Game/Screens/SelectV2/PanelBase.cs
index 805cbac8eb..05a1a55c03 100644
--- a/osu.Game/Screens/SelectV2/PanelBase.cs
+++ b/osu.Game/Screens/SelectV2/PanelBase.cs
@@ -23,23 +23,22 @@ namespace osu.Game.Screens.SelectV2
     {
         private const float corner_radius = 10;
 
-        private const float left_edge_x_offset = 20f;
-        private const float keyboard_active_x_offset = 25f;
         private const float active_x_offset = 50f;
 
-        private const float duration = 500;
+        protected const float DURATION = 400;
 
         protected float PanelXOffset { get; init; }
 
         private Box backgroundBorder = null!;
         private Box backgroundGradient = null!;
         private Box backgroundAccentGradient = null!;
-        private Container backgroundLayer = null!;
         private Container backgroundLayerHorizontalPadding = null!;
         private Container backgroundContainer = null!;
         private Container iconContainer = null!;
         private Box activationFlash = null!;
         private Box hoverLayer = null!;
+        private Box keyboardSelectionLayer = null!;
+        private Box selectionLayer = null!;
 
         public Container TopLevelContent { get; private set; } = null!;
 
@@ -61,6 +60,14 @@ namespace osu.Game.Screens.SelectV2
             }
         }
 
+        // content is offset by PanelXOffset, make sure we only handle input at the actual visible
+        // offset region.
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) =>
+            TopLevelContent.ReceivePositionalInputAt(screenSpacePos);
+
+        [Resolved]
+        private BeatmapCarousel? carousel { get; set; }
+
         [BackgroundDependencyLoader]
         private void load(OverlayColourProvider colourProvider, OsuColour colours)
         {
@@ -97,30 +104,26 @@ namespace osu.Game.Screens.SelectV2
                             backgroundLayerHorizontalPadding = new Container
                             {
                                 RelativeSizeAxes = Axes.Both,
-                                Child = backgroundLayer = new Container
+                                Child = new Container
                                 {
                                     RelativeSizeAxes = Axes.Both,
-                                    Child = new Container
+                                    Masking = true,
+                                    CornerRadius = corner_radius,
+                                    Children = new Drawable[]
                                     {
-                                        Masking = true,
-                                        CornerRadius = corner_radius,
-                                        RelativeSizeAxes = Axes.Both,
-                                        Children = new Drawable[]
+                                        backgroundGradient = new Box
                                         {
-                                            backgroundGradient = new Box
-                                            {
-                                                RelativeSizeAxes = Axes.Both,
-                                            },
-                                            backgroundAccentGradient = new Box
-                                            {
-                                                RelativeSizeAxes = Axes.Both,
-                                            },
-                                            backgroundContainer = new Container
-                                            {
-                                                RelativeSizeAxes = Axes.Both,
-                                            },
-                                        }
-                                    },
+                                            RelativeSizeAxes = Axes.Both,
+                                        },
+                                        backgroundAccentGradient = new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                        },
+                                        backgroundContainer = new Container
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                        },
+                                    }
                                 },
                             }
                         },
@@ -139,6 +142,24 @@ namespace osu.Game.Screens.SelectV2
                     hoverLayer = new Box
                     {
                         Alpha = 0,
+                        Colour = colours.Blue.Opacity(0.1f),
+                        Blending = BlendingParameters.Additive,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    selectionLayer = new Box
+                    {
+                        Alpha = 0,
+                        Colour = ColourInfo.GradientHorizontal(colours.Yellow.Opacity(0), colours.Yellow.Opacity(0.5f)),
+                        Blending = BlendingParameters.Additive,
+                        RelativeSizeAxes = Axes.Both,
+                        Width = 0.7f,
+                        Anchor = Anchor.TopRight,
+                        Origin = Anchor.TopRight,
+                    },
+                    keyboardSelectionLayer = new Box
+                    {
+                        Alpha = 0,
+                        Colour = colours.Yellow.Opacity(0.1f),
                         Blending = BlendingParameters.Additive,
                         RelativeSizeAxes = Axes.Both,
                     },
@@ -153,7 +174,6 @@ namespace osu.Game.Screens.SelectV2
                 }
             };
 
-            hoverLayer.Colour = colours.Blue.Opacity(0.1f);
             backgroundGradient.Colour = ColourInfo.GradientHorizontal(colourProvider.Background3, colourProvider.Background4);
         }
 
@@ -161,37 +181,50 @@ namespace osu.Game.Screens.SelectV2
         {
             base.LoadComplete();
 
-            Expanded.BindValueChanged(_ => updateDisplay());
-            KeyboardSelected.BindValueChanged(_ => updateDisplay(), true);
+            Expanded.BindValueChanged(_ => updateDisplay(), true);
+
+            Selected.BindValueChanged(selected =>
+            {
+                if (selected.NewValue)
+                    selectionLayer.FadeIn(100, Easing.OutQuint);
+                else
+                    selectionLayer.FadeOut(200, Easing.OutQuint);
+
+                updateXOffset();
+            }, true);
+
+            KeyboardSelected.BindValueChanged(selected =>
+            {
+                if (selected.NewValue)
+                    keyboardSelectionLayer.FadeIn(100, Easing.OutQuint);
+                else
+                    keyboardSelectionLayer.FadeOut(1000, Easing.OutQuint);
+
+                updateXOffset();
+            }, true);
         }
 
         protected override void PrepareForUse()
         {
             base.PrepareForUse();
-            this.FadeInFromZero(duration, Easing.OutQuint);
+            this.FadeInFromZero(DURATION, Easing.OutQuint);
         }
 
-        [Resolved]
-        private BeatmapCarousel? carousel { get; set; }
-
         protected override bool OnClick(ClickEvent e)
         {
-            activationFlash.FadeOutFromOne(500, Easing.OutQuint);
             carousel?.Activate(Item!);
             return true;
         }
 
         private void updateDisplay()
         {
-            backgroundLayer.TransformTo(nameof(Padding), backgroundLayer.Padding with { Vertical = Expanded.Value ? 2f : 0f }, duration, Easing.OutQuint);
-
             var backgroundColour = accentColour ?? Color4.White;
             var edgeEffectColour = accentColour ?? Color4Extensions.FromHex(@"4EBFFF");
 
-            backgroundAccentGradient.FadeColour(ColourInfo.GradientHorizontal(backgroundColour.Opacity(0.25f), backgroundColour.Opacity(0f)), duration, Easing.OutQuint);
-            backgroundBorder.FadeColour(backgroundColour, duration, Easing.OutQuint);
+            backgroundAccentGradient.FadeColour(ColourInfo.GradientHorizontal(backgroundColour.Opacity(0.25f), backgroundColour.Opacity(0f)), DURATION, Easing.OutQuint);
+            backgroundBorder.FadeColour(backgroundColour, DURATION, Easing.OutQuint);
 
-            TopLevelContent.FadeEdgeEffectTo(Expanded.Value ? edgeEffectColour.Opacity(0.5f) : Color4.Black.Opacity(0.4f), duration, Easing.OutQuint);
+            TopLevelContent.FadeEdgeEffectTo(Expanded.Value ? edgeEffectColour.Opacity(0.5f) : Color4.Black.Opacity(0.4f), DURATION, Easing.OutQuint);
 
             updateXOffset();
             updateHover();
@@ -199,22 +232,20 @@ namespace osu.Game.Screens.SelectV2
 
         private void updateXOffset()
         {
-            float x = PanelXOffset + active_x_offset + keyboard_active_x_offset + left_edge_x_offset;
+            float x = PanelXOffset + corner_radius;
 
-            if (Expanded.Value)
-                x -= active_x_offset;
+            if (!Expanded.Value && !Selected.Value)
+                x += active_x_offset;
 
-            if (KeyboardSelected.Value)
-                x -= keyboard_active_x_offset;
+            if (!KeyboardSelected.Value)
+                x += active_x_offset * 0.5f;
 
-            this.TransformTo(nameof(Padding), new MarginPadding { Left = x }, duration, Easing.OutQuint);
+            TopLevelContent.MoveToX(x, DURATION, Easing.OutQuint);
         }
 
         private void updateHover()
         {
-            bool hovered = IsHovered || KeyboardSelected.Value;
-
-            if (hovered)
+            if (IsHovered)
                 hoverLayer.FadeIn(100, Easing.OutQuint);
             else
                 hoverLayer.FadeOut(1000, Easing.OutQuint);
@@ -222,13 +253,13 @@ namespace osu.Game.Screens.SelectV2
 
         protected override bool OnHover(HoverEvent e)
         {
-            updateDisplay();
+            updateHover();
             return true;
         }
 
         protected override void OnHoverLost(HoverLostEvent e)
         {
-            updateDisplay();
+            updateHover();
             base.OnHoverLost(e);
         }
 
@@ -250,7 +281,7 @@ namespace osu.Game.Screens.SelectV2
 
         public virtual void Activated()
         {
-            activationFlash.FadeOutFromOne(500, Easing.OutQuint);
+            activationFlash.FadeOutFromOne(1000, Easing.OutQuint);
         }
 
         #endregion
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmap.cs b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
index b27e5cae14..d4bf3519fa 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmap.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmap.cs
@@ -54,7 +54,7 @@ namespace osu.Game.Screens.SelectV2
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos)
         {
-            var inputRectangle = DrawRectangle;
+            var inputRectangle = TopLevelContent.DrawRectangle;
 
             // Cover the gaps introduced by the spacing between BeatmapPanels so that clicks will not fall through the carousel.
             //
@@ -62,7 +62,7 @@ namespace osu.Game.Screens.SelectV2
             // larger hit target.
             inputRectangle = inputRectangle.Inflate(new MarginPadding { Vertical = BeatmapCarousel.SPACING });
 
-            return inputRectangle.Contains(ToLocalSpace(screenSpacePos));
+            return inputRectangle.Contains(TopLevelContent.ToLocalSpace(screenSpacePos));
         }
 
         [BackgroundDependencyLoader]
@@ -163,8 +163,6 @@ namespace osu.Game.Screens.SelectV2
                 computeStarRating();
                 updateKeyCount();
             }, true);
-
-            Selected.BindValueChanged(s => Expanded.Value = s.NewValue, true);
         }
 
         protected override void PrepareForUse()
diff --git a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
index 5c38fe8e04..512fbacec1 100644
--- a/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
+++ b/osu.Game/Screens/SelectV2/PanelBeatmapSet.cs
@@ -48,7 +48,7 @@ namespace osu.Game.Screens.SelectV2
 
             Icon = chevronIcon = new Container
             {
-                Size = new Vector2(22),
+                Size = new Vector2(0, 22),
                 Child = new SpriteIcon
                 {
                     Anchor = Anchor.Centre,
@@ -128,10 +128,16 @@ namespace osu.Game.Screens.SelectV2
 
         private void onExpanded()
         {
-            const float duration = 500;
-
-            chevronIcon.ResizeWidthTo(Expanded.Value ? 22 : 0f, duration, Easing.OutQuint);
-            chevronIcon.FadeTo(Expanded.Value ? 1f : 0f, duration, Easing.OutQuint);
+            if (Expanded.Value)
+            {
+                chevronIcon.ResizeWidthTo(18, 600, Easing.OutElasticQuarter);
+                chevronIcon.FadeTo(1f, DURATION, Easing.OutQuint);
+            }
+            else
+            {
+                chevronIcon.ResizeWidthTo(0f, DURATION, Easing.OutQuint);
+                chevronIcon.FadeTo(0f, DURATION, Easing.OutQuint);
+            }
         }
 
         protected override void PrepareForUse()
diff --git a/osu.Game/Screens/SelectV2/SoloSongSelect.cs b/osu.Game/Screens/SelectV2/SoloSongSelect.cs
new file mode 100644
index 0000000000..e6ecdc6705
--- /dev/null
+++ b/osu.Game/Screens/SelectV2/SoloSongSelect.cs
@@ -0,0 +1,28 @@
+// 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.Screens;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Screens.SelectV2
+{
+    public partial class SoloSongSelect : SongSelect
+    {
+        protected override bool OnStart()
+        {
+            this.Push(new PlayerLoaderV2(() => new SoloPlayer()));
+            return false;
+        }
+
+        private partial class PlayerLoaderV2 : PlayerLoader
+        {
+            public override bool ShowFooter => true;
+
+            public PlayerLoaderV2(Func<Player> createPlayer)
+                : base(createPlayer)
+            {
+            }
+        }
+    }
+}
diff --git a/osu.Game/Screens/SelectV2/SongSelectV2.cs b/osu.Game/Screens/SelectV2/SongSelect.cs
similarity index 64%
rename from osu.Game/Screens/SelectV2/SongSelectV2.cs
rename to osu.Game/Screens/SelectV2/SongSelect.cs
index 3943d059f9..ad29f846c4 100644
--- a/osu.Game/Screens/SelectV2/SongSelectV2.cs
+++ b/osu.Game/Screens/SelectV2/SongSelect.cs
@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -11,7 +10,7 @@ using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Screens.Footer;
 using osu.Game.Screens.Menu;
-using osu.Game.Screens.Play;
+using osu.Game.Screens.Select;
 using osu.Game.Screens.SelectV2.Footer;
 
 namespace osu.Game.Screens.SelectV2
@@ -20,15 +19,20 @@ namespace osu.Game.Screens.SelectV2
     /// This screen is intended to house all components introduced in the new song select design to add transitions and examine the overall look.
     /// This will be gradually built upon and ultimately replace <see cref="Select.SongSelect"/> once everything is in place.
     /// </summary>
-    public partial class SongSelectV2 : OsuScreen
+    public abstract partial class SongSelect : OsuScreen
     {
         private const float logo_scale = 0.4f;
 
-        private readonly ModSelectOverlay modSelectOverlay = new SoloModSelectOverlay();
+        private readonly ModSelectOverlay modSelectOverlay = new ModSelectOverlay
+        {
+            ShowPresets = true,
+        };
 
         [Cached]
         private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Aquamarine);
 
+        private BeatmapCarousel carousel = null!;
+
         public override bool ShowFooter => true;
 
         [Resolved]
@@ -39,17 +43,33 @@ namespace osu.Game.Screens.SelectV2
         {
             AddRangeInternal(new Drawable[]
             {
-                new Container
+                new GridContainer // used for max width implementation
                 {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
                     RelativeSizeAxes = Axes.Both,
-                    Padding = new MarginPadding { Bottom = ScreenFooter.HEIGHT },
-                    Child = new BeatmapCarousel
+                    ColumnDimensions = new[]
                     {
-                        Anchor = Anchor.TopRight,
-                        Origin = Anchor.TopRight,
-                        RelativeSizeAxes = Axes.Both,
-                        Width = 0.6f,
+                        new Dimension(),
+                        new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 750),
                     },
+                    Content = new[]
+                    {
+                        new[]
+                        {
+                            Empty(),
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding { Bottom = ScreenFooter.HEIGHT },
+                                Child = carousel = new BeatmapCarousel
+                                {
+                                    RequestPresentBeatmap = _ => OnStart(),
+                                    RelativeSizeAxes = Axes.Both
+                                },
+                            },
+                        }
+                    }
                 },
                 modSelectOverlay,
             });
@@ -82,9 +102,13 @@ namespace osu.Game.Screens.SelectV2
             base.OnEntering(e);
         }
 
+        private const double fade_duration = 300;
+
         public override void OnResuming(ScreenTransitionEvent e)
         {
-            this.FadeIn();
+            this.FadeIn(fade_duration, Easing.OutQuint);
+
+            carousel.VisuallyFocusSelected = false;
 
             // required due to https://github.com/ppy/osu-framework/issues/3218
             modSelectOverlay.SelectedMods.Disabled = false;
@@ -95,16 +119,18 @@ namespace osu.Game.Screens.SelectV2
 
         public override void OnSuspending(ScreenTransitionEvent e)
         {
-            this.Delay(400).FadeOut();
+            this.Delay(100).FadeOut(fade_duration, Easing.OutQuint);
 
             modSelectOverlay.SelectedMods.UnbindFrom(Mods);
 
+            carousel.VisuallyFocusSelected = true;
+
             base.OnSuspending(e);
         }
 
         public override bool OnExiting(ScreenExitEvent e)
         {
-            this.Delay(400).FadeOut();
+            this.FadeOut(fade_duration, Easing.OutQuint);
             return base.OnExiting(e);
         }
 
@@ -126,11 +152,17 @@ namespace osu.Game.Screens.SelectV2
 
             logo.Action = () =>
             {
-                this.Push(new PlayerLoaderV2(() => new SoloPlayer()));
+                OnStart();
                 return false;
             };
         }
 
+        /// <summary>
+        /// Called when a selection is made.
+        /// </summary>
+        /// <returns>If a resultant action occurred that takes the user away from SongSelect.</returns>
+        protected abstract bool OnStart();
+
         protected override void LogoSuspending(OsuLogo logo)
         {
             base.LogoSuspending(logo);
@@ -145,19 +177,17 @@ namespace osu.Game.Screens.SelectV2
             logo.FadeOut(120, Easing.Out);
         }
 
-        private partial class SoloModSelectOverlay : UserModSelectOverlay
+        /// <summary>
+        /// Set the query to the search text box.
+        /// </summary>
+        /// <param name="query">The string to search.</param>
+        public void Search(string query)
         {
-            protected override bool ShowPresets => true;
-        }
-
-        private partial class PlayerLoaderV2 : PlayerLoader
-        {
-            public override bool ShowFooter => true;
-
-            public PlayerLoaderV2(Func<Player> createPlayer)
-                : base(createPlayer)
+            carousel.Filter(new FilterCriteria
             {
-            }
+                // TODO: this should only set the text of the current criteria, not use a completely new criteria.
+                SearchText = query,
+            });
         }
     }
 }
diff --git a/osu.Game/Screens/Utility/CircleGameplay.cs b/osu.Game/Screens/Utility/CircleGameplay.cs
index 1f970c5121..0f328d04fb 100644
--- a/osu.Game/Screens/Utility/CircleGameplay.cs
+++ b/osu.Game/Screens/Utility/CircleGameplay.cs
@@ -201,8 +201,8 @@ namespace osu.Game.Screens.Utility
                 {
                     double preempt = (float)IBeatmapDifficultyInfo.DifficultyRange(SampleApproachRate.Value, 1800, 1200, 450);
 
-                    approach.Scale = new Vector2(1 + 4 * (float)MathHelper.Clamp((HitTime - Clock.CurrentTime) / preempt, 0, 100));
-                    Alpha = (float)MathHelper.Clamp((Clock.CurrentTime - HitTime + 600) / 400, 0, 1);
+                    approach.Scale = new Vector2(1 + 4 * (float)Math.Clamp((HitTime - Clock.CurrentTime) / preempt, 0, 100));
+                    Alpha = (float)Math.Clamp((Clock.CurrentTime - HitTime + 600) / 400, 0, 1);
 
                     if (Clock.CurrentTime > HitTime + duration)
                         Expire();
diff --git a/osu.Game/Screens/Utility/SampleComponents/LatencyMovableBox.cs b/osu.Game/Screens/Utility/SampleComponents/LatencyMovableBox.cs
index dcfcf602bf..ef1b848945 100644
--- a/osu.Game/Screens/Utility/SampleComponents/LatencyMovableBox.cs
+++ b/osu.Game/Screens/Utility/SampleComponents/LatencyMovableBox.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 osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
@@ -55,22 +56,22 @@ namespace osu.Game.Screens.Utility.SampleComponents
                     {
                         case Key.F:
                         case Key.Up:
-                            box.Y = MathHelper.Clamp(box.Y - movementAmount, 0.1f, 0.9f);
+                            box.Y = Math.Clamp(box.Y - movementAmount, 0.1f, 0.9f);
                             break;
 
                         case Key.J:
                         case Key.Down:
-                            box.Y = MathHelper.Clamp(box.Y + movementAmount, 0.1f, 0.9f);
+                            box.Y = Math.Clamp(box.Y + movementAmount, 0.1f, 0.9f);
                             break;
 
                         case Key.Z:
                         case Key.Left:
-                            box.X = MathHelper.Clamp(box.X - movementAmount, 0.1f, 0.9f);
+                            box.X = Math.Clamp(box.X - movementAmount, 0.1f, 0.9f);
                             break;
 
                         case Key.X:
                         case Key.Right:
-                            box.X = MathHelper.Clamp(box.X + movementAmount, 0.1f, 0.9f);
+                            box.X = Math.Clamp(box.X + movementAmount, 0.1f, 0.9f);
                             break;
                     }
                 }
diff --git a/osu.Game/Screens/Utility/ScrollingGameplay.cs b/osu.Game/Screens/Utility/ScrollingGameplay.cs
index 5038c53b4a..c0264f5734 100644
--- a/osu.Game/Screens/Utility/ScrollingGameplay.cs
+++ b/osu.Game/Screens/Utility/ScrollingGameplay.cs
@@ -165,7 +165,7 @@ namespace osu.Game.Screens.Utility
                 {
                     double preempt = (float)IBeatmapDifficultyInfo.DifficultyRange(SampleApproachRate.Value, 1800, 1200, 450);
 
-                    Alpha = (float)MathHelper.Clamp((Clock.CurrentTime - HitTime + 600) / 400, 0, 1);
+                    Alpha = (float)Math.Clamp((Clock.CurrentTime - HitTime + 600) / 400, 0, 1);
                     Y = judgement_position - (float)((HitTime - Clock.CurrentTime) / preempt);
 
                     if (Clock.CurrentTime > HitTime + duration)
diff --git a/osu.Game/Skinning/LegacyManiaSkinConfiguration.cs b/osu.Game/Skinning/LegacyManiaSkinConfiguration.cs
index db1f216b6e..1e6fa44e68 100644
--- a/osu.Game/Skinning/LegacyManiaSkinConfiguration.cs
+++ b/osu.Game/Skinning/LegacyManiaSkinConfiguration.cs
@@ -41,6 +41,7 @@ namespace osu.Game.Skinning
         public float LightPosition = (480 - 413) * POSITION_SCALE_FACTOR;
         public float ComboPosition = 111 * POSITION_SCALE_FACTOR;
         public float ScorePosition = 300 * POSITION_SCALE_FACTOR;
+        public float BarLineHeight = 1;
         public bool ShowJudgementLine = true;
         public bool KeysUnderNotes;
         public int LightFramePerSecond = 60;
diff --git a/osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs b/osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs
index ee354de68b..e94fb23681 100644
--- a/osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs
+++ b/osu.Game/Skinning/LegacyManiaSkinConfigurationLookup.cs
@@ -70,6 +70,9 @@ namespace osu.Game.Skinning
         RightStageImage,
         BottomStageImage,
 
+        BarLineHeight,
+        BarLineColour,
+
         // ReSharper disable once InconsistentNaming
         Hit300g,
 
diff --git a/osu.Game/Skinning/LegacyManiaSkinDecoder.cs b/osu.Game/Skinning/LegacyManiaSkinDecoder.cs
index 09866ef237..2739743387 100644
--- a/osu.Game/Skinning/LegacyManiaSkinDecoder.cs
+++ b/osu.Game/Skinning/LegacyManiaSkinDecoder.cs
@@ -86,6 +86,10 @@ namespace osu.Game.Skinning
                         parseArrayValue(pair.Value, currentConfig.ColumnWidth);
                         break;
 
+                    case "BarlineHeight":
+                        currentConfig.BarLineHeight = float.Parse(pair.Value, CultureInfo.InvariantCulture);
+                        break;
+
                     case "HitPosition":
                         currentConfig.HitPosition = (480 - Math.Clamp(float.Parse(pair.Value, CultureInfo.InvariantCulture), 240, 480)) * LegacyManiaSkinConfiguration.POSITION_SCALE_FACTOR;
                         break;
diff --git a/osu.Game/Skinning/LegacySkin.cs b/osu.Game/Skinning/LegacySkin.cs
index 08fa068830..51c1473303 100644
--- a/osu.Game/Skinning/LegacySkin.cs
+++ b/osu.Game/Skinning/LegacySkin.cs
@@ -198,9 +198,15 @@ namespace osu.Game.Skinning
                 case LegacyManiaSkinConfigurationLookups.ComboBreakColour:
                     return SkinUtils.As<TValue>(getCustomColour(existing, "ColourBreak"));
 
+                case LegacyManiaSkinConfigurationLookups.BarLineColour:
+                    return SkinUtils.As<TValue>(getCustomColour(existing, "ColourBarline"));
+
                 case LegacyManiaSkinConfigurationLookups.MinimumColumnWidth:
                     return SkinUtils.As<TValue>(new Bindable<float>(existing.MinimumColumnWidth));
 
+                case LegacyManiaSkinConfigurationLookups.BarLineHeight:
+                    return SkinUtils.As<TValue>(new Bindable<float>(existing.BarLineHeight));
+
                 case LegacyManiaSkinConfigurationLookups.NoteBodyStyle:
 
                     if (existing.NoteBodyStyle != null)
diff --git a/osu.Game/Skinning/TrianglesSkin.cs b/osu.Game/Skinning/TrianglesSkin.cs
index 06fe1c80ee..a4a967bed9 100644
--- a/osu.Game/Skinning/TrianglesSkin.cs
+++ b/osu.Game/Skinning/TrianglesSkin.cs
@@ -158,7 +158,7 @@ namespace osu.Game.Skinning
 
                                 if (spectatorList != null)
                                 {
-                                    spectatorList.Font.Value = Typeface.Venera;
+                                    spectatorList.HeaderFont.Value = Typeface.Venera;
                                     spectatorList.HeaderColour.Value = new OsuColour().BlueLighter;
                                     spectatorList.Anchor = Anchor.BottomLeft;
                                     spectatorList.Origin = Anchor.BottomLeft;
diff --git a/osu.Game/Tests/Visual/Gameplay/ScoringTestScene.cs b/osu.Game/Tests/Visual/Gameplay/ScoringTestScene.cs
index 6908f7f1b4..21d0b8e7a8 100644
--- a/osu.Game/Tests/Visual/Gameplay/ScoringTestScene.cs
+++ b/osu.Game/Tests/Visual/Gameplay/ScoringTestScene.cs
@@ -658,11 +658,10 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private partial class TestModSelectOverlay : UserModSelectOverlay
         {
-            protected override bool ShowPresets => false;
-
             public TestModSelectOverlay()
                 : base(OverlayColourScheme.Aquamarine)
             {
+                ShowPresets = false;
             }
         }
     }
diff --git a/osu.Game/Tests/Visual/Multiplayer/IMultiplayerTestSceneDependencies.cs b/osu.Game/Tests/Visual/Multiplayer/IMultiplayerTestSceneDependencies.cs
index efd0b80ebf..262816ae89 100644
--- a/osu.Game/Tests/Visual/Multiplayer/IMultiplayerTestSceneDependencies.cs
+++ b/osu.Game/Tests/Visual/Multiplayer/IMultiplayerTestSceneDependencies.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.Game.Screens.OnlinePlay;
 using osu.Game.Tests.Visual.OnlinePlay;
 using osu.Game.Tests.Visual.Spectator;
 
@@ -17,11 +16,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
         /// </summary>
         TestMultiplayerClient MultiplayerClient { get; }
 
-        /// <summary>
-        /// The cached <see cref="IRoomManager"/>.
-        /// </summary>
-        new TestMultiplayerRoomManager RoomManager { get; }
-
         /// <summary>
         /// The cached <see cref="osu.Game.Online.Spectator.SpectatorClient"/>.
         /// </summary>
diff --git a/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestScene.cs b/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestScene.cs
index 42cf317829..ac587d3bb2 100644
--- a/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestScene.cs
+++ b/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestScene.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 osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Visual.OnlinePlay;
@@ -17,21 +18,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
         public const int PLAYER_2_ID = 56;
 
         public TestMultiplayerClient MultiplayerClient => OnlinePlayDependencies.MultiplayerClient;
-        public new TestMultiplayerRoomManager RoomManager => OnlinePlayDependencies.RoomManager;
         public TestSpectatorClient SpectatorClient => OnlinePlayDependencies.SpectatorClient;
 
         protected new MultiplayerTestSceneDependencies OnlinePlayDependencies => (MultiplayerTestSceneDependencies)base.OnlinePlayDependencies;
 
         public bool RoomJoined => MultiplayerClient.RoomJoined;
 
-        private readonly bool joinRoom;
-
-        protected MultiplayerTestScene(bool joinRoom = true)
-        {
-            this.joinRoom = joinRoom;
-        }
-
-        protected virtual Room CreateRoom()
+        protected Room CreateDefaultRoom()
         {
             return new Room
             {
@@ -47,21 +40,12 @@ namespace osu.Game.Tests.Visual.Multiplayer
             };
         }
 
-        public override void SetUpSteps()
-        {
-            base.SetUpSteps();
+        /// <summary>
+        /// Creates and joins a basic multiplayer room.
+        /// </summary>
+        protected void JoinRoom(Room room) => MultiplayerClient.CreateRoom(room).FireAndForget();
 
-            if (joinRoom)
-            {
-                AddStep("join room", () =>
-                {
-                    SelectedRoom.Value = CreateRoom();
-                    RoomManager.CreateRoom(SelectedRoom.Value);
-                });
-
-                AddUntilStep("wait for room join", () => RoomJoined);
-            }
-        }
+        protected void WaitForJoined() => AddUntilStep("wait for room join", () => RoomJoined);
 
         protected override OnlinePlayTestSceneDependencies CreateOnlinePlayDependencies() => new MultiplayerTestSceneDependencies();
     }
diff --git a/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestSceneDependencies.cs b/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestSceneDependencies.cs
index 88202d4327..24c33f2f49 100644
--- a/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestSceneDependencies.cs
+++ b/osu.Game/Tests/Visual/Multiplayer/MultiplayerTestSceneDependencies.cs
@@ -3,7 +3,6 @@
 
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Spectator;
-using osu.Game.Screens.OnlinePlay;
 using osu.Game.Tests.Visual.OnlinePlay;
 using osu.Game.Tests.Visual.Spectator;
 
@@ -16,19 +15,16 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         public TestMultiplayerClient MultiplayerClient { get; }
         public TestSpectatorClient SpectatorClient { get; }
-        public new TestMultiplayerRoomManager RoomManager => (TestMultiplayerRoomManager)base.RoomManager;
 
         public MultiplayerTestSceneDependencies()
         {
-            MultiplayerClient = new TestMultiplayerClient(RoomManager);
+            MultiplayerClient = new TestMultiplayerClient(RequestsHandler);
             SpectatorClient = CreateSpectatorClient();
 
             CacheAs<MultiplayerClient>(MultiplayerClient);
             CacheAs<SpectatorClient>(SpectatorClient);
         }
 
-        protected override IRoomManager CreateRoomManager() => new TestMultiplayerRoomManager(RequestsHandler);
-
         protected virtual TestSpectatorClient CreateSpectatorClient() => new TestSpectatorClient();
     }
 }
diff --git a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
index 3abef523cd..cc9a82c1ba 100644
--- a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
+++ b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
@@ -10,6 +10,7 @@ using MessagePack;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
+using osu.Game.Beatmaps;
 using osu.Game.Online;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
@@ -17,6 +18,7 @@ using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Tests.Visual.OnlinePlay;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -65,15 +67,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Resolved]
         private IAPIProvider api { get; set; } = null!;
 
-        private readonly TestMultiplayerRoomManager roomManager;
-
         private MultiplayerPlaylistItem? currentItem => ServerRoom?.Playlist[currentIndex];
         private int currentIndex;
         private long lastPlaylistItemId;
 
-        public TestMultiplayerClient(TestMultiplayerRoomManager roomManager)
+        private readonly TestRoomRequestsHandler apiRequestHandler;
+
+        public TestMultiplayerClient(TestRoomRequestsHandler? apiRequestHandler = null)
         {
-            this.roomManager = roomManager;
+            this.apiRequestHandler = apiRequestHandler ?? new TestRoomRequestsHandler();
         }
 
         public void Connect() => isConnected.Value = true;
@@ -206,7 +208,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             ((IMultiplayerClient)this).UserBeatmapAvailabilityChanged(clone(userId), clone(user.BeatmapAvailability));
         }
 
-        protected override async Task<MultiplayerRoom> JoinRoom(long roomId, string? password = null)
+        protected override async Task<MultiplayerRoom> JoinRoomInternal(long roomId, string? password = null)
         {
             if (RoomJoined || ServerAPIRoom != null)
                 throw new InvalidOperationException("Already joined a room");
@@ -214,7 +216,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             roomId = clone(roomId);
             password = clone(password);
 
-            ServerAPIRoom = roomManager.ServerSideRooms.Single(r => r.RoomID == roomId);
+            ServerAPIRoom = ServerSideRooms.Single(r => r.RoomID == roomId);
 
             if (password != ServerAPIRoom.Password)
                 throw new InvalidOperationException("Invalid password.");
@@ -500,6 +502,19 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         public override Task RemovePlaylistItem(long playlistItemId) => RemoveUserPlaylistItem(api.LocalUser.Value.OnlineID, clone(playlistItemId));
 
+        protected override Task<MultiplayerRoom> CreateRoomInternal(MultiplayerRoom room)
+        {
+            Room apiRoom = new Room(room)
+            {
+                Type = room.Settings.MatchType == MatchType.Playlists
+                    ? MatchType.HeadToHead
+                    : room.Settings.MatchType
+            };
+
+            AddServerSideRoom(apiRoom, api.LocalUser.Value);
+            return JoinRoomInternal(apiRoom.RoomID!.Value, room.Settings.Password);
+        }
+
         private async Task changeMatchType(MatchType type)
         {
             Debug.Assert(ServerRoom != null);
@@ -692,5 +707,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
             isConnected.Value = false;
             return Task.CompletedTask;
         }
+
+        #region API Room Handling
+
+        public IReadOnlyList<Room> ServerSideRooms
+            => apiRequestHandler.ServerSideRooms;
+
+        public void AddServerSideRoom(Room room, APIUser host)
+            => apiRequestHandler.AddServerSideRoom(room, host);
+
+        public bool HandleRequest(APIRequest request, APIUser localUser, BeatmapManager beatmapManager)
+            => apiRequestHandler.HandleRequest(request, localUser, beatmapManager);
+
+        #endregion
     }
 }
diff --git a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerRoomManager.cs b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerRoomManager.cs
deleted file mode 100644
index b998a638e5..0000000000
--- a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerRoomManager.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using System.Collections.Generic;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Online.Rooms;
-using osu.Game.Screens.OnlinePlay.Components;
-using osu.Game.Screens.OnlinePlay.Multiplayer;
-using osu.Game.Tests.Visual.OnlinePlay;
-
-namespace osu.Game.Tests.Visual.Multiplayer
-{
-    /// <summary>
-    /// A <see cref="RoomManager"/> for use in multiplayer test scenes.
-    /// Should generally not be used by itself outside of a <see cref="MultiplayerTestScene"/>.
-    /// </summary>
-    public partial class TestMultiplayerRoomManager : MultiplayerRoomManager
-    {
-        private readonly TestRoomRequestsHandler requestsHandler;
-
-        public TestMultiplayerRoomManager(TestRoomRequestsHandler requestsHandler)
-        {
-            this.requestsHandler = requestsHandler;
-        }
-
-        public IReadOnlyList<Room> ServerSideRooms => requestsHandler.ServerSideRooms;
-
-        public override void CreateRoom(Room room, Action<Room>? onSuccess = null, Action<string>? onError = null)
-            => base.CreateRoom(room, r => onSuccess?.Invoke(r), onError);
-
-        public override void JoinRoom(Room room, string? password = null, Action<Room>? onSuccess = null, Action<string>? onError = null)
-            => base.JoinRoom(room, password, r => onSuccess?.Invoke(r), onError);
-
-        /// <summary>
-        /// Adds a room to a local "server-side" list that's returned when a <see cref="GetRoomsRequest"/> is fired.
-        /// </summary>
-        /// <param name="room">The room.</param>
-        /// <param name="host">The host.</param>
-        public void AddServerSideRoom(Room room, APIUser host) => requestsHandler.AddServerSideRoom(room, host);
-    }
-}
diff --git a/osu.Game/Tests/Visual/OnlinePlay/IOnlinePlayTestSceneDependencies.cs b/osu.Game/Tests/Visual/OnlinePlay/IOnlinePlayTestSceneDependencies.cs
index 8ddc5325db..60730ee9a4 100644
--- a/osu.Game/Tests/Visual/OnlinePlay/IOnlinePlayTestSceneDependencies.cs
+++ b/osu.Game/Tests/Visual/OnlinePlay/IOnlinePlayTestSceneDependencies.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.Bindables;
 using osu.Game.Database;
 using osu.Game.Online.Rooms;
 using osu.Game.Screens.OnlinePlay;
@@ -13,16 +12,6 @@ namespace osu.Game.Tests.Visual.OnlinePlay
     /// </summary>
     public interface IOnlinePlayTestSceneDependencies
     {
-        /// <summary>
-        /// The cached <see cref="Room"/>.
-        /// </summary>
-        Bindable<Room?> SelectedRoom { get; }
-
-        /// <summary>
-        /// The cached <see cref="IRoomManager"/>
-        /// </summary>
-        IRoomManager RoomManager { get; }
-
         /// <summary>
         /// The cached <see cref="OngoingOperationTracker"/>.
         /// </summary>
diff --git a/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs b/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs
index 3f6c175fbd..ce8df36590 100644
--- a/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs
+++ b/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestScene.cs
@@ -3,14 +3,15 @@
 
 using System;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
 using osu.Game.Screens.OnlinePlay;
 
 namespace osu.Game.Tests.Visual.OnlinePlay
@@ -20,8 +21,6 @@ namespace osu.Game.Tests.Visual.OnlinePlay
     /// </summary>
     public abstract partial class OnlinePlayTestScene : ScreenTestScene, IOnlinePlayTestSceneDependencies
     {
-        public Bindable<Room?> SelectedRoom => OnlinePlayDependencies.SelectedRoom;
-        public IRoomManager RoomManager => OnlinePlayDependencies.RoomManager;
         public OngoingOperationTracker OngoingOperationTracker => OnlinePlayDependencies.OngoingOperationTracker;
         public OnlinePlayBeatmapAvailabilityTracker AvailabilityTracker => OnlinePlayDependencies.AvailabilityTracker;
         public TestUserLookupCache UserLookupCache => OnlinePlayDependencies.UserLookupCache;
@@ -34,9 +33,13 @@ namespace osu.Game.Tests.Visual.OnlinePlay
 
         protected override Container<Drawable> Content => content;
 
+        [Resolved]
+        private RulesetStore rulesets { get; set; } = null!;
+
         private readonly Container content;
         private readonly Container drawableDependenciesContainer;
         private DelegatedDependencyContainer dependencies = null!;
+        private int currentRoomId;
 
         protected OnlinePlayTestScene()
         {
@@ -93,6 +96,31 @@ 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)
+        {
+            Room[] rooms = new Room[count];
+
+            // Can't reference Osu ruleset project here.
+            ruleset ??= rulesets.GetRuleset(0)!;
+
+            for (int i = 0; i < count; i++)
+            {
+                rooms[i] = new Room
+                {
+                    RoomID = currentRoomId++,
+                    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 }]
+                };
+            }
+
+            return rooms;
+        }
+
         /// <summary>
         /// A <see cref="IReadOnlyDependencyContainer"/> providing a mutable lookup source for online play dependencies.
         /// </summary>
diff --git a/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestSceneDependencies.cs b/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestSceneDependencies.cs
index e2670c9ad8..9537c7958c 100644
--- a/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestSceneDependencies.cs
+++ b/osu.Game/Tests/Visual/OnlinePlay/OnlinePlayTestSceneDependencies.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Database;
 using osu.Game.Online.Rooms;
@@ -18,8 +17,6 @@ namespace osu.Game.Tests.Visual.OnlinePlay
     /// </summary>
     public class OnlinePlayTestSceneDependencies : IReadOnlyDependencyContainer, IOnlinePlayTestSceneDependencies
     {
-        public Bindable<Room?> SelectedRoom { get; }
-        public IRoomManager RoomManager { get; }
         public OngoingOperationTracker OngoingOperationTracker { get; }
         public OnlinePlayBeatmapAvailabilityTracker AvailabilityTracker { get; }
         public TestRoomRequestsHandler RequestsHandler { get; }
@@ -36,19 +33,15 @@ namespace osu.Game.Tests.Visual.OnlinePlay
 
         public OnlinePlayTestSceneDependencies()
         {
-            SelectedRoom = new Bindable<Room?>();
             RequestsHandler = new TestRoomRequestsHandler();
             OngoingOperationTracker = new OngoingOperationTracker();
             AvailabilityTracker = new OnlinePlayBeatmapAvailabilityTracker();
-            RoomManager = CreateRoomManager();
             UserLookupCache = new TestUserLookupCache();
             BeatmapLookupCache = new BeatmapLookupCache();
 
             dependencies = new DependencyContainer();
 
             CacheAs(RequestsHandler);
-            CacheAs(SelectedRoom);
-            CacheAs(RoomManager);
             CacheAs(OngoingOperationTracker);
             CacheAs(AvailabilityTracker);
             CacheAs(new OverlayColourProvider(OverlayColourScheme.Plum));
@@ -80,7 +73,5 @@ namespace osu.Game.Tests.Visual.OnlinePlay
             if (instance is Drawable drawable)
                 drawableComponents.Add(drawable);
         }
-
-        protected virtual IRoomManager CreateRoomManager() => new TestRoomManager();
     }
 }
diff --git a/osu.Game/Tests/Visual/OnlinePlay/TestRoomManager.cs b/osu.Game/Tests/Visual/OnlinePlay/TestRoomManager.cs
deleted file mode 100644
index b1e3eafacc..0000000000
--- a/osu.Game/Tests/Visual/OnlinePlay/TestRoomManager.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-using osu.Game.Beatmaps;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Online.Rooms;
-using osu.Game.Rulesets;
-using osu.Game.Screens.OnlinePlay.Components;
-
-namespace osu.Game.Tests.Visual.OnlinePlay
-{
-    /// <summary>
-    /// A very simple <see cref="RoomManager"/> for use in online play test scenes.
-    /// </summary>
-    public partial class TestRoomManager : RoomManager
-    {
-        public Action<Room, string?>? JoinRoomRequested;
-
-        private int currentRoomId;
-
-        public override void JoinRoom(Room room, string? password = null, Action<Room>? onSuccess = null, Action<string>? onError = null)
-        {
-            JoinRoomRequested?.Invoke(room, password);
-            base.JoinRoom(room, password, onSuccess, onError);
-        }
-
-        public void AddRooms(int count, RulesetInfo? ruleset = null, bool withPassword = false, bool withSpotlightRooms = false)
-        {
-            for (int i = 0; i < count; i++)
-            {
-                AddRoom(new Room
-                {
-                    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 = ruleset == null
-                        ? null
-                        : new Room.RoomPlaylistItemStats { RulesetIDs = [ruleset.OnlineID] },
-                    Playlist = ruleset == null
-                        ? Array.Empty<PlaylistItem>()
-                        : [new PlaylistItem(new BeatmapInfo { Metadata = new BeatmapMetadata() }) { RulesetID = ruleset.OnlineID }]
-                });
-            }
-        }
-
-        public void AddRoom(Room room)
-        {
-            room.RoomID = -currentRoomId;
-            CreateRoom(room);
-            currentRoomId++;
-        }
-    }
-}
diff --git a/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs b/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs
index 3e3fe03329..46c1251d42 100644
--- a/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs
+++ b/osu.Game/Tests/Visual/OnlinePlay/TestRoomRequestsHandler.cs
@@ -16,7 +16,6 @@ using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
-using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Utils;
 
@@ -29,7 +28,6 @@ namespace osu.Game.Tests.Visual.OnlinePlay
     public class TestRoomRequestsHandler
     {
         public IReadOnlyList<Room> ServerSideRooms => serverSideRooms;
-
         private readonly List<Room> serverSideRooms = new List<Room>();
 
         private int currentRoomId = 1;
@@ -37,8 +35,7 @@ namespace osu.Game.Tests.Visual.OnlinePlay
         private int currentScoreId = 1;
 
         /// <summary>
-        /// Handles an API request, while also updating the local state to match
-        /// how the server would eventually respond and update an <see cref="RoomManager"/>.
+        /// Handles an API request, while also updating the local state to match how the server would eventually respond.
         /// </summary>
         /// <param name="request">The API request to handle.</param>
         /// <param name="localUser">The local user to store in responses where required.</param>
@@ -129,6 +126,7 @@ namespace osu.Game.Tests.Visual.OnlinePlay
                                 MaxCombo = 100,
                                 TotalScore = 200000,
                                 User = new APIUser { Username = "worst user" },
+                                Mods = [new APIMod { Acronym = @"TD" }],
                                 Statistics = new Dictionary<HitResult, int>()
                             },
                         },
diff --git a/osu.Game/Tests/Visual/PlacementBlueprintTestScene.cs b/osu.Game/Tests/Visual/PlacementBlueprintTestScene.cs
index baf614d1c8..a644936a16 100644
--- a/osu.Game/Tests/Visual/PlacementBlueprintTestScene.cs
+++ b/osu.Game/Tests/Visual/PlacementBlueprintTestScene.cs
@@ -51,7 +51,9 @@ namespace osu.Game.Tests.Visual
 
         protected virtual IBeatmap GetPlayableBeatmap()
         {
-            var playable = Beatmap.Value.GetPlayableBeatmap(Beatmap.Value.BeatmapInfo.Ruleset);
+            var rulesetInfo = CreateRuleset()!.RulesetInfo;
+            var playable = Beatmap.Value.GetPlayableBeatmap(rulesetInfo);
+            playable.BeatmapInfo.Ruleset = rulesetInfo;
             playable.Difficulty.CircleSize = 2;
             return playable;
         }
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index 8104906d1a..5b1310f7c3 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.220.1" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2025.217.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2025.311.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2025.307.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 5ca49e80f6..8045009621 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.220.1" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2025.311.0" />
   </ItemGroup>
 </Project>