diff --git a/osu.Game.Benchmarks/BenchmarkRuleset.cs b/osu.Game.Benchmarks/BenchmarkRuleset.cs
index 63c99dcb2b..f3d678a2b0 100644
--- a/osu.Game.Benchmarks/BenchmarkRuleset.cs
+++ b/osu.Game.Benchmarks/BenchmarkRuleset.cs
@@ -39,5 +39,11 @@ namespace osu.Game.Benchmarks
         {
             ruleset.GetAllMods().Consume(new Consumer());
         }
+
+        [Benchmark]
+        public void BenchmarkGetAllModsForReference()
+        {
+            ruleset.GetAllModsForReference().Consume(new Consumer());
+        }
     }
 }
diff --git a/osu.Game.Tournament/Components/TournamentModIcon.cs b/osu.Game.Tournament/Components/TournamentModIcon.cs
index 43ac92d285..709e99b165 100644
--- a/osu.Game.Tournament/Components/TournamentModIcon.cs
+++ b/osu.Game.Tournament/Components/TournamentModIcon.cs
@@ -49,7 +49,7 @@ namespace osu.Game.Tournament.Components
             }
 
             var ruleset = rulesets.GetRuleset(ladderInfo.Ruleset.Value?.ID ?? 0);
-            var modIcon = ruleset?.CreateInstance().GetAllMods().FirstOrDefault(mod => mod.Acronym == modAcronym);
+            var modIcon = ruleset?.CreateInstance().GetModForAcronym(modAcronym);
 
             if (modIcon == null)
                 return;
diff --git a/osu.Game/Online/API/APIMod.cs b/osu.Game/Online/API/APIMod.cs
index 596d567480..f31f8bc92a 100644
--- a/osu.Game/Online/API/APIMod.cs
+++ b/osu.Game/Online/API/APIMod.cs
@@ -48,7 +48,7 @@ namespace osu.Game.Online.API
 
         public Mod ToMod(Ruleset ruleset)
         {
-            Mod resultMod = ruleset.GetAllMods().FirstOrDefault(m => m.Acronym == Acronym);
+            Mod resultMod = ruleset.GetModForAcronym(Acronym);
 
             if (resultMod == null)
                 throw new InvalidOperationException($"There is no mod in the ruleset ({ruleset.ShortName}) matching the acronym {Acronym}.");
diff --git a/osu.Game/Online/API/Requests/Responses/APILegacyScoreInfo.cs b/osu.Game/Online/API/Requests/Responses/APILegacyScoreInfo.cs
index 1b394185fd..e74db7de6e 100644
--- a/osu.Game/Online/API/Requests/Responses/APILegacyScoreInfo.cs
+++ b/osu.Game/Online/API/Requests/Responses/APILegacyScoreInfo.cs
@@ -23,7 +23,7 @@ namespace osu.Game.Online.API.Requests.Responses
 
             var rulesetInstance = ruleset.CreateInstance();
 
-            var mods = Mods != null ? rulesetInstance.GetAllMods().Where(mod => Mods.Contains(mod.Acronym)).ToArray() : Array.Empty<Mod>();
+            var mods = Mods != null ? Mods.Select(acronym => rulesetInstance.GetModForAcronym(acronym)).Where(m => m != null).ToArray() : Array.Empty<Mod>();
 
             // all API scores provided by this class are considered to be legacy.
             mods = mods.Append(rulesetInstance.GetAllMods().OfType<ModClassic>().Single()).ToArray();
diff --git a/osu.Game/Overlays/BeatmapSet/LeaderboardModSelector.cs b/osu.Game/Overlays/BeatmapSet/LeaderboardModSelector.cs
index 5b903372fd..517da11c8c 100644
--- a/osu.Game/Overlays/BeatmapSet/LeaderboardModSelector.cs
+++ b/osu.Game/Overlays/BeatmapSet/LeaderboardModSelector.cs
@@ -54,7 +54,7 @@ namespace osu.Game.Overlays.BeatmapSet
                 return;
 
             modsContainer.Add(new ModButton(new ModNoMod()));
-            modsContainer.AddRange(ruleset.NewValue.CreateInstance().GetAllMods().Where(m => m.UserPlayable).Select(m => new ModButton(m)));
+            modsContainer.AddRange(ruleset.NewValue.CreateInstance().GetAllModsForReference().Where(m => m.UserPlayable).Select(m => new ModButton(m)));
 
             modsContainer.ForEach(button =>
             {
diff --git a/osu.Game/Overlays/Mods/IncompatibilityDisplayingModButton.cs b/osu.Game/Overlays/Mods/IncompatibilityDisplayingModButton.cs
index c8e44ee159..8d0746f24d 100644
--- a/osu.Game/Overlays/Mods/IncompatibilityDisplayingModButton.cs
+++ b/osu.Game/Overlays/Mods/IncompatibilityDisplayingModButton.cs
@@ -107,7 +107,7 @@ namespace osu.Game.Overlays.Mods
 
                 var incompatibleTypes = mod.IncompatibleMods;
 
-                var allMods = ruleset.Value.CreateInstance().GetAllMods();
+                var allMods = ruleset.Value.CreateInstance().GetAllModsForReference();
 
                 incompatibleMods.Value = allMods.Where(m => m.GetType() != mod.GetType() && incompatibleTypes.Any(t => t.IsInstanceOfType(m))).ToList();
                 incompatibleText.Text = incompatibleMods.Value.Any() ? "Incompatible with:" : "Compatible with all mods";
diff --git a/osu.Game/Rulesets/Ruleset.cs b/osu.Game/Rulesets/Ruleset.cs
index de62cf8d33..2f65bd76a4 100644
--- a/osu.Game/Rulesets/Ruleset.cs
+++ b/osu.Game/Rulesets/Ruleset.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics;
@@ -23,6 +24,7 @@ using osu.Game.Scoring;
 using osu.Game.Skinning;
 using osu.Game.Users;
 using JetBrains.Annotations;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Testing;
@@ -38,6 +40,13 @@ namespace osu.Game.Rulesets
     {
         public RulesetInfo RulesetInfo { get; internal set; }
 
+        /// <summary>
+        /// Returns fresh instances of all mods.
+        /// </summary>
+        /// <remarks>
+        /// This comes with considerable allocation overhead. If only accessing for reference purposes (ie. not changing bindables / settings)
+        /// use <see cref="GetAllModsForReference"/> instead.
+        /// </remarks>
         public IEnumerable<Mod> GetAllMods() => Enum.GetValues(typeof(ModType)).Cast<ModType>()
                                                     // Confine all mods of each mod type into a single IEnumerable<Mod>
                                                     .SelectMany(GetModsFor)
@@ -46,6 +55,37 @@ namespace osu.Game.Rulesets
                                                     // Resolve MultiMods as their .Mods property
                                                     .SelectMany(mod => (mod as MultiMod)?.Mods ?? new[] { mod });
 
+        private static readonly ConcurrentDictionary<int, Mod[]> mod_reference_cache = new ConcurrentDictionary<int, Mod[]>();
+
+        /// <summary>
+        /// Returns all mods for a query-only purpose.
+        /// Bindables should not be considered usable when retrieving via this method (use <see cref="GetAllMods"/> instead).
+        /// </summary>
+        public IEnumerable<Mod> GetAllModsForReference()
+        {
+            if (!(RulesetInfo.ID is int id))
+                return GetAllMods();
+
+            if (!mod_reference_cache.TryGetValue(id, out var mods))
+                mod_reference_cache[id] = mods = GetAllMods().ToArray();
+
+            return mods;
+        }
+
+        /// <summary>
+        /// Returns a fresh instance of the mod matching the specified acronym.
+        /// </summary>
+        /// <param name="acronym">The acronym to query for .</param>
+        public Mod GetModForAcronym(string acronym)
+        {
+            var type = GetAllModsForReference().FirstOrDefault(m => m.Acronym == acronym)?.GetType();
+
+            if (type != null)
+                return (Mod)Activator.CreateInstance(type);
+
+            return null;
+        }
+
         public abstract IEnumerable<Mod> GetModsFor(ModType type);
 
         /// <summary>