diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs
index 6c4fbbac17..a5e89210f6 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs
@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
         /// <summary>
         /// The start time of <see cref="Start"/>.
         /// </summary>
-        public readonly Bindable<double> StartTime = new Bindable<double>();
+        public readonly Bindable<double> StartTime = new BindableDouble();
 
         /// <summary>
         /// The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will exit from.
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
index 3162f4b379..4ef63bb2a0 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
         private readonly IBindable<int> stackHeightBindable = new Bindable<int>();
-        private readonly IBindable<float> scaleBindable = new Bindable<float>();
+        private readonly IBindable<float> scaleBindable = new BindableFloat();
 
         public OsuAction? HitAction => HitArea.HitAction;
 
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableRepeatPoint.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableRepeatPoint.cs
index 20b31c68f2..8fdcd060e7 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableRepeatPoint.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableRepeatPoint.cs
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             InternalChild = scaleContainer = new ReverseArrowPiece();
         }
 
-        private readonly IBindable<float> scaleBindable = new Bindable<float>();
+        private readonly IBindable<float> scaleBindable = new BindableFloat();
 
         [BackgroundDependencyLoader]
         private void load()
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
index cd3c572ba0..7403649184 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
         private readonly IBindable<int> stackHeightBindable = new Bindable<int>();
-        private readonly IBindable<float> scaleBindable = new Bindable<float>();
+        private readonly IBindable<float> scaleBindable = new BindableFloat();
 
         public DrawableSlider(Slider s)
             : base(s)
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTick.cs
index 9d4d9958a1..60b5c335d6 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTick.cs
@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             };
         }
 
-        private readonly IBindable<float> scaleBindable = new Bindable<float>();
+        private readonly IBindable<float> scaleBindable = new BindableFloat();
 
         [BackgroundDependencyLoader]
         private void load()
diff --git a/osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs b/osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs
index 0ba712a83f..15af141c99 100644
--- a/osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Objects/OsuHitObject.cs
@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public double Radius => OBJECT_RADIUS * Scale;
 
-        public readonly Bindable<float> ScaleBindable = new Bindable<float>(1);
+        public readonly Bindable<float> ScaleBindable = new BindableFloat(1);
 
         public float Scale
         {
diff --git a/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs b/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs
index a463542e64..79b5d1b7f8 100644
--- a/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs
+++ b/osu.Game.Rulesets.Osu/UI/Cursor/OsuCursorContainer.cs
@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             autoCursorScale = config.GetBindable<bool>(OsuSetting.AutoCursorSize);
             autoCursorScale.ValueChanged += _ => calculateScale();
 
-            CursorScale = new Bindable<float>();
+            CursorScale = new BindableFloat();
             CursorScale.ValueChanged += e => ActiveCursor.Scale = cursorTrail.Scale = new Vector2(e.NewValue);
 
             calculateScale();
diff --git a/osu.Game.Rulesets.Osu/UI/OsuResumeOverlay.cs b/osu.Game.Rulesets.Osu/UI/OsuResumeOverlay.cs
index ca3030db3e..abba444c73 100644
--- a/osu.Game.Rulesets.Osu/UI/OsuResumeOverlay.cs
+++ b/osu.Game.Rulesets.Osu/UI/OsuResumeOverlay.cs
@@ -50,7 +50,7 @@ namespace osu.Game.Rulesets.Osu.UI
             {
                 Add(localCursorContainer = new OsuCursorContainer());
 
-                localCursorScale = new Bindable<float>();
+                localCursorScale = new BindableFloat();
                 localCursorScale.BindTo(localCursorContainer.CursorScale);
                 localCursorScale.BindValueChanged(scale => cursorScaleContainer.Scale = new Vector2(scale.NewValue), true);
             }
diff --git a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
index 589ec7e8aa..29bcc7df9e 100644
--- a/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
+++ b/osu.Game.Tests/Visual/Background/TestSceneUserDimBackgrounds.cs
@@ -302,8 +302,8 @@ namespace osu.Game.Tests.Visual.Background
             }
 
             public readonly Bindable<bool> DimEnabled = new Bindable<bool>();
-            public readonly Bindable<double> DimLevel = new Bindable<double>();
-            public readonly Bindable<double> BlurLevel = new Bindable<double>();
+            public readonly Bindable<double> DimLevel = new BindableDouble();
+            public readonly Bindable<double> BlurLevel = new BindableDouble();
 
             public new BeatmapCarousel Carousel => base.Carousel;
 
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs
new file mode 100644
index 0000000000..3d3517ada4
--- /dev/null
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneAdvancedStats.cs
@@ -0,0 +1,175 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Screens.Select.Details;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.SongSelect
+{
+    [System.ComponentModel.Description("Advanced beatmap statistics display")]
+    public class TestSceneAdvancedStats : OsuTestScene
+    {
+        private TestAdvancedStats advancedStats;
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; }
+
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        [SetUp]
+        public void Setup() => Schedule(() => Child = advancedStats = new TestAdvancedStats
+        {
+            Width = 500
+        });
+
+        private BeatmapInfo exampleBeatmapInfo => new BeatmapInfo
+        {
+            RulesetID = 0,
+            Ruleset = rulesets.AvailableRulesets.First(),
+            BaseDifficulty = new BeatmapDifficulty
+            {
+                CircleSize = 7.2f,
+                DrainRate = 3,
+                OverallDifficulty = 5.7f,
+                ApproachRate = 3.5f
+            },
+            StarDifficulty = 4.5f
+        };
+
+        [Test]
+        public void TestNoMod()
+        {
+            AddStep("set beatmap", () => advancedStats.Beatmap = exampleBeatmapInfo);
+
+            AddStep("no mods selected", () => SelectedMods.Value = Array.Empty<Mod>());
+
+            AddAssert("first bar text is Circle Size", () => advancedStats.ChildrenOfType<SpriteText>().First().Text == "Circle Size");
+            AddAssert("circle size bar is white", () => barIsWhite(advancedStats.FirstValue));
+            AddAssert("HP drain bar is white", () => barIsWhite(advancedStats.HpDrain));
+            AddAssert("accuracy bar is white", () => barIsWhite(advancedStats.Accuracy));
+            AddAssert("approach rate bar is white", () => barIsWhite(advancedStats.ApproachRate));
+        }
+
+        [Test]
+        public void TestManiaFirstBarText()
+        {
+            AddStep("set beatmap", () => advancedStats.Beatmap = new BeatmapInfo
+            {
+                Ruleset = rulesets.GetRuleset(3),
+                BaseDifficulty = new BeatmapDifficulty
+                {
+                    CircleSize = 5,
+                    DrainRate = 4.3f,
+                    OverallDifficulty = 4.5f,
+                    ApproachRate = 3.1f
+                },
+                StarDifficulty = 8
+            });
+
+            AddAssert("first bar text is Key Count", () => advancedStats.ChildrenOfType<SpriteText>().First().Text == "Key Count");
+        }
+
+        [Test]
+        public void TestEasyMod()
+        {
+            AddStep("set beatmap", () => advancedStats.Beatmap = exampleBeatmapInfo);
+
+            AddStep("select EZ mod", () =>
+            {
+                var ruleset = advancedStats.Beatmap.Ruleset.CreateInstance();
+                SelectedMods.Value = new[] { ruleset.GetAllMods().OfType<ModEasy>().Single() };
+            });
+
+            AddAssert("circle size bar is blue", () => barIsBlue(advancedStats.FirstValue));
+            AddAssert("HP drain bar is blue", () => barIsBlue(advancedStats.HpDrain));
+            AddAssert("accuracy bar is blue", () => barIsBlue(advancedStats.Accuracy));
+            AddAssert("approach rate bar is blue", () => barIsBlue(advancedStats.ApproachRate));
+        }
+
+        [Test]
+        public void TestHardRockMod()
+        {
+            AddStep("set beatmap", () => advancedStats.Beatmap = exampleBeatmapInfo);
+
+            AddStep("select HR mod", () =>
+            {
+                var ruleset = advancedStats.Beatmap.Ruleset.CreateInstance();
+                SelectedMods.Value = new[] { ruleset.GetAllMods().OfType<ModHardRock>().Single() };
+            });
+
+            AddAssert("circle size bar is red", () => barIsRed(advancedStats.FirstValue));
+            AddAssert("HP drain bar is red", () => barIsRed(advancedStats.HpDrain));
+            AddAssert("accuracy bar is red", () => barIsRed(advancedStats.Accuracy));
+            AddAssert("approach rate bar is red", () => barIsRed(advancedStats.ApproachRate));
+        }
+
+        [Test]
+        public void TestUnchangedDifficultyAdjustMod()
+        {
+            AddStep("set beatmap", () => advancedStats.Beatmap = exampleBeatmapInfo);
+
+            AddStep("select unchanged Difficulty Adjust mod", () =>
+            {
+                var ruleset = advancedStats.Beatmap.Ruleset.CreateInstance();
+                var difficultyAdjustMod = ruleset.GetAllMods().OfType<ModDifficultyAdjust>().Single();
+                difficultyAdjustMod.ReadFromDifficulty(advancedStats.Beatmap.BaseDifficulty);
+                SelectedMods.Value = new[] { difficultyAdjustMod };
+            });
+
+            AddAssert("circle size bar is white", () => barIsWhite(advancedStats.FirstValue));
+            AddAssert("HP drain bar is white", () => barIsWhite(advancedStats.HpDrain));
+            AddAssert("accuracy bar is white", () => barIsWhite(advancedStats.Accuracy));
+            AddAssert("approach rate bar is white", () => barIsWhite(advancedStats.ApproachRate));
+        }
+
+        [Test]
+        public void TestChangedDifficultyAdjustMod()
+        {
+            AddStep("set beatmap", () => advancedStats.Beatmap = exampleBeatmapInfo);
+
+            AddStep("select changed Difficulty Adjust mod", () =>
+            {
+                var ruleset = advancedStats.Beatmap.Ruleset.CreateInstance();
+                var difficultyAdjustMod = ruleset.GetAllMods().OfType<ModDifficultyAdjust>().Single();
+                var originalDifficulty = advancedStats.Beatmap.BaseDifficulty;
+                var adjustedDifficulty = new BeatmapDifficulty
+                {
+                    CircleSize = originalDifficulty.CircleSize,
+                    DrainRate = originalDifficulty.DrainRate - 0.5f,
+                    OverallDifficulty = originalDifficulty.OverallDifficulty,
+                    ApproachRate = originalDifficulty.ApproachRate + 2.2f,
+                };
+                difficultyAdjustMod.ReadFromDifficulty(adjustedDifficulty);
+                SelectedMods.Value = new[] { difficultyAdjustMod };
+            });
+
+            AddAssert("circle size bar is white", () => barIsWhite(advancedStats.FirstValue));
+            AddAssert("drain rate bar is blue", () => barIsBlue(advancedStats.HpDrain));
+            AddAssert("accuracy bar is white", () => barIsWhite(advancedStats.Accuracy));
+            AddAssert("approach rate bar is red", () => barIsRed(advancedStats.ApproachRate));
+        }
+
+        private bool barIsWhite(AdvancedStats.StatisticRow row) => row.ModBar.AccentColour == Color4.White;
+        private bool barIsBlue(AdvancedStats.StatisticRow row) => row.ModBar.AccentColour == colours.BlueDark;
+        private bool barIsRed(AdvancedStats.StatisticRow row) => row.ModBar.AccentColour == colours.Red;
+
+        private class TestAdvancedStats : AdvancedStats
+        {
+            public new StatisticRow FirstValue => base.FirstValue;
+            public new StatisticRow HpDrain => base.HpDrain;
+            public new StatisticRow Accuracy => base.Accuracy;
+            public new StatisticRow ApproachRate => base.ApproachRate;
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapDetails.cs b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapDetails.cs
index 6aa5a76490..acf037198f 100644
--- a/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapDetails.cs
+++ b/osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapDetails.cs
@@ -3,14 +3,8 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Testing;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Select;
 
 namespace osu.Game.Tests.Visual.SongSelect
@@ -180,27 +174,5 @@ namespace osu.Game.Tests.Visual.SongSelect
                 OnlineBeatmapID = 162,
             });
         }
-
-        [Resolved]
-        private RulesetStore rulesets { get; set; }
-
-        [Resolved]
-        private OsuColour colours { get; set; }
-
-        [Test]
-        public void TestModAdjustments()
-        {
-            TestAllMetrics();
-
-            Ruleset ruleset = rulesets.AvailableRulesets.First().CreateInstance();
-
-            AddStep("with EZ mod", () => SelectedMods.Value = new[] { ruleset.GetAllMods().First(m => m is ModEasy) });
-
-            AddAssert("first bar coloured blue", () => details.ChildrenOfType<Bar>().Skip(1).First().AccentColour == colours.BlueDark);
-
-            AddStep("with HR mod", () => SelectedMods.Value = new[] { ruleset.GetAllMods().First(m => m is ModHardRock) });
-
-            AddAssert("first bar coloured red", () => details.ChildrenOfType<Bar>().Skip(1).First().AccentColour == colours.Red);
-        }
     }
 }
diff --git a/osu.Game/Rulesets/Objects/HitObject.cs b/osu.Game/Rulesets/Objects/HitObject.cs
index bd96441ebb..c09844e0c6 100644
--- a/osu.Game/Rulesets/Objects/HitObject.cs
+++ b/osu.Game/Rulesets/Objects/HitObject.cs
@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Objects
         /// </summary>
         public event Action DefaultsApplied;
 
-        public readonly Bindable<double> StartTimeBindable = new Bindable<double>();
+        public readonly Bindable<double> StartTimeBindable = new BindableDouble();
 
         /// <summary>
         /// The time at which the HitObject starts.
diff --git a/osu.Game/Screens/Backgrounds/BackgroundScreenBeatmap.cs b/osu.Game/Screens/Backgrounds/BackgroundScreenBeatmap.cs
index 3ced9ee753..50fd127093 100644
--- a/osu.Game/Screens/Backgrounds/BackgroundScreenBeatmap.cs
+++ b/osu.Game/Screens/Backgrounds/BackgroundScreenBeatmap.cs
@@ -36,7 +36,7 @@ namespace osu.Game.Screens.Backgrounds
         /// <summary>
         /// The amount of blur to be applied in addition to user-specified blur.
         /// </summary>
-        public readonly Bindable<float> BlurAmount = new Bindable<float>();
+        public readonly Bindable<float> BlurAmount = new BindableFloat();
 
         internal readonly IBindable<bool> IsBreakTime = new Bindable<bool>();
 
@@ -119,7 +119,7 @@ namespace osu.Game.Screens.Backgrounds
             /// <remarks>
             /// Used in contexts where there can potentially be both user and screen-specified blurring occuring at the same time, such as in <see cref="PlayerLoader"/>
             /// </remarks>
-            public readonly Bindable<float> BlurAmount = new Bindable<float>();
+            public readonly Bindable<float> BlurAmount = new BindableFloat();
 
             public Background Background
             {
diff --git a/osu.Game/Screens/Select/Details/AdvancedStats.cs b/osu.Game/Screens/Select/Details/AdvancedStats.cs
index 56c400e869..7ab91677a9 100644
--- a/osu.Game/Screens/Select/Details/AdvancedStats.cs
+++ b/osu.Game/Screens/Select/Details/AdvancedStats.cs
@@ -16,6 +16,7 @@ using System.Collections.Generic;
 using osu.Game.Rulesets.Mods;
 using System.Linq;
 using osu.Framework.Threading;
+using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Overlays.Settings;
 
@@ -26,7 +27,8 @@ namespace osu.Game.Screens.Select.Details
         [Resolved]
         private IBindable<IReadOnlyList<Mod>> mods { get; set; }
 
-        private readonly StatisticRow firstValue, hpDrain, accuracy, approachRate, starDifficulty;
+        protected readonly StatisticRow FirstValue, HpDrain, Accuracy, ApproachRate;
+        private readonly StatisticRow starDifficulty;
 
         private BeatmapInfo beatmap;
 
@@ -52,10 +54,10 @@ namespace osu.Game.Screens.Select.Details
                 Spacing = new Vector2(4f),
                 Children = new[]
                 {
-                    firstValue = new StatisticRow(), //circle size/key amount
-                    hpDrain = new StatisticRow { Title = "HP Drain" },
-                    accuracy = new StatisticRow { Title = "Accuracy" },
-                    approachRate = new StatisticRow { Title = "Approach Rate" },
+                    FirstValue = new StatisticRow(), //circle size/key amount
+                    HpDrain = new StatisticRow { Title = "HP Drain" },
+                    Accuracy = new StatisticRow { Title = "Accuracy" },
+                    ApproachRate = new StatisticRow { Title = "Approach Rate" },
                     starDifficulty = new StatisticRow(10, true) { Title = "Star Difficulty" },
                 },
             };
@@ -122,24 +124,24 @@ namespace osu.Game.Screens.Select.Details
                 case 3:
                     // Account for mania differences locally for now
                     // Eventually this should be handled in a more modular way, allowing rulesets to return arbitrary difficulty attributes
-                    firstValue.Title = "Key Count";
-                    firstValue.Value = (baseDifficulty?.CircleSize ?? 0, null);
+                    FirstValue.Title = "Key Count";
+                    FirstValue.Value = (baseDifficulty?.CircleSize ?? 0, null);
                     break;
 
                 default:
-                    firstValue.Title = "Circle Size";
-                    firstValue.Value = (baseDifficulty?.CircleSize ?? 0, adjustedDifficulty?.CircleSize);
+                    FirstValue.Title = "Circle Size";
+                    FirstValue.Value = (baseDifficulty?.CircleSize ?? 0, adjustedDifficulty?.CircleSize);
                     break;
             }
 
             starDifficulty.Value = ((float)(Beatmap?.StarDifficulty ?? 0), null);
 
-            hpDrain.Value = (baseDifficulty?.DrainRate ?? 0, adjustedDifficulty?.DrainRate);
-            accuracy.Value = (baseDifficulty?.OverallDifficulty ?? 0, adjustedDifficulty?.OverallDifficulty);
-            approachRate.Value = (baseDifficulty?.ApproachRate ?? 0, adjustedDifficulty?.ApproachRate);
+            HpDrain.Value = (baseDifficulty?.DrainRate ?? 0, adjustedDifficulty?.DrainRate);
+            Accuracy.Value = (baseDifficulty?.OverallDifficulty ?? 0, adjustedDifficulty?.OverallDifficulty);
+            ApproachRate.Value = (baseDifficulty?.ApproachRate ?? 0, adjustedDifficulty?.ApproachRate);
         }
 
-        private class StatisticRow : Container, IHasAccentColour
+        public class StatisticRow : Container, IHasAccentColour
         {
             private const float value_width = 25;
             private const float name_width = 70;
@@ -147,7 +149,8 @@ namespace osu.Game.Screens.Select.Details
             private readonly float maxValue;
             private readonly bool forceDecimalPlaces;
             private readonly OsuSpriteText name, valueText;
-            private readonly Bar bar, modBar;
+            private readonly Bar bar;
+            public readonly Bar ModBar;
 
             [Resolved]
             private OsuColour colours { get; set; }
@@ -173,14 +176,14 @@ namespace osu.Game.Screens.Select.Details
                     bar.Length = value.baseValue / maxValue;
 
                     valueText.Text = (value.adjustedValue ?? value.baseValue).ToString(forceDecimalPlaces ? "0.00" : "0.##");
-                    modBar.Length = (value.adjustedValue ?? 0) / maxValue;
+                    ModBar.Length = (value.adjustedValue ?? 0) / maxValue;
 
-                    if (value.adjustedValue > value.baseValue)
-                        modBar.AccentColour = valueText.Colour = colours.Red;
+                    if (Precision.AlmostEquals(value.baseValue, value.adjustedValue ?? value.baseValue, 0.05f))
+                        ModBar.AccentColour = valueText.Colour = Color4.White;
+                    else if (value.adjustedValue > value.baseValue)
+                        ModBar.AccentColour = valueText.Colour = colours.Red;
                     else if (value.adjustedValue < value.baseValue)
-                        modBar.AccentColour = valueText.Colour = colours.BlueDark;
-                    else
-                        modBar.AccentColour = valueText.Colour = Color4.White;
+                        ModBar.AccentColour = valueText.Colour = colours.BlueDark;
                 }
             }
 
@@ -217,7 +220,7 @@ namespace osu.Game.Screens.Select.Details
                         BackgroundColour = Color4.White.Opacity(0.5f),
                         Padding = new MarginPadding { Left = name_width + 10, Right = value_width + 10 },
                     },
-                    modBar = new Bar
+                    ModBar = new Bar
                     {
                         Origin = Anchor.CentreLeft,
                         Anchor = Anchor.CentreLeft,
diff --git a/osu.Game/Screens/Select/FilterControl.cs b/osu.Game/Screens/Select/FilterControl.cs
index c851b201d7..6a03cfb68e 100644
--- a/osu.Game/Screens/Select/FilterControl.cs
+++ b/osu.Game/Screens/Select/FilterControl.cs
@@ -149,8 +149,8 @@ namespace osu.Game.Screens.Select
         private readonly IBindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
 
         private readonly Bindable<bool> showConverted = new Bindable<bool>();
-        private readonly Bindable<double> minimumStars = new Bindable<double>();
-        private readonly Bindable<double> maximumStars = new Bindable<double>();
+        private readonly Bindable<double> minimumStars = new BindableDouble();
+        private readonly Bindable<double> maximumStars = new BindableDouble();
 
         public readonly Box Background;
 
diff --git a/osu.Game/Tests/Visual/ScrollingTestContainer.cs b/osu.Game/Tests/Visual/ScrollingTestContainer.cs
index bdad3d278c..161ebe7030 100644
--- a/osu.Game/Tests/Visual/ScrollingTestContainer.cs
+++ b/osu.Game/Tests/Visual/ScrollingTestContainer.cs
@@ -47,7 +47,7 @@ namespace osu.Game.Tests.Visual
             public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
             IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
 
-            public readonly Bindable<double> TimeRange = new Bindable<double>(1000) { Value = 1000 };
+            public readonly Bindable<double> TimeRange = new BindableDouble(1000) { Value = 1000 };
             IBindable<double> IScrollingInfo.TimeRange => TimeRange;
 
             public readonly TestScrollAlgorithm Algorithm = new TestScrollAlgorithm();