diff --git a/osu.Game.Benchmarks/BenchmarkUnstableRate.cs b/osu.Game.Benchmarks/BenchmarkUnstableRate.cs
index aa229c7d06..4d3023e92e 100644
--- a/osu.Game.Benchmarks/BenchmarkUnstableRate.cs
+++ b/osu.Game.Benchmarks/BenchmarkUnstableRate.cs
@@ -4,28 +4,54 @@
 using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using osu.Framework.Utils;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Benchmarks
 {
     public class BenchmarkUnstableRate : BenchmarkTest
     {
-        private List<HitEvent> events = null!;
+        private readonly List<List<HitEvent>> incrementalEventLists = new List<List<HitEvent>>();
 
         public override void SetUp()
         {
             base.SetUp();
-            events = new List<HitEvent>();
 
-            for (int i = 0; i < 1000; i++)
-                events.Add(new HitEvent(RNG.NextDouble(-200.0, 200.0), RNG.NextDouble(1.0, 2.0), HitResult.Great, new HitObject(), null, null));
+            var events = new List<HitEvent>();
+
+            for (int i = 0; i < 2048; i++)
+            {
+                // Ensure the object has hit windows populated.
+                var hitObject = new HitCircle();
+                hitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+                events.Add(new HitEvent(RNG.NextDouble(-200.0, 200.0), RNG.NextDouble(1.0, 2.0), HitResult.Great, hitObject, null, null));
+
+                incrementalEventLists.Add(new List<HitEvent>(events));
+            }
         }
 
         [Benchmark]
         public void CalculateUnstableRate()
         {
-            _ = events.CalculateUnstableRate();
+            for (int i = 0; i < 2048; i++)
+            {
+                var events = incrementalEventLists[i];
+                _ = events.CalculateUnstableRate();
+            }
+        }
+
+        [Benchmark]
+        public void CalculateUnstableRateUsingIncrementalCalculation()
+        {
+            HitEventExtensions.UnstableRateCalculationResult? last = null;
+
+            for (int i = 0; i < 2048; i++)
+            {
+                var events = incrementalEventLists[i];
+                last = events.CalculateUnstableRate(last);
+            }
         }
     }
 }
diff --git a/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs b/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
index f975c7f1d4..d9cc224ad1 100644
--- a/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
+++ b/osu.Game.Rulesets.Mania/Configuration/ManiaRulesetConfigManager.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
         {
             base.InitialiseDefaults();
 
-            SetDefault(ManiaRulesetSetting.ScrollSpeed, 8, 1, 40);
+            SetDefault(ManiaRulesetSetting.ScrollSpeed, 8.0, 1.0, 40.0, 0.1);
             SetDefault(ManiaRulesetSetting.ScrollDirection, ManiaScrollingDirection.Down);
             SetDefault(ManiaRulesetSetting.TimingBasedNoteColouring, false);
 
@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
             if (Get<double?>(ManiaRulesetSetting.ScrollTime) is double scrollTime)
             {
-                SetValue(ManiaRulesetSetting.ScrollSpeed, (int)Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime));
+                SetValue(ManiaRulesetSetting.ScrollSpeed, Math.Round(DrawableManiaRuleset.MAX_TIME_RANGE / scrollTime));
                 SetValue<double?>(ManiaRulesetSetting.ScrollTime, null);
             }
 #pragma warning restore CS0618
@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
         {
-            new TrackedSetting<int>(ManiaRulesetSetting.ScrollSpeed,
+            new TrackedSetting<double>(ManiaRulesetSetting.ScrollSpeed,
                 speed => new SettingDescription(
                     rawValue: speed,
                     name: RulesetSettingsStrings.ScrollSpeed,
diff --git a/osu.Game.Rulesets.Mania/Edit/DrawableManiaEditorRuleset.cs b/osu.Game.Rulesets.Mania/Edit/DrawableManiaEditorRuleset.cs
index 4c4cf519ce..181bc7341c 100644
--- a/osu.Game.Rulesets.Mania/Edit/DrawableManiaEditorRuleset.cs
+++ b/osu.Game.Rulesets.Mania/Edit/DrawableManiaEditorRuleset.cs
@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Mania.Edit
 
         protected override void Update()
         {
-            TargetTimeRange = TimelineTimeRange == null || ShowSpeedChanges.Value ? ComputeScrollTime(Config.Get<int>(ManiaRulesetSetting.ScrollSpeed)) : TimelineTimeRange.Value;
+            TargetTimeRange = TimelineTimeRange == null || ShowSpeedChanges.Value ? ComputeScrollTime(Config.Get<double>(ManiaRulesetSetting.ScrollSpeed)) : TimelineTimeRange.Value;
             base.Update();
         }
     }
diff --git a/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs b/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs
index 30eca0636c..17add32513 100644
--- a/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs
+++ b/osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs
@@ -33,11 +33,11 @@ namespace osu.Game.Rulesets.Mania
                     LabelText = RulesetSettingsStrings.ScrollingDirection,
                     Current = config.GetBindable<ManiaScrollingDirection>(ManiaRulesetSetting.ScrollDirection)
                 },
-                new SettingsSlider<int, ManiaScrollSlider>
+                new SettingsSlider<double, ManiaScrollSlider>
                 {
                     LabelText = RulesetSettingsStrings.ScrollSpeed,
-                    Current = config.GetBindable<int>(ManiaRulesetSetting.ScrollSpeed),
-                    KeyboardStep = 5
+                    Current = config.GetBindable<double>(ManiaRulesetSetting.ScrollSpeed),
+                    KeyboardStep = 1
                 },
                 new SettingsCheckbox
                 {
@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Mania
             };
         }
 
-        private partial class ManiaScrollSlider : RoundedSliderBar<int>
+        private partial class ManiaScrollSlider : RoundedSliderBar<double>
         {
             public override LocalisableString TooltipText => RulesetSettingsStrings.ScrollSpeedTooltip((int)DrawableManiaRuleset.ComputeScrollTime(Current.Value), Current.Value);
         }
diff --git a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
index aed53e157a..d173ae4143 100644
--- a/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/UI/DrawableManiaRuleset.cs
@@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Mania.UI
         protected new ManiaRulesetConfigManager Config => (ManiaRulesetConfigManager)base.Config;
 
         private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
-        private readonly BindableInt configScrollSpeed = new BindableInt();
+        private readonly BindableDouble configScrollSpeed = new BindableDouble();
 
         private double currentTimeRange;
         protected double TargetTimeRange;
@@ -160,7 +160,7 @@ namespace osu.Game.Rulesets.Mania.UI
         /// </summary>
         /// <param name="scrollSpeed">The scroll speed.</param>
         /// <returns>The scroll time.</returns>
-        public static double ComputeScrollTime(int scrollSpeed) => MAX_TIME_RANGE / scrollSpeed;
+        public static double ComputeScrollTime(double scrollSpeed) => MAX_TIME_RANGE / scrollSpeed;
 
         public override PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new ManiaPlayfieldAdjustmentContainer();
 
diff --git a/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyNewStyleSpinner.cs b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyNewStyleSpinner.cs
index d4a0f243e4..5d09267c21 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyNewStyleSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyNewStyleSpinner.cs
@@ -63,18 +63,18 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                         Origin = Anchor.Centre,
                         Texture = source.GetTexture("spinner-top"),
                     },
-                    fixedMiddle = new Sprite
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Texture = source.GetTexture("spinner-middle"),
-                    },
                     spinningMiddle = new Sprite
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
                         Texture = source.GetTexture("spinner-middle2"),
                     },
+                    fixedMiddle = new Sprite
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Texture = source.GetTexture("spinner-middle"),
+                    },
                 }
             });
 
diff --git a/osu.Game.Tests/NonVisual/Ranking/UnstableRateTest.cs b/osu.Game.Tests/NonVisual/Ranking/UnstableRateTest.cs
index 5a416d05d7..03dc91b5d4 100644
--- a/osu.Game.Tests/NonVisual/Ranking/UnstableRateTest.cs
+++ b/osu.Game.Tests/NonVisual/Ranking/UnstableRateTest.cs
@@ -20,12 +20,53 @@ namespace osu.Game.Tests.NonVisual.Ranking
         public void TestDistributedHits()
         {
             var events = Enumerable.Range(-5, 11)
-                                   .Select(t => new HitEvent(t - 5, 1.0, HitResult.Great, new HitObject(), null, null));
+                                   .Select(t => new HitEvent(t - 5, 1.0, HitResult.Great, new HitObject(), null, null))
+                                   .ToList();
 
             var unstableRate = new UnstableRate(events);
 
             Assert.IsNotNull(unstableRate.Value);
-            Assert.IsTrue(Precision.AlmostEquals(unstableRate.Value.Value, 10 * Math.Sqrt(10)));
+            Assert.AreEqual(unstableRate.Value.Value, 10 * Math.Sqrt(10), Precision.DOUBLE_EPSILON);
+        }
+
+        [Test]
+        public void TestDistributedHitsIncrementalRewind()
+        {
+            var events = Enumerable.Range(-5, 11)
+                                   .Select(t => new HitEvent(t - 5, 1.0, HitResult.Great, new HitObject(), null, null))
+                                   .ToList();
+
+            HitEventExtensions.UnstableRateCalculationResult result = null;
+
+            for (int i = 0; i < events.Count; i++)
+            {
+                result = events.GetRange(0, i + 1)
+                               .CalculateUnstableRate(result);
+            }
+
+            result = events.GetRange(0, 2).CalculateUnstableRate(result);
+
+            Assert.IsNotNull(result!.Result);
+            Assert.AreEqual(5, result.Result, Precision.DOUBLE_EPSILON);
+        }
+
+        [Test]
+        public void TestDistributedHitsIncremental()
+        {
+            var events = Enumerable.Range(-5, 11)
+                                   .Select(t => new HitEvent(t - 5, 1.0, HitResult.Great, new HitObject(), null, null))
+                                   .ToList();
+
+            HitEventExtensions.UnstableRateCalculationResult result = null;
+
+            for (int i = 0; i < events.Count; i++)
+            {
+                result = events.GetRange(0, i + 1)
+                               .CalculateUnstableRate(result);
+            }
+
+            Assert.IsNotNull(result!.Result);
+            Assert.AreEqual(10 * Math.Sqrt(10), result.Result, Precision.DOUBLE_EPSILON);
         }
 
         [Test]
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
index 5cc1e64197..765fe1ecf6 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
@@ -527,8 +527,11 @@ namespace osu.Game.Tests.Visual.Editing
             checkPlacementSampleBank(HitSampleInfo.BANK_NORMAL);
             checkPlacementSampleAdditionBank(HitSampleInfo.BANK_NORMAL);
 
-            void checkPlacementSampleBank(string expected) => AddAssert($"Placement sample is {expected}", () => EditorBeatmap.PlacementObject.Value.Samples.First(s => s.Name == HitSampleInfo.HIT_NORMAL).Bank, () => Is.EqualTo(expected));
-            void checkPlacementSampleAdditionBank(string expected) => AddAssert($"Placement sample addition is {expected}", () => EditorBeatmap.PlacementObject.Value.Samples.First(s => s.Name != HitSampleInfo.HIT_NORMAL).Bank, () => Is.EqualTo(expected));
+            void checkPlacementSampleBank(string expected) => AddAssert($"Placement sample is {expected}",
+                () => EditorBeatmap.PlacementObject.Value.Samples.First(s => s.Name == HitSampleInfo.HIT_NORMAL).Bank, () => Is.EqualTo(expected));
+
+            void checkPlacementSampleAdditionBank(string expected) => AddAssert($"Placement sample addition is {expected}",
+                () => EditorBeatmap.PlacementObject.Value.Samples.First(s => s.Name != HitSampleInfo.HIT_NORMAL).Bank, () => Is.EqualTo(expected));
         }
 
         [Test]
@@ -781,15 +784,39 @@ namespace osu.Game.Tests.Visual.Editing
             setAdditionBankViaPopover(HitSampleInfo.BANK_SOFT);
             dismissPopover();
 
-            hitObjectHasSamples(0, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_FINISH);
-            hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_NORMAL);
-            hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_SOFT);
+            assertNoChanges();
 
-            AddStep("select first object", () => EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects[0]));
+            AddStep("select first object", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.Clear();
+                EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects[0]);
+            });
+            assertNoChanges();
 
-            hitObjectHasSamples(0, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_FINISH);
-            hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_NORMAL);
-            hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_SOFT);
+            AddStep("select second object", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.Clear();
+                EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects[1]);
+            });
+            assertNoChanges();
+
+            AddStep("select first object", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.Clear();
+                EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects[0]);
+            });
+            assertNoChanges();
+
+            void assertNoChanges()
+            {
+                hitObjectHasSamples(0, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_FINISH);
+                hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_NORMAL);
+                hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_SOFT);
+
+                hitObjectHasSamples(1, HitSampleInfo.HIT_NORMAL);
+                hitObjectHasSampleNormalBank(1, HitSampleInfo.BANK_SOFT);
+                hitObjectHasSampleAdditionBank(1, HitSampleInfo.BANK_SOFT);
+            }
         }
 
         private void clickSamplePiece(int objectIndex) => AddStep($"click {objectIndex.ToOrdinalWords()} sample piece", () =>
@@ -883,11 +910,12 @@ namespace osu.Game.Tests.Visual.Editing
             return h.Samples.All(o => o.Volume == volume);
         });
 
-        private void hitObjectNodeHasSampleVolume(int objectIndex, int nodeIndex, int volume) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has volume {volume}", () =>
-        {
-            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
-            return h is not null && h.NodeSamples[nodeIndex].All(o => o.Volume == volume);
-        });
+        private void hitObjectNodeHasSampleVolume(int objectIndex, int nodeIndex, int volume) => AddAssert(
+            $"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has volume {volume}", () =>
+            {
+                var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+                return h is not null && h.NodeSamples[nodeIndex].All(o => o.Volume == volume);
+            });
 
         private void setBankViaPopover(string bank) => AddStep($"set bank {bank} via popover", () =>
         {
@@ -944,29 +972,33 @@ namespace osu.Game.Tests.Visual.Editing
             return h.Samples.Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
         });
 
-        private void hitObjectNodeHasSamples(int objectIndex, int nodeIndex, params string[] samples) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has samples {string.Join(',', samples)}", () =>
-        {
-            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
-            return h is not null && h.NodeSamples[nodeIndex].Select(s => s.Name).SequenceEqual(samples);
-        });
+        private void hitObjectNodeHasSamples(int objectIndex, int nodeIndex, params string[] samples) => AddAssert(
+            $"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has samples {string.Join(',', samples)}", () =>
+            {
+                var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+                return h is not null && h.NodeSamples[nodeIndex].Select(s => s.Name).SequenceEqual(samples);
+            });
 
-        private void hitObjectNodeHasSampleBank(int objectIndex, int nodeIndex, string bank) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has bank {bank}", () =>
-        {
-            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
-            return h is not null && h.NodeSamples[nodeIndex].All(o => o.Bank == bank);
-        });
+        private void hitObjectNodeHasSampleBank(int objectIndex, int nodeIndex, string bank) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has bank {bank}",
+            () =>
+            {
+                var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+                return h is not null && h.NodeSamples[nodeIndex].All(o => o.Bank == bank);
+            });
 
-        private void hitObjectNodeHasSampleNormalBank(int objectIndex, int nodeIndex, string bank) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has normal bank {bank}", () =>
-        {
-            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
-            return h is not null && h.NodeSamples[nodeIndex].Where(o => o.Name == HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
-        });
+        private void hitObjectNodeHasSampleNormalBank(int objectIndex, int nodeIndex, string bank) => AddAssert(
+            $"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has normal bank {bank}", () =>
+            {
+                var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+                return h is not null && h.NodeSamples[nodeIndex].Where(o => o.Name == HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
+            });
 
-        private void hitObjectNodeHasSampleAdditionBank(int objectIndex, int nodeIndex, string bank) => AddAssert($"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has addition bank {bank}", () =>
-        {
-            var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
-            return h is not null && h.NodeSamples[nodeIndex].Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
-        });
+        private void hitObjectNodeHasSampleAdditionBank(int objectIndex, int nodeIndex, string bank) => AddAssert(
+            $"{objectIndex.ToOrdinalWords()} object {nodeIndex.ToOrdinalWords()} node has addition bank {bank}", () =>
+            {
+                var h = EditorBeatmap.HitObjects.ElementAt(objectIndex) as IHasRepeats;
+                return h is not null && h.NodeSamples[nodeIndex].Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(o => o.Bank == bank);
+            });
 
         private void editorTimeIs(double time) => AddAssert($"editor time is {time}", () => Precision.AlmostEquals(EditorClock.CurrentTimeAccurate, time, 1));
     }
diff --git a/osu.Game/Configuration/OsuConfigManager.cs b/osu.Game/Configuration/OsuConfigManager.cs
index 362c06849d..33d99e9b0f 100644
--- a/osu.Game/Configuration/OsuConfigManager.cs
+++ b/osu.Game/Configuration/OsuConfigManager.cs
@@ -214,6 +214,7 @@ namespace osu.Game.Configuration
             SetDefault(OsuSetting.EditorContractSidebars, false);
 
             SetDefault(OsuSetting.AlwaysShowHoldForMenuButton, false);
+            SetDefault(OsuSetting.AlwaysRequireHoldingForPause, false);
         }
 
         protected override bool CheckLookupContainsPrivateInformation(OsuSetting lookup)
@@ -444,5 +445,6 @@ namespace osu.Game.Configuration
         EditorRotationOrigin,
         EditorTimelineShowBreaks,
         EditorAdjustExistingObjectsOnTimingChanges,
+        AlwaysRequireHoldingForPause
     }
 }
diff --git a/osu.Game/Localisation/GameplaySettingsStrings.cs b/osu.Game/Localisation/GameplaySettingsStrings.cs
index 6de61f7ebe..ff6a6102a7 100644
--- a/osu.Game/Localisation/GameplaySettingsStrings.cs
+++ b/osu.Game/Localisation/GameplaySettingsStrings.cs
@@ -89,6 +89,11 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString AlwaysShowHoldForMenuButton => new TranslatableString(getKey(@"always_show_hold_for_menu_button"), @"Always show hold for menu button");
 
+        /// <summary>
+        /// "Require holding key to pause gameplay"
+        /// </summary>
+        public static LocalisableString AlwaysRequireHoldForMenu => new TranslatableString(getKey(@"require_holding_key_to_pause_gameplay"), @"Require holding key to pause gameplay");
+
         /// <summary>
         /// "Always play first combo break sound"
         /// </summary>
diff --git a/osu.Game/Localisation/RulesetSettingsStrings.cs b/osu.Game/Localisation/RulesetSettingsStrings.cs
index e3d51f1124..9434cd53de 100644
--- a/osu.Game/Localisation/RulesetSettingsStrings.cs
+++ b/osu.Game/Localisation/RulesetSettingsStrings.cs
@@ -80,9 +80,9 @@ namespace osu.Game.Localisation
         public static LocalisableString TimingBasedColouring => new TranslatableString(getKey(@"Timing_based_colouring"), @"Timing-based note colouring");
 
         /// <summary>
-        /// "{0}ms (speed {1})"
+        /// "{0}ms (speed {1:N1})"
         /// </summary>
-        public static LocalisableString ScrollSpeedTooltip(int scrollTime, int scrollSpeed) => new TranslatableString(getKey(@"ruleset"), @"{0}ms (speed {1})", scrollTime, scrollSpeed);
+        public static LocalisableString ScrollSpeedTooltip(int scrollTime, double scrollSpeed) => new TranslatableString(getKey(@"ruleset"), @"{0}ms (speed {1:N1})", scrollTime, scrollSpeed);
 
         /// <summary>
         /// "Touch control scheme"
diff --git a/osu.Game/Overlays/Settings/Sections/Gameplay/HUDSettings.cs b/osu.Game/Overlays/Settings/Sections/Gameplay/HUDSettings.cs
index f4dd319152..b4caaf7983 100644
--- a/osu.Game/Overlays/Settings/Sections/Gameplay/HUDSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Gameplay/HUDSettings.cs
@@ -41,6 +41,11 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
                     Current = config.GetBindable<bool>(OsuSetting.GameplayLeaderboard),
                 },
                 new SettingsCheckbox
+                {
+                    LabelText = GameplaySettingsStrings.AlwaysRequireHoldForMenu,
+                    Current = config.GetBindable<bool>(OsuSetting.AlwaysRequireHoldingForPause),
+                },
+                new SettingsCheckbox
                 {
                     LabelText = GameplaySettingsStrings.AlwaysShowHoldForMenuButton,
                     Current = config.GetBindable<bool>(OsuSetting.AlwaysShowHoldForMenuButton),
diff --git a/osu.Game/Rulesets/Mods/ModAdaptiveSpeed.cs b/osu.Game/Rulesets/Mods/ModAdaptiveSpeed.cs
index 19554b6504..4ca937bf86 100644
--- a/osu.Game/Rulesets/Mods/ModAdaptiveSpeed.cs
+++ b/osu.Game/Rulesets/Mods/ModAdaptiveSpeed.cs
@@ -205,7 +205,7 @@ namespace osu.Game.Rulesets.Mods
         {
             foreach (var hitObject in hitObjects)
             {
-                if (!(hitObject.HitWindows is HitWindows.EmptyHitWindows))
+                if (hitObject.HitWindows != HitWindows.Empty)
                     yield return hitObject;
 
                 foreach (HitObject nested in getAllApplicableHitObjects(hitObject.NestedHitObjects))
diff --git a/osu.Game/Rulesets/Scoring/HitEventExtensions.cs b/osu.Game/Rulesets/Scoring/HitEventExtensions.cs
index fc4eef13ba..269342460f 100644
--- a/osu.Game/Rulesets/Scoring/HitEventExtensions.cs
+++ b/osu.Game/Rulesets/Scoring/HitEventExtensions.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Scoring
 {
@@ -20,32 +21,36 @@ namespace osu.Game.Rulesets.Scoring
         /// A non-null <see langword="double"/> value if unstable rate could be calculated,
         /// and <see langword="null"/> if unstable rate cannot be calculated due to <paramref name="hitEvents"/> being empty.
         /// </returns>
-        public static double? CalculateUnstableRate(this IEnumerable<HitEvent> hitEvents)
+        public static UnstableRateCalculationResult? CalculateUnstableRate(this IReadOnlyList<HitEvent> hitEvents, UnstableRateCalculationResult? result = null)
         {
             Debug.Assert(hitEvents.All(ev => ev.GameplayRate != null));
 
-            int count = 0;
-            double mean = 0;
-            double sumOfSquares = 0;
+            result ??= new UnstableRateCalculationResult();
 
-            foreach (var e in hitEvents)
+            // Handle rewinding in the simplest way possible.
+            if (hitEvents.Count < result.EventCount + 1)
+                result = new UnstableRateCalculationResult();
+
+            for (int i = result.EventCount; i < hitEvents.Count; i++)
             {
+                HitEvent e = hitEvents[i];
+
                 if (!AffectsUnstableRate(e))
                     continue;
 
-                count++;
+                result.EventCount++;
 
                 // Division by gameplay rate is to account for TimeOffset scaling with gameplay rate.
                 double currentValue = e.TimeOffset / e.GameplayRate!.Value;
-                double nextMean = mean + (currentValue - mean) / count;
-                sumOfSquares += (currentValue - mean) * (currentValue - nextMean);
-                mean = nextMean;
+                double nextMean = result.Mean + (currentValue - result.Mean) / result.EventCount;
+                result.SumOfSquares += (currentValue - result.Mean) * (currentValue - nextMean);
+                result.Mean = nextMean;
             }
 
-            if (count == 0)
+            if (result.EventCount == 0)
                 return null;
 
-            return 10.0 * Math.Sqrt(sumOfSquares / count);
+            return result;
         }
 
         /// <summary>
@@ -65,6 +70,39 @@ namespace osu.Game.Rulesets.Scoring
             return timeOffsets.Average();
         }
 
-        public static bool AffectsUnstableRate(HitEvent e) => !(e.HitObject.HitWindows is HitWindows.EmptyHitWindows) && e.Result.IsHit();
+        public static bool AffectsUnstableRate(HitEvent e) => AffectsUnstableRate(e.HitObject, e.Result);
+        public static bool AffectsUnstableRate(HitObject hitObject, HitResult result) => hitObject.HitWindows != HitWindows.Empty && result.IsHit();
+
+        /// <summary>
+        /// Data type returned by <see cref="HitEventExtensions.CalculateUnstableRate"/> which allows efficient incremental processing.
+        /// </summary>
+        /// <remarks>
+        /// This should be passed back into future <see cref="HitEventExtensions.CalculateUnstableRate"/> calls as a parameter.
+        ///
+        /// The optimisations used here rely on hit events being a consecutive sequence from a single gameplay session.
+        /// When a new gameplay session is started, any existing results should be disposed.
+        /// </remarks>
+        public class UnstableRateCalculationResult
+        {
+            /// <summary>
+            /// Total events processed. For internal incremental calculation use.
+            /// </summary>
+            public int EventCount;
+
+            /// <summary>
+            /// Last sum-of-squares value. For internal incremental calculation use.
+            /// </summary>
+            public double SumOfSquares;
+
+            /// <summary>
+            /// Last mean value. For internal incremental calculation use.
+            /// </summary>
+            public double Mean;
+
+            /// <summary>
+            /// The unstable rate.
+            /// </summary>
+            public double Result => EventCount == 0 ? 0 : 10.0 * Math.Sqrt(SumOfSquares / EventCount);
+        }
     }
 }
diff --git a/osu.Game/Rulesets/Scoring/HitWindows.cs b/osu.Game/Rulesets/Scoring/HitWindows.cs
index 2d008b58ba..a6a268fc78 100644
--- a/osu.Game/Rulesets/Scoring/HitWindows.cs
+++ b/osu.Game/Rulesets/Scoring/HitWindows.cs
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Scoring
         /// An empty <see cref="HitWindows"/> with only <see cref="HitResult.Miss"/> and <see cref="HitResult.Perfect"/>.
         /// No time values are provided (meaning instantaneous hit or miss).
         /// </summary>
-        public static HitWindows Empty => new EmptyHitWindows();
+        public static HitWindows Empty { get; } = new EmptyHitWindows();
 
         public HitWindows()
         {
@@ -182,7 +182,7 @@ namespace osu.Game.Rulesets.Scoring
         /// </summary>
         protected virtual DifficultyRange[] GetRanges() => base_ranges;
 
-        public class EmptyHitWindows : HitWindows
+        private class EmptyHitWindows : HitWindows
         {
             private static readonly DifficultyRange[] ranges =
             {
diff --git a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
index 6724a1dc4d..78cee2c1cf 100644
--- a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
@@ -258,6 +258,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         private void resetTernaryStates()
         {
+            if (SelectedItems.Count > 0)
+                return;
+
             SelectionNewComboState.Value = TernaryState.False;
             AutoSelectionBankEnabled.Value = true;
             SelectionAdditionBanksEnabled.Value = true;
diff --git a/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs b/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs
index 5d3d5774d0..96e937fda7 100644
--- a/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs
+++ b/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs
@@ -162,14 +162,18 @@ namespace osu.Game.Screens.Play.HUD
             private bool pendingAnimation;
             private ScheduledDelegate shakeOperation;
 
+            private Bindable<bool> alwaysRequireHold;
+
             public HoldButton(bool isDangerousAction)
                 : base(isDangerousAction)
             {
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuColour colours)
+            private void load(OsuColour colours, OsuConfigManager config)
             {
+                alwaysRequireHold = config.GetBindable<bool>(OsuSetting.AlwaysRequireHoldingForPause);
+
                 Size = new Vector2(60);
 
                 Child = new CircularContainer
@@ -300,7 +304,7 @@ namespace osu.Game.Screens.Play.HUD
                     case GlobalAction.Back:
                         if (!pendingAnimation)
                         {
-                            if (IsDangerousAction)
+                            if (IsDangerousAction || alwaysRequireHold.Value)
                                 BeginConfirm();
                             else
                                 Confirm();
@@ -314,7 +318,7 @@ namespace osu.Game.Screens.Play.HUD
 
                         if (!pendingAnimation)
                         {
-                            if (IsDangerousAction)
+                            if (IsDangerousAction || alwaysRequireHold.Value)
                                 BeginConfirm();
                             else
                                 Confirm();
diff --git a/osu.Game/Screens/Play/HUD/UnstableRateCounter.cs b/osu.Game/Screens/Play/HUD/UnstableRateCounter.cs
index ab7ab6b3a0..a856a09388 100644
--- a/osu.Game/Screens/Play/HUD/UnstableRateCounter.cs
+++ b/osu.Game/Screens/Play/HUD/UnstableRateCounter.cs
@@ -28,6 +28,8 @@ namespace osu.Game.Screens.Play.HUD
         private const float alpha_when_invalid = 0.3f;
         private readonly Bindable<bool> valid = new Bindable<bool>();
 
+        private HitEventExtensions.UnstableRateCalculationResult? unstableRateResult;
+
         [Resolved]
         private ScoreProcessor scoreProcessor { get; set; } = null!;
 
@@ -44,9 +46,6 @@ namespace osu.Game.Screens.Play.HUD
                 DrawableCount.FadeTo(e.NewValue ? 1 : alpha_when_invalid, 1000, Easing.OutQuint));
         }
 
-        private bool changesUnstableRate(JudgementResult judgement)
-            => !(judgement.HitObject.HitWindows is HitWindows.EmptyHitWindows) && judgement.IsHit;
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -56,13 +55,20 @@ namespace osu.Game.Screens.Play.HUD
             updateDisplay();
         }
 
-        private void updateDisplay(JudgementResult _) => Scheduler.AddOnce(updateDisplay);
+        private void updateDisplay(JudgementResult result)
+        {
+            if (HitEventExtensions.AffectsUnstableRate(result.HitObject, result.Type))
+                Scheduler.AddOnce(updateDisplay);
+        }
 
         private void updateDisplay()
         {
-            double? unstableRate = scoreProcessor.HitEvents.CalculateUnstableRate();
+            unstableRateResult = scoreProcessor.HitEvents.CalculateUnstableRate(unstableRateResult);
+
+            double? unstableRate = unstableRateResult?.Result;
 
             valid.Value = unstableRate != null;
+
             if (unstableRate != null)
                 Current.Value = (int)Math.Round(unstableRate.Value);
         }
diff --git a/osu.Game/Screens/Ranking/Statistics/HitEventTimingDistributionGraph.cs b/osu.Game/Screens/Ranking/Statistics/HitEventTimingDistributionGraph.cs
index a9b93e0ffc..a80aeaa5dd 100644
--- a/osu.Game/Screens/Ranking/Statistics/HitEventTimingDistributionGraph.cs
+++ b/osu.Game/Screens/Ranking/Statistics/HitEventTimingDistributionGraph.cs
@@ -58,7 +58,7 @@ namespace osu.Game.Screens.Ranking.Statistics
         /// <param name="hitEvents">The <see cref="HitEvent"/>s to display the timing distribution of.</param>
         public HitEventTimingDistributionGraph(IReadOnlyList<HitEvent> hitEvents)
         {
-            this.hitEvents = hitEvents.Where(e => !(e.HitObject.HitWindows is HitWindows.EmptyHitWindows) && e.Result.IsBasic() && e.Result.IsHit()).ToList();
+            this.hitEvents = hitEvents.Where(e => e.HitObject.HitWindows != HitWindows.Empty && e.Result.IsBasic() && e.Result.IsHit()).ToList();
             bins = Enumerable.Range(0, total_timing_distribution_bins).Select(_ => new Dictionary<HitResult, int>()).ToArray<IDictionary<HitResult, int>>();
         }
 
diff --git a/osu.Game/Screens/Ranking/Statistics/UnstableRate.cs b/osu.Game/Screens/Ranking/Statistics/UnstableRate.cs
index cc3535a426..d114bed156 100644
--- a/osu.Game/Screens/Ranking/Statistics/UnstableRate.cs
+++ b/osu.Game/Screens/Ranking/Statistics/UnstableRate.cs
@@ -15,10 +15,10 @@ namespace osu.Game.Screens.Ranking.Statistics
         /// Creates and computes an <see cref="UnstableRate"/> statistic.
         /// </summary>
         /// <param name="hitEvents">Sequence of <see cref="HitEvent"/>s to calculate the unstable rate based on.</param>
-        public UnstableRate(IEnumerable<HitEvent> hitEvents)
+        public UnstableRate(IReadOnlyList<HitEvent> hitEvents)
             : base("Unstable Rate")
         {
-            Value = hitEvents.CalculateUnstableRate();
+            Value = hitEvents.CalculateUnstableRate()?.Result;
         }
 
         protected override string DisplayValue(double? value) => value == null ? "(not available)" : value.Value.ToString(@"N2");