diff --git a/PerformanceCalculator/Difficulty/DifficultyCommand.cs b/PerformanceCalculator/Difficulty/DifficultyCommand.cs
index 47b3158f8..8bdb8fd89 100644
--- a/PerformanceCalculator/Difficulty/DifficultyCommand.cs
+++ b/PerformanceCalculator/Difficulty/DifficultyCommand.cs
@@ -12,9 +12,7 @@
 using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Online.API;
-using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
-using osu.Game.Rulesets.Mods;
 
 namespace PerformanceCalculator.Difficulty
 {
@@ -37,8 +35,9 @@ public class DifficultyCommand : ProcessorCommand
         public string[] Mods { get; }
 
         [UsedImplicitly]
-        [Option(Template = "-nc|--no-classic", Description = "Excludes the classic mod.")]
-        public bool NoClassicMod { get; }
+        [Option(CommandOptionType.MultipleValue, Template = "-o|--mod-option <option>",
+            Description = "The options of mods, with one for each setting. Specified as acryonym_settingkey=value. Example: DT_speed_change=1.35")]
+        public string[] ModOptions { get; set; } = [];
 
         public override void Execute()
         {
@@ -67,9 +66,6 @@ public override void Execute()
                 string json = JsonConvert.SerializeObject(resultSet);
 
                 Console.WriteLine(json);
-
-                if (OutputFile != null)
-                    File.WriteAllText(OutputFile, json);
             }
             else
             {
@@ -124,7 +120,7 @@ private Result processBeatmap(WorkingBeatmap beatmap)
         {
             // Get the ruleset
             var ruleset = LegacyHelper.GetRulesetFromLegacyID(Ruleset ?? beatmap.BeatmapInfo.Ruleset.OnlineID);
-            var mods = NoClassicMod ? getMods(ruleset) : LegacyHelper.FilterDifficultyAdjustmentMods(beatmap.BeatmapInfo, ruleset, getMods(ruleset));
+            var mods = ParseMods(ruleset, Mods, ModOptions);
             var attributes = ruleset.CreateDifficultyCalculator(beatmap).Calculate(mods);
 
             return new Result
@@ -137,26 +133,6 @@ private Result processBeatmap(WorkingBeatmap beatmap)
             };
         }
 
-        private Mod[] getMods(Ruleset ruleset)
-        {
-            var mods = new List<Mod>();
-            if (Mods == null)
-                return Array.Empty<Mod>();
-
-            var availableMods = ruleset.CreateAllMods().ToList();
-
-            foreach (var modString in Mods)
-            {
-                Mod newMod = availableMods.FirstOrDefault(m => string.Equals(m.Acronym, modString, StringComparison.CurrentCultureIgnoreCase));
-                if (newMod == null)
-                    throw new ArgumentException($"Invalid mod provided: {modString}");
-
-                mods.Add(newMod);
-            }
-
-            return mods.ToArray();
-        }
-
         private class ResultSet
         {
             [JsonProperty("errors")]
diff --git a/PerformanceCalculator/Difficulty/LegacyScoreAttributesCommand.cs b/PerformanceCalculator/Difficulty/LegacyScoreAttributesCommand.cs
index 79a7573b5..053287b7d 100644
--- a/PerformanceCalculator/Difficulty/LegacyScoreAttributesCommand.cs
+++ b/PerformanceCalculator/Difficulty/LegacyScoreAttributesCommand.cs
@@ -62,9 +62,6 @@ public override void Execute()
                 string json = JsonConvert.SerializeObject(resultSet);
 
                 Console.WriteLine(json);
-
-                if (OutputFile != null)
-                    File.WriteAllText(OutputFile, json);
             }
             else
             {
@@ -115,11 +112,8 @@ public override void Execute()
 
         private Result processBeatmap(WorkingBeatmap beatmap)
         {
-            // Get the ruleset
             var ruleset = LegacyHelper.GetRulesetFromLegacyID(Ruleset ?? beatmap.BeatmapInfo.Ruleset.OnlineID);
-
-            // bit of a hack to discard non-legacy mods.
-            var mods = ruleset.ConvertFromLegacyMods(ruleset.ConvertToLegacyMods(getMods(ruleset))).ToList();
+            var mods = getMods(ruleset);
 
             var legacyRuleset = (ILegacyRuleset)ruleset;
             var simulator = legacyRuleset.CreateLegacyScoreSimulator();
diff --git a/PerformanceCalculator/Difficulty/LegacyScoreConversionCommand.cs b/PerformanceCalculator/Difficulty/LegacyScoreConversionCommand.cs
index 396d81f15..190baa3ef 100644
--- a/PerformanceCalculator/Difficulty/LegacyScoreConversionCommand.cs
+++ b/PerformanceCalculator/Difficulty/LegacyScoreConversionCommand.cs
@@ -66,10 +66,8 @@ public virtual void OnExecute(CommandLineApplication app, IConsole console)
             var ruleset = LegacyHelper.GetRulesetFromLegacyID(Ruleset);
 
             var workingBeatmap = ProcessorWorkingBeatmap.FromFileOrId(Beatmap);
-            // bit of a hack to discard non-legacy mods.
-            var mods = ruleset.ConvertFromLegacyMods(ruleset.ConvertToLegacyMods(getMods(ruleset)))
-                              .Append(ruleset.CreateMod<ModClassic>())
-                              .ToArray();
+            Mod[] mods = [ruleset.CreateMod<ModClassic>(), .. getMods(ruleset)];
+
             var beatmap = workingBeatmap.GetPlayableBeatmap(ruleset.RulesetInfo, mods);
 
             var scoreInfo = new ScoreInfo(beatmap.BeatmapInfo, ruleset.RulesetInfo)
diff --git a/PerformanceCalculator/Leaderboard/LeaderboardCommand.cs b/PerformanceCalculator/Leaderboard/LeaderboardCommand.cs
index 5a22c4924..a9455ae3a 100644
--- a/PerformanceCalculator/Leaderboard/LeaderboardCommand.cs
+++ b/PerformanceCalculator/Leaderboard/LeaderboardCommand.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using Alba.CsConsoleFormat;
 using JetBrains.Annotations;
@@ -62,7 +61,7 @@ public override void Execute()
                     var score = new ProcessorScoreDecoder(working).Parse(scoreInfo);
 
                     var difficultyCalculator = ruleset.CreateDifficultyCalculator(working);
-                    var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.FilterDifficultyAdjustmentMods(working.BeatmapInfo, ruleset, scoreInfo.Mods).ToArray());
+                    var difficultyAttributes = difficultyCalculator.Calculate(scoreInfo.Mods);
                     var performanceCalculator = ruleset.CreatePerformanceCalculator();
 
                     plays.Add((performanceCalculator?.Calculate(score.ScoreInfo, difficultyAttributes).Total ?? 0, play.PP ?? 0.0));
@@ -98,9 +97,6 @@ public override void Execute()
                 var json = JsonConvert.SerializeObject(calculatedPlayers);
 
                 Console.Write(json);
-
-                if (OutputFile != null)
-                    File.WriteAllText(OutputFile, json);
             }
             else
             {
diff --git a/PerformanceCalculator/LegacyHelper.cs b/PerformanceCalculator/LegacyHelper.cs
index 7d2595b61..0449f0d93 100644
--- a/PerformanceCalculator/LegacyHelper.cs
+++ b/PerformanceCalculator/LegacyHelper.cs
@@ -2,16 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Linq;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.Legacy;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Catch.Difficulty;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mania.Difficulty;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Difficulty;
 using osu.Game.Rulesets.Taiko;
@@ -63,54 +59,6 @@ public static string GetRulesetShortNameFromId(int id)
             }
         }
 
-        public const LegacyMods KEY_MODS = LegacyMods.Key1 | LegacyMods.Key2 | LegacyMods.Key3 | LegacyMods.Key4 | LegacyMods.Key5 | LegacyMods.Key6 | LegacyMods.Key7 | LegacyMods.Key8
-                                           | LegacyMods.Key9 | LegacyMods.KeyCoop;
-
-        // See: https://github.com/ppy/osu-queue-score-statistics/blob/2264bfa68e14bb16ec71a7cac2072bdcfaf565b6/osu.Server.Queues.ScoreStatisticsProcessor/Helpers/LegacyModsHelper.cs
-        public static LegacyMods MaskRelevantMods(LegacyMods mods, bool isConvertedBeatmap, int rulesetId)
-        {
-            LegacyMods relevantMods = LegacyMods.DoubleTime | LegacyMods.HalfTime | LegacyMods.HardRock | LegacyMods.Easy;
-
-            switch (rulesetId)
-            {
-                case 0:
-                    if ((mods & LegacyMods.Flashlight) > 0)
-                        relevantMods |= LegacyMods.Flashlight | LegacyMods.Hidden | LegacyMods.TouchDevice;
-                    else
-                        relevantMods |= LegacyMods.Flashlight | LegacyMods.TouchDevice;
-                    break;
-
-                case 3:
-                    if (isConvertedBeatmap)
-                        relevantMods |= KEY_MODS;
-                    break;
-            }
-
-            return mods & relevantMods;
-        }
-
-        /// <summary>
-        /// Transforms a given <see cref="Mod"/> combination into one which is applicable to legacy scores.
-        /// This is used to match osu!stable/osu!web calculations for the time being, until such a point that these mods do get considered.
-        /// </summary>
-        public static LegacyMods ConvertToLegacyDifficultyAdjustmentMods(BeatmapInfo beatmapInfo, Ruleset ruleset, Mod[] mods)
-        {
-            var legacyMods = ruleset.ConvertToLegacyMods(mods);
-
-            // mods that are not represented in `LegacyMods` (but we can approximate them well enough with others)
-            if (mods.Any(mod => mod is ModDaycore))
-                legacyMods |= LegacyMods.HalfTime;
-
-            return MaskRelevantMods(legacyMods, ruleset.RulesetInfo.OnlineID != beatmapInfo.Ruleset.OnlineID, ruleset.RulesetInfo.OnlineID);
-        }
-
-        /// <summary>
-        /// Transforms a given <see cref="Mod"/> combination into one which is applicable to legacy scores.
-        /// This is used to match osu!stable/osu!web calculations for the time being, until such a point that these mods do get considered.
-        /// </summary>
-        public static Mod[] FilterDifficultyAdjustmentMods(BeatmapInfo beatmapInfo, Ruleset ruleset, Mod[] mods)
-            => ruleset.ConvertFromLegacyMods(ConvertToLegacyDifficultyAdjustmentMods(beatmapInfo, ruleset, mods)).ToArray();
-
         public static DifficultyAttributes CreateDifficultyAttributes(int legacyId)
         {
             switch (legacyId)
diff --git a/PerformanceCalculator/Performance/ReplayPerformanceCommand.cs b/PerformanceCalculator/Performance/ReplayPerformanceCommand.cs
index 116052602..8e118e671 100644
--- a/PerformanceCalculator/Performance/ReplayPerformanceCommand.cs
+++ b/PerformanceCalculator/Performance/ReplayPerformanceCommand.cs
@@ -9,7 +9,6 @@
 using osu.Game.Database;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring.Legacy;
 using osu.Game.Scoring;
 using osu.Game.Scoring.Legacy;
@@ -38,11 +37,8 @@ public override void Execute()
             var workingBeatmap = ProcessorWorkingBeatmap.FromFileOrId(score.ScoreInfo.BeatmapInfo!.OnlineID.ToString());
             var playableBeatmap = workingBeatmap.GetPlayableBeatmap(ruleset.RulesetInfo, score.ScoreInfo.Mods);
 
-            Mod[] difficultyMods = score.ScoreInfo.Mods;
-
             if (score.ScoreInfo.IsLegacyScore)
             {
-                difficultyMods = LegacyHelper.FilterDifficultyAdjustmentMods(workingBeatmap.BeatmapInfo, ruleset, difficultyMods);
                 score.ScoreInfo.LegacyTotalScore = (int)score.ScoreInfo.TotalScore;
                 LegacyScoreDecoder.PopulateMaximumStatistics(score.ScoreInfo, workingBeatmap);
                 StandardisedScoreMigrationTools.UpdateFromLegacy(
@@ -52,7 +48,7 @@ public override void Execute()
                     ((ILegacyRuleset)ruleset).CreateLegacyScoreSimulator().Simulate(workingBeatmap, playableBeatmap));
             }
 
-            var difficultyAttributes = ruleset.CreateDifficultyCalculator(workingBeatmap).Calculate(difficultyMods);
+            var difficultyAttributes = ruleset.CreateDifficultyCalculator(workingBeatmap).Calculate(score.ScoreInfo.Mods);
             var performanceCalculator = score.ScoreInfo.Ruleset.CreateInstance().CreatePerformanceCalculator();
             var performanceAttributes = performanceCalculator?.Calculate(score.ScoreInfo, difficultyAttributes);
 
diff --git a/PerformanceCalculator/Performance/ScorePerformanceCommand.cs b/PerformanceCalculator/Performance/ScorePerformanceCommand.cs
index c8c6dbe7f..0bc18179b 100644
--- a/PerformanceCalculator/Performance/ScorePerformanceCommand.cs
+++ b/PerformanceCalculator/Performance/ScorePerformanceCommand.cs
@@ -16,6 +16,7 @@
 using osu.Game.Rulesets.Catch.Difficulty;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania.Difficulty;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty;
 using osu.Game.Rulesets.Taiko.Difficulty;
 using osu.Game.Scoring;
@@ -46,13 +47,13 @@ public override void Execute()
 
             if (OnlineAttributes)
             {
-                LegacyMods legacyMods = LegacyHelper.ConvertToLegacyDifficultyAdjustmentMods(workingBeatmap.BeatmapInfo, ruleset, score.Mods);
+                LegacyMods legacyMods = convertToLegacyMods(workingBeatmap.BeatmapInfo, ruleset, score.Mods);
                 attributes = queryApiAttributes(apiScore.BeatmapID, apiScore.RulesetID, legacyMods);
             }
             else
             {
                 var difficultyCalculator = ruleset.CreateDifficultyCalculator(workingBeatmap);
-                attributes = difficultyCalculator.Calculate(LegacyHelper.FilterDifficultyAdjustmentMods(workingBeatmap.BeatmapInfo, ruleset, score.Mods));
+                attributes = difficultyCalculator.Calculate(score.Mods);
             }
 
             var performanceCalculator = ruleset.CreatePerformanceCalculator();
@@ -121,6 +122,47 @@ DifficultyAttributes getMergedAttributes<TAttributes>(APIBeatmap apiBeatmap)
             }
         }
 
+        /// <summary>
+        /// Transforms a given <see cref="Mod"/> combination into one which is applicable to legacy scores.
+        /// This should only be used to match performance calculations using databased attributes.
+        /// </summary>
+        private static LegacyMods convertToLegacyMods(BeatmapInfo beatmapInfo, Ruleset ruleset, Mod[] mods)
+        {
+            var legacyMods = ruleset.ConvertToLegacyMods(mods);
+
+            // mods that are not represented in `LegacyMods` (but we can approximate them well enough with others)
+            if (mods.Any(mod => mod is ModDaycore))
+                legacyMods |= LegacyMods.HalfTime;
+
+            // See: https://github.com/ppy/osu-queue-score-statistics/blob/2264bfa68e14bb16ec71a7cac2072bdcfaf565b6/osu.Server.Queues.ScoreStatisticsProcessor/Helpers/LegacyModsHelper.cs
+            static LegacyMods maskRelevantMods(LegacyMods mods, bool isConvertedBeatmap, int rulesetId)
+            {
+                const LegacyMods key_mods = LegacyMods.Key1 | LegacyMods.Key2 | LegacyMods.Key3 | LegacyMods.Key4 | LegacyMods.Key5 | LegacyMods.Key6 | LegacyMods.Key7 | LegacyMods.Key8
+                                            | LegacyMods.Key9 | LegacyMods.KeyCoop;
+
+                LegacyMods relevantMods = LegacyMods.DoubleTime | LegacyMods.HalfTime | LegacyMods.HardRock | LegacyMods.Easy;
+
+                switch (rulesetId)
+                {
+                    case 0:
+                        if ((mods & LegacyMods.Flashlight) > 0)
+                            relevantMods |= LegacyMods.Flashlight | LegacyMods.Hidden | LegacyMods.TouchDevice;
+                        else
+                            relevantMods |= LegacyMods.Flashlight | LegacyMods.TouchDevice;
+                        break;
+
+                    case 3:
+                        if (isConvertedBeatmap)
+                            relevantMods |= key_mods;
+                        break;
+                }
+
+                return mods & relevantMods;
+            }
+
+            return maskRelevantMods(legacyMods, ruleset.RulesetInfo.OnlineID != beatmapInfo.Ruleset.OnlineID, ruleset.RulesetInfo.OnlineID);
+        }
+
         [JsonObject(MemberSerialization.OptIn)]
         private class AttributesResponse<T>
             where T : DifficultyAttributes
diff --git a/PerformanceCalculator/PerformanceCalculator.csproj b/PerformanceCalculator/PerformanceCalculator.csproj
index 26ce15f1c..ef2d47157 100644
--- a/PerformanceCalculator/PerformanceCalculator.csproj
+++ b/PerformanceCalculator/PerformanceCalculator.csproj
@@ -3,14 +3,15 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>12.0</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Alba.CsConsoleFormat" Version="1.0.0" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.1.0" />
-    <PackageReference Include="ppy.osu.Game" Version="2024.130.2" />
-    <PackageReference Include="ppy.osu.Game.Rulesets.Osu" Version="2024.130.2" />
-    <PackageReference Include="ppy.osu.Game.Rulesets.Taiko" Version="2024.130.2" />
-    <PackageReference Include="ppy.osu.Game.Rulesets.Catch" Version="2024.130.2" />
-    <PackageReference Include="ppy.osu.Game.Rulesets.Mania" Version="2024.130.2" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.1.1" />
+    <PackageReference Include="ppy.osu.Game" Version="2024.1023.0" />
+    <PackageReference Include="ppy.osu.Game.Rulesets.Osu" Version="2024.1023.0" />
+    <PackageReference Include="ppy.osu.Game.Rulesets.Taiko" Version="2024.1023.0" />
+    <PackageReference Include="ppy.osu.Game.Rulesets.Catch" Version="2024.1023.0" />
+    <PackageReference Include="ppy.osu.Game.Rulesets.Mania" Version="2024.1023.0" />
   </ItemGroup>
 </Project>
diff --git a/PerformanceCalculator/ProcessorCommand.cs b/PerformanceCalculator/ProcessorCommand.cs
index deef8047b..392631c00 100644
--- a/PerformanceCalculator/ProcessorCommand.cs
+++ b/PerformanceCalculator/ProcessorCommand.cs
@@ -12,7 +12,9 @@
 using McMaster.Extensions.CommandLineUtils;
 using Newtonsoft.Json;
 using osu.Game.Online.API;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 
@@ -26,10 +28,6 @@ public abstract class ProcessorCommand
         /// </summary>
         public IConsole Console { get; private set; }
 
-        [UsedImplicitly]
-        [Option(Template = "-o|--output <file.txt>", Description = "Output results to text file.")]
-        public string OutputFile { get; }
-
         [UsedImplicitly]
         [Option(Template = "-j|--json", Description = "Output results as JSON.")]
         public bool OutputJson { get; }
@@ -65,9 +63,6 @@ public void OutputPerformance(ScoreInfo score, PerformanceAttributes performance
                 string json = JsonConvert.SerializeObject(result, Formatting.Indented);
 
                 Console.WriteLine(json);
-
-                if (OutputFile != null)
-                    File.WriteAllText(OutputFile, json);
             }
             else
             {
@@ -131,8 +126,6 @@ public void OutputDocument(Document document)
                 str = string.Join('\n', lines);
 
                 Console.Write(str);
-                if (OutputFile != null)
-                    File.WriteAllText(OutputFile, str);
             }
         }
 
@@ -140,6 +133,37 @@ public virtual void Execute()
         {
         }
 
+        public static Mod[] ParseMods(Ruleset ruleset, string[] acronyms, string[] options)
+        {
+            acronyms ??= [];
+            options ??= [];
+
+            if (acronyms.Length == 0)
+                return [];
+
+            var mods = new List<Mod>();
+
+            foreach (var acronym in acronyms)
+            {
+                APIMod mod = new APIMod { Acronym = acronym };
+
+                foreach (string optionString in options.Where(x => x.StartsWith($"{acronym}_", StringComparison.CurrentCultureIgnoreCase)))
+                {
+                    string optionTuple = optionString[(acronym.Length + 1)..];
+
+                    string[] split = optionTuple.Split('=');
+                    if (split.Length != 2)
+                        throw new ArgumentException($"Invalid mod-option format (key=value): {optionTuple}");
+
+                    mod.Settings[split[0]] = split[1];
+                }
+
+                mods.Add(mod.ToMod(ruleset));
+            }
+
+            return mods.ToArray();
+        }
+
         private class Result
         {
             [JsonProperty("score")]
diff --git a/PerformanceCalculator/Profile/ProfileCommand.cs b/PerformanceCalculator/Profile/ProfileCommand.cs
index 050ae51a3..7cb90d6f3 100644
--- a/PerformanceCalculator/Profile/ProfileCommand.cs
+++ b/PerformanceCalculator/Profile/ProfileCommand.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using Alba.CsConsoleFormat;
 using JetBrains.Annotations;
@@ -52,7 +51,7 @@ public override void Execute()
                 var score = new ProcessorScoreDecoder(working).Parse(scoreInfo);
 
                 var difficultyCalculator = ruleset.CreateDifficultyCalculator(working);
-                var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.FilterDifficultyAdjustmentMods(working.BeatmapInfo, ruleset, scoreInfo.Mods).ToArray());
+                var difficultyAttributes = difficultyCalculator.Calculate(scoreInfo.Mods);
                 var performanceCalculator = ruleset.CreatePerformanceCalculator();
 
                 var ppAttributes = performanceCalculator?.Calculate(score.ScoreInfo, difficultyAttributes);
@@ -109,9 +108,6 @@ public override void Execute()
                 });
 
                 Console.Write(json);
-
-                if (OutputFile != null)
-                    File.WriteAllText(OutputFile, json);
             }
             else
             {
diff --git a/PerformanceCalculator/Simulate/CatchSimulateCommand.cs b/PerformanceCalculator/Simulate/CatchSimulateCommand.cs
index b18958f49..146508f5c 100644
--- a/PerformanceCalculator/Simulate/CatchSimulateCommand.cs
+++ b/PerformanceCalculator/Simulate/CatchSimulateCommand.cs
@@ -17,29 +17,14 @@ namespace PerformanceCalculator.Simulate
     [Command(Name = "catch", Description = "Computes the performance (pp) of a simulated osu!catch play.")]
     public class CatchSimulateCommand : SimulateCommand
     {
-        [UsedImplicitly]
-        [Option(Template = "-a|--accuracy <accuracy>", Description = "Accuracy. Enter as decimal 0-100. Defaults to 100."
-                                                                     + " Scales hit results as well and is rounded to the nearest possible value for the beatmap.")]
-        public override double Accuracy { get; } = 100;
-
         [UsedImplicitly]
         [Option(Template = "-c|--combo <combo>", Description = "Maximum combo during play. Defaults to beatmap maximum.")]
         public override int? Combo { get; }
 
         [UsedImplicitly]
-        [Option(Template = "-C|--percent-combo <combo>", Description = "Percentage of beatmap maximum combo achieved. Alternative to combo option."
-                                                                       + " Enter as decimal 0-100.")]
+        [Option(Template = "-C|--percent-combo <combo>", Description = "Percentage of beatmap maximum combo achieved. Alternative to combo option. Enter as decimal 0-100.")]
         public override double PercentCombo { get; } = 100;
 
-        [UsedImplicitly]
-        [Option(CommandOptionType.MultipleValue, Template = "-m|--mod <mod>", Description = "One for each mod. The mods to compute the performance with."
-                                                                                            + " Values: hr, dt, hd, fl, ez, etc...")]
-        public override string[] Mods { get; }
-
-        [UsedImplicitly]
-        [Option(Template = "-X|--misses <misses>", Description = "Number of misses. Defaults to 0.")]
-        public override int Misses { get; }
-
         [UsedImplicitly]
         [Option(Template = "-T|--tiny-droplets <tinys>", Description = "Number of tiny droplets hit. Will override accuracy if used. Otherwise is automatically calculated.")]
         public override int? Mehs { get; }
@@ -50,12 +35,11 @@ public class CatchSimulateCommand : SimulateCommand
 
         public override Ruleset Ruleset => new CatchRuleset();
 
-        protected override int GetMaxCombo(IBeatmap beatmap) => beatmap.HitObjects.Count(h => h is Fruit)
-                                                                + beatmap.HitObjects.OfType<JuiceStream>().SelectMany(j => j.NestedHitObjects).Count(h => !(h is TinyDroplet));
+        protected override Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap) => generateHitResults(beatmap, Accuracy / 100, Misses, Mehs, Goods);
 
-        protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        private static Dictionary<HitResult, int> generateHitResults(IBeatmap beatmap, double accuracy, int countMiss, int? countMeh, int? countGood)
         {
-            var maxCombo = GetMaxCombo(beatmap);
+            var maxCombo = beatmap.GetMaxCombo();
             int maxTinyDroplets = beatmap.HitObjects.OfType<JuiceStream>().Sum(s => s.NestedHitObjects.OfType<TinyDroplet>().Count());
             int maxDroplets = beatmap.HitObjects.OfType<JuiceStream>().Sum(s => s.NestedHitObjects.OfType<Droplet>().Count()) - maxTinyDroplets;
             int maxFruits = beatmap.HitObjects.Sum(h => h is Fruit ? 1 : (h as JuiceStream)?.NestedHitObjects.Count(n => n is Fruit) ?? 0);
@@ -83,7 +67,7 @@ protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy
             };
         }
 
-        protected override double GetAccuracy(Dictionary<HitResult, int> statistics)
+        protected override double GetAccuracy(IBeatmap beatmap, Dictionary<HitResult, int> statistics)
         {
             double hits = statistics[HitResult.Great] + statistics[HitResult.LargeTickHit] + statistics[HitResult.SmallTickHit];
             double total = hits + statistics[HitResult.Miss] + statistics[HitResult.SmallTickMiss];
diff --git a/PerformanceCalculator/Simulate/ManiaSimulateCommand.cs b/PerformanceCalculator/Simulate/ManiaSimulateCommand.cs
index d02febad1..61c7f74a6 100644
--- a/PerformanceCalculator/Simulate/ManiaSimulateCommand.cs
+++ b/PerformanceCalculator/Simulate/ManiaSimulateCommand.cs
@@ -17,55 +17,41 @@ namespace PerformanceCalculator.Simulate
     [Command(Name = "mania", Description = "Computes the performance (pp) of a simulated osu!mania play.")]
     public class ManiaSimulateCommand : SimulateCommand
     {
-        [UsedImplicitly]
-        [Option(Template = "-a|--accuracy <accuracy>", Description = "Accuracy. Enter as decimal 0-100. Defaults to 100."
-                                                                     + " Scales hit results as well and is rounded to the nearest possible value for the beatmap.")]
-        public override double Accuracy { get; } = 100;
-
-        [UsedImplicitly]
-        [Option(Template = "-X|--misses <misses>", Description = "Number of misses. Defaults to 0.")]
-        public override int Misses { get; }
-
         [UsedImplicitly]
         [Option(Template = "-M|--mehs <mehs>", Description = "Number of mehs. Will override accuracy if used. Otherwise is automatically calculated.")]
         public override int? Mehs { get; }
 
-        [UsedImplicitly]
-        [Option(Template = "-O|--oks <oks>", Description = "Number of oks. Will override accuracy if used. Otherwise is automatically calculated.")]
-        private int? oks { get; set; }
-
         [UsedImplicitly]
         [Option(Template = "-G|--goods <goods>", Description = "Number of goods. Will override accuracy if used. Otherwise is automatically calculated.")]
         public override int? Goods { get; }
 
         [UsedImplicitly]
-        [Option(Template = "-T|--greats <greats>", Description = "Number of greats. Will override accuracy if used. Otherwise is automatically calculated.")]
-        private int? greats { get; set; }
+        [Option(Template = "-O|--oks <oks>", Description = "Number of oks. Will override accuracy if used. Otherwise is automatically calculated.")]
+        private int? oks { get; }
 
         [UsedImplicitly]
-        [Option(CommandOptionType.MultipleValue, Template = "-m|--mod <mod>", Description = "One for each mod. The mods to compute the performance with."
-                                                                                            + " Values: hr, dt, fl, 4k, 5k, etc...")]
-        public override string[] Mods { get; }
+        [Option(Template = "-T|--greats <greats>", Description = "Number of greats. Will override accuracy if used. Otherwise is automatically calculated.")]
+        private int? greats { get; }
 
         public override Ruleset Ruleset => new ManiaRuleset();
 
-        protected override int GetMaxCombo(IBeatmap beatmap) => 0;
+        protected override Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap) => generateHitResults(beatmap, Accuracy / 100, Misses, Mehs, oks, Goods, greats);
 
-        protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        private static Dictionary<HitResult, int> generateHitResults(IBeatmap beatmap, double accuracy, int countMiss, int? countMeh, int? countOk, int? countGood, int? countGreat)
         {
             // One judgement per normal note. Two judgements per hold note (head + tail).
             var totalHits = beatmap.HitObjects.Count + beatmap.HitObjects.Count(ho => ho is HoldNote);
 
-            if (countMeh != null || oks != null || countGood != null || greats != null)
+            if (countMeh != null || countOk != null || countGood != null || countGreat != null)
             {
-                int countPerfect = totalHits - (countMiss + (countMeh ?? 0) + (oks ?? 0) + (countGood ?? 0) + (greats ?? 0));
+                int countPerfect = totalHits - (countMiss + (countMeh ?? 0) + (countOk ?? 0) + (countGood ?? 0) + (countGreat ?? 0));
 
                 return new Dictionary<HitResult, int>
                 {
                     [HitResult.Perfect] = countPerfect,
-                    [HitResult.Great] = greats ?? 0,
+                    [HitResult.Great] = countGreat ?? 0,
                     [HitResult.Good] = countGood ?? 0,
-                    [HitResult.Ok] = oks ?? 0,
+                    [HitResult.Ok] = countOk ?? 0,
                     [HitResult.Meh] = countMeh ?? 0,
                     [HitResult.Miss] = countMiss
                 };
@@ -82,10 +68,10 @@ protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy
             // Each great and perfect increases total by 5 (great-meh=5)
             // There is no difference in accuracy between them, so just halve arbitrarily (favouring perfects for an odd number).
             int greatsAndPerfects = Math.Min(delta / 5, remainingHits);
-            greats = greatsAndPerfects / 2;
-            int perfects = greatsAndPerfects - greats.Value;
-            delta -= (greats.Value + perfects) * 5;
-            remainingHits -= greats.Value + perfects;
+            int greats = greatsAndPerfects / 2;
+            int perfects = greatsAndPerfects - greats;
+            delta -= (greats + perfects) * 5;
+            remainingHits -= greats + perfects;
 
             // Each good increases total by 3 (good-meh=3).
             countGood = Math.Min(delta / 3, remainingHits);
@@ -93,8 +79,8 @@ protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy
             remainingHits -= countGood.Value;
 
             // Each ok increases total by 1 (ok-meh=1).
-            oks = delta;
-            remainingHits -= oks.Value;
+            int oks = delta;
+            remainingHits -= oks;
 
             // Everything else is a meh, as initially assumed.
             countMeh = remainingHits;
@@ -102,8 +88,8 @@ protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy
             return new Dictionary<HitResult, int>
             {
                 { HitResult.Perfect, perfects },
-                { HitResult.Great, greats.Value },
-                { HitResult.Ok, oks.Value },
+                { HitResult.Great, greats },
+                { HitResult.Ok, oks },
                 { HitResult.Good, countGood.Value },
                 { HitResult.Meh, countMeh.Value },
                 { HitResult.Miss, countMiss }
diff --git a/PerformanceCalculator/Simulate/OsuSimulateCommand.cs b/PerformanceCalculator/Simulate/OsuSimulateCommand.cs
index 3fdf0f307..ea7e83fcc 100644
--- a/PerformanceCalculator/Simulate/OsuSimulateCommand.cs
+++ b/PerformanceCalculator/Simulate/OsuSimulateCommand.cs
@@ -3,11 +3,13 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using JetBrains.Annotations;
 using McMaster.Extensions.CommandLineUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 
 namespace PerformanceCalculator.Simulate
@@ -16,41 +18,34 @@ namespace PerformanceCalculator.Simulate
     public class OsuSimulateCommand : SimulateCommand
     {
         [UsedImplicitly]
-        [Option(Template = "-a|--accuracy <accuracy>", Description = "Accuracy. Enter as decimal 0-100. Defaults to 100."
-                                                                     + " Scales hit results as well and is rounded to the nearest possible value for the beatmap.")]
-        public override double Accuracy { get; } = 100;
+        [Option(Template = "-M|--mehs <mehs>", Description = "Number of mehs. Will override accuracy if used. Otherwise is automatically calculated.")]
+        public override int? Mehs { get; }
+
+        [UsedImplicitly]
+        [Option(Template = "-G|--goods <goods>", Description = "Number of goods. Will override accuracy if used. Otherwise is automatically calculated.")]
+        public override int? Goods { get; }
 
         [UsedImplicitly]
         [Option(Template = "-c|--combo <combo>", Description = "Maximum combo during play. Defaults to beatmap maximum.")]
         public override int? Combo { get; }
 
         [UsedImplicitly]
-        [Option(Template = "-C|--percent-combo <combo>", Description = "Percentage of beatmap maximum combo achieved. Alternative to combo option."
-                                                                       + " Enter as decimal 0-100.")]
+        [Option(Template = "-C|--percent-combo <combo>", Description = "Percentage of beatmap maximum combo achieved. Alternative to combo option. Enter as decimal 0-100.")]
         public override double PercentCombo { get; } = 100;
 
         [UsedImplicitly]
-        [Option(CommandOptionType.MultipleValue, Template = "-m|--mod <mod>", Description = "One for each mod. The mods to compute the performance with."
-                                                                                            + " Values: hr, dt, hd, fl, ez, etc...")]
-        public override string[] Mods { get; }
-
-        [UsedImplicitly]
-        [Option(Template = "-X|--misses <misses>", Description = "Number of misses. Defaults to 0.")]
-        public override int Misses { get; }
+        [Option(Template = "-L|--large-tick-misses <misses>", Description = "Number of large tick misses. Defaults to 0.")]
+        private int largeTickMisses { get; }
 
         [UsedImplicitly]
-        [Option(Template = "-M|--mehs <mehs>", Description = "Number of mehs. Will override accuracy if used. Otherwise is automatically calculated.")]
-        public override int? Mehs { get; }
-
-        [UsedImplicitly]
-        [Option(Template = "-G|--goods <goods>", Description = "Number of goods. Will override accuracy if used. Otherwise is automatically calculated.")]
-        public override int? Goods { get; }
+        [Option(Template = "-S|--slider-tail-misses <misses>", Description = "Number of slider tail misses. Defaults to 0.")]
+        private int sliderTailMisses { get; }
 
         public override Ruleset Ruleset => new OsuRuleset();
 
-        protected override int GetMaxCombo(IBeatmap beatmap) => beatmap.GetMaxCombo();
+        protected override Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap) => generateHitResults(beatmap, Accuracy / 100, Misses, Mehs, Goods, largeTickMisses, sliderTailMisses);
 
-        protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        private static Dictionary<HitResult, int> generateHitResults(IBeatmap beatmap, double accuracy, int countMiss, int? countMeh, int? countGood, int countLargeTickMisses, int countSliderTailMisses)
         {
             int countGreat;
 
@@ -62,19 +57,68 @@ protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy
             }
             else
             {
-                // Let Great=6, Good=2, Meh=1, Miss=0. The total should be this.
-                var targetTotal = (int)Math.Round(accuracy * totalResultCount * 6);
-
-                // Start by assuming every non miss is a meh
-                // This is how much increase is needed by greats and goods
-                var delta = targetTotal - (totalResultCount - countMiss);
-
-                // Each great increases total by 5 (great-meh=5)
-                countGreat = delta / 5;
-                // Each good increases total by 1 (good-meh=1). Covers remaining difference.
-                countGood = delta % 5;
-                // Mehs are left over. Could be negative if impossible value of amountMiss chosen
-                countMeh = totalResultCount - countGreat - countGood - countMiss;
+                // Total result count excluding countMiss
+                int relevantResultCount = totalResultCount - countMiss;
+
+                // Accuracy excluding countMiss. We need that because we're trying to achieve target accuracy without touching countMiss
+                // So it's better to pretened that there were 0 misses in the 1st place
+                double relevantAccuracy = accuracy * totalResultCount / relevantResultCount;
+
+                // Clamp accuracy to account for user trying to break the algorithm by inputting impossible values
+                relevantAccuracy = Math.Clamp(relevantAccuracy, 0, 1);
+
+                // Main curve for accuracy > 25%, the closer accuracy is to 25% - the more 50s it adds
+                if (relevantAccuracy >= 0.25)
+                {
+                    // Main curve. Zero 50s if accuracy is 100%, one 50 per 9 100s if accuracy is 75% (excluding misses), 4 50s per 9 100s if accuracy is 50%
+                    double ratio50To100 = Math.Pow(1 - (relevantAccuracy - 0.25) / 0.75, 2);
+
+                    // Derived from the formula: Accuracy = (6 * c300 + 2 * c100 + c50) / (6 * totalHits), assuming that c50 = c100 * ratio50to100
+                    double count100Estimate = 6 * relevantResultCount * (1 - relevantAccuracy) / (5 * ratio50To100 + 4);
+
+                    // Get count50 according to c50 = c100 * ratio50to100
+                    double count50Estimate = count100Estimate * ratio50To100;
+
+                    // Round it to get int number of 100s
+                    countGood = (int?)Math.Round(count100Estimate);
+
+                    // Get number of 50s as difference between total mistimed hits and count100
+                    countMeh = (int?)(Math.Round(count100Estimate + count50Estimate) - countGood);
+                }
+                // If accuracy is between 16.67% and 25% - we assume that we have no 300s
+                else if (relevantAccuracy >= 1.0 / 6)
+                {
+                    // Derived from the formula: Accuracy = (6 * c300 + 2 * c100 + c50) / (6 * totalHits), assuming that c300 = 0
+                    double count100Estimate = 6 * relevantResultCount * relevantAccuracy - relevantResultCount;
+
+                    // We only had 100s and 50s in that scenario so rest of the hits are 50s
+                    double count50Estimate = relevantResultCount - count100Estimate;
+
+                    // Round it to get int number of 100s
+                    countGood = (int?)Math.Round(count100Estimate);
+
+                    // Get number of 50s as difference between total mistimed hits and count100
+                    countMeh = (int?)(Math.Round(count100Estimate + count50Estimate) - countGood);
+                }
+                // If accuracy is less than 16.67% - it means that we have only 50s or misses
+                // Assuming that we removed misses in the 1st place - that means that we need to add additional misses to achieve target accuracy
+                else
+                {
+                    // Derived from the formula: Accuracy = (6 * c300 + 2 * c100 + c50) / (6 * totalHits), assuming that c300 = c100 = 0
+                    double count50Estimate = 6 * relevantResultCount * relevantAccuracy;
+
+                    // We have 0 100s, because we can't start adding 100s again after reaching "only 50s" point
+                    countGood = 0;
+
+                    // Round it to get int number of 50s
+                    countMeh = (int?)Math.Round(count50Estimate);
+
+                    // Fill the rest results with misses overwriting initial countMiss
+                    countMiss = (int)(totalResultCount - countMeh);
+                }
+
+                // Rest of the hits are 300s
+                countGreat = (int)(totalResultCount - countGood - countMeh - countMiss);
             }
 
             return new Dictionary<HitResult, int>
@@ -82,19 +126,27 @@ protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy
                 { HitResult.Great, countGreat },
                 { HitResult.Ok, countGood ?? 0 },
                 { HitResult.Meh, countMeh ?? 0 },
+                { HitResult.LargeTickMiss, countLargeTickMisses },
+                { HitResult.SliderTailHit, beatmap.HitObjects.Count(x => x is Slider) - countSliderTailMisses },
                 { HitResult.Miss, countMiss }
             };
         }
 
-        protected override double GetAccuracy(Dictionary<HitResult, int> statistics)
+        protected override double GetAccuracy(IBeatmap beatmap, Dictionary<HitResult, int> statistics)
         {
             var countGreat = statistics[HitResult.Great];
             var countGood = statistics[HitResult.Ok];
             var countMeh = statistics[HitResult.Meh];
             var countMiss = statistics[HitResult.Miss];
-            var total = countGreat + countGood + countMeh + countMiss;
 
-            return (double)((6 * countGreat) + (2 * countGood) + countMeh) / (6 * total);
+            var countSliders = beatmap.HitObjects.Count(x => x is Slider);
+            var countSliderTailHit = statistics[HitResult.SliderTailHit];
+            var countLargeTicks = beatmap.HitObjects.Sum(obj => obj.NestedHitObjects.Count(x => x is SliderTick or SliderRepeat));
+            var countLargeTickHit = countLargeTicks - statistics[HitResult.LargeTickMiss];
+
+            double total = 6 * (countGreat + countGood + countMeh + countMiss) + 3 * countSliders + 0.6 * countLargeTicks;
+
+            return (6 * countGreat + 2 * countGood + countMeh + 3 * countSliderTailHit + 0.6 * countLargeTickHit) / total;
         }
     }
 }
diff --git a/PerformanceCalculator/Simulate/SimulateCommand.cs b/PerformanceCalculator/Simulate/SimulateCommand.cs
index b7351ff50..957b2f290 100644
--- a/PerformanceCalculator/Simulate/SimulateCommand.cs
+++ b/PerformanceCalculator/Simulate/SimulateCommand.cs
@@ -4,12 +4,10 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
-using System.Linq;
 using JetBrains.Annotations;
 using McMaster.Extensions.CommandLineUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 
@@ -25,23 +23,28 @@ public abstract class SimulateCommand : ProcessorCommand
         public string Beatmap { get; }
 
         [UsedImplicitly]
-        public virtual double Accuracy { get; }
+        [Option(Template = "-a|--accuracy <accuracy>", Description = "Accuracy. Enter as decimal 0-100. Defaults to 100. Scales hit results as well and is rounded to the nearest possible value for the beatmap.")]
+        public double Accuracy { get; } = 100;
 
         [UsedImplicitly]
-        public virtual int? Combo { get; }
-
-        [UsedImplicitly]
-        public virtual double PercentCombo { get; }
-
-        [UsedImplicitly]
-        public virtual int Score { get; }
+        [Option(CommandOptionType.MultipleValue, Template = "-m|--mod <mod>", Description = "One for each mod. The mods to compute the performance with. Values: hr, dt, hd, fl, etc...")]
+        public string[] Mods { get; }
 
         [UsedImplicitly]
-        public virtual string[] Mods { get; }
+        [Option(CommandOptionType.MultipleValue, Template = "-o|--mod-option <option>",
+            Description = "The options of mods, with one for each setting. Specified as acryonym_settingkey=value. Example: DT_speed_change=1.35")]
+        public string[] ModOptions { get; set; } = [];
 
         [UsedImplicitly]
-        public virtual int Misses { get; }
-
+        [Option(Template = "-X|--misses <misses>", Description = "Number of misses. Defaults to 0.")]
+        public int Misses { get; }
+
+        //
+        // Options implemented in the ruleset-specific commands
+        // -> Catch renames Mehs/Goods to (tiny-)droplets
+        // -> Mania does not have Combo
+        // -> Taiko does not have Mehs
+        //
         [UsedImplicitly]
         public virtual int? Mehs { get; }
 
@@ -49,26 +52,27 @@ public abstract class SimulateCommand : ProcessorCommand
         public virtual int? Goods { get; }
 
         [UsedImplicitly]
-        [Option(Template = "-nc|--no-classic", Description = "Excludes the classic mod.")]
-        public bool NoClassicMod { get; }
+        public virtual int? Combo { get; }
+
+        [UsedImplicitly]
+        public virtual double PercentCombo { get; }
 
         public override void Execute()
         {
             var ruleset = Ruleset;
 
             var workingBeatmap = ProcessorWorkingBeatmap.FromFileOrId(Beatmap);
-            var mods = NoClassicMod ? GetMods(ruleset) : LegacyHelper.FilterDifficultyAdjustmentMods(workingBeatmap.BeatmapInfo, ruleset, GetMods(ruleset));
+            var mods = ParseMods(ruleset, Mods, ModOptions);
             var beatmap = workingBeatmap.GetPlayableBeatmap(ruleset.RulesetInfo, mods);
 
-            var beatmapMaxCombo = GetMaxCombo(beatmap);
-            var statistics = GenerateHitResults(Accuracy / 100, beatmap, Misses, Mehs, Goods);
+            var beatmapMaxCombo = beatmap.GetMaxCombo();
+            var statistics = GenerateHitResults(beatmap);
             var scoreInfo = new ScoreInfo(beatmap.BeatmapInfo, ruleset.RulesetInfo)
             {
-                Accuracy = GetAccuracy(statistics),
+                Accuracy = GetAccuracy(beatmap, statistics),
                 MaxCombo = Combo ?? (int)Math.Round(PercentCombo / 100 * beatmapMaxCombo),
                 Statistics = statistics,
-                Mods = mods,
-                TotalScore = Score,
+                Mods = mods
             };
 
             var difficultyCalculator = ruleset.CreateDifficultyCalculator(workingBeatmap);
@@ -79,30 +83,8 @@ public override void Execute()
             OutputPerformance(scoreInfo, performanceAttributes, difficultyAttributes);
         }
 
-        protected Mod[] GetMods(Ruleset ruleset)
-        {
-            if (Mods == null)
-                return Array.Empty<Mod>();
-
-            var availableMods = ruleset.CreateAllMods().ToList();
-            var mods = new List<Mod>();
-
-            foreach (var modString in Mods)
-            {
-                Mod newMod = availableMods.FirstOrDefault(m => string.Equals(m.Acronym, modString, StringComparison.CurrentCultureIgnoreCase));
-                if (newMod == null)
-                    throw new ArgumentException($"Invalid mod provided: {modString}");
-
-                mods.Add(newMod);
-            }
-
-            return mods.ToArray();
-        }
-
-        protected abstract int GetMaxCombo(IBeatmap beatmap);
-
-        protected abstract Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood);
+        protected abstract Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap);
 
-        protected virtual double GetAccuracy(Dictionary<HitResult, int> statistics) => 0;
+        protected virtual double GetAccuracy(IBeatmap beatmap, Dictionary<HitResult, int> statistics) => 0;
     }
 }
diff --git a/PerformanceCalculator/Simulate/TaikoSimulateCommand.cs b/PerformanceCalculator/Simulate/TaikoSimulateCommand.cs
index 9a0c3a0e8..ac7d69448 100644
--- a/PerformanceCalculator/Simulate/TaikoSimulateCommand.cs
+++ b/PerformanceCalculator/Simulate/TaikoSimulateCommand.cs
@@ -3,14 +3,12 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using JetBrains.Annotations;
 using McMaster.Extensions.CommandLineUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko;
-using osu.Game.Rulesets.Taiko.Objects;
 
 namespace PerformanceCalculator.Simulate
 {
@@ -18,39 +16,24 @@ namespace PerformanceCalculator.Simulate
     public class TaikoSimulateCommand : SimulateCommand
     {
         [UsedImplicitly]
-        [Option(Template = "-a|--accuracy <accuracy>", Description = "Accuracy. Enter as decimal 0-100. Defaults to 100."
-                                                                     + " Scales hit results as well and is rounded to the nearest possible value for the beatmap.")]
-        public override double Accuracy { get; } = 100;
+        [Option(Template = "-G|--goods <goods>", Description = "Number of goods. Will override accuracy if used. Otherwise is automatically calculated.")]
+        public override int? Goods { get; }
 
         [UsedImplicitly]
         [Option(Template = "-c|--combo <combo>", Description = "Maximum combo during play. Defaults to beatmap maximum.")]
         public override int? Combo { get; }
 
         [UsedImplicitly]
-        [Option(Template = "-C|--percent-combo <combo>", Description = "Percentage of beatmap maximum combo achieved. Alternative to combo option."
-                                                                       + " Enter as decimal 0-100.")]
+        [Option(Template = "-C|--percent-combo <combo>", Description = "Percentage of beatmap maximum combo achieved. Alternative to combo option. Enter as decimal 0-100.")]
         public override double PercentCombo { get; } = 100;
 
-        [UsedImplicitly]
-        [Option(CommandOptionType.MultipleValue, Template = "-m|--mod <mod>", Description = "One for each mod. The mods to compute the performance with."
-                                                                                            + " Values: hr, dt, hd, fl, ez, etc...")]
-        public override string[] Mods { get; }
-
-        [UsedImplicitly]
-        [Option(Template = "-X|--misses <misses>", Description = "Number of misses. Defaults to 0.")]
-        public override int Misses { get; }
-
-        [UsedImplicitly]
-        [Option(Template = "-G|--goods <goods>", Description = "Number of goods. Will override accuracy if used. Otherwise is automatically calculated.")]
-        public override int? Goods { get; }
-
         public override Ruleset Ruleset => new TaikoRuleset();
 
-        protected override int GetMaxCombo(IBeatmap beatmap) => beatmap.HitObjects.OfType<Hit>().Count();
+        protected override Dictionary<HitResult, int> GenerateHitResults(IBeatmap beatmap) => generateHitResults(Accuracy / 100, beatmap, Misses, Goods);
 
-        protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        private static Dictionary<HitResult, int> generateHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countGood)
         {
-            var totalResultCount = GetMaxCombo(beatmap);
+            var totalResultCount = beatmap.GetMaxCombo();
 
             int countGreat;
 
@@ -76,7 +59,7 @@ protected override Dictionary<HitResult, int> GenerateHitResults(double accuracy
             };
         }
 
-        protected override double GetAccuracy(Dictionary<HitResult, int> statistics)
+        protected override double GetAccuracy(IBeatmap beatmap, Dictionary<HitResult, int> statistics)
         {
             var countGreat = statistics[HitResult.Great];
             var countGood = statistics[HitResult.Ok];
diff --git a/PerformanceCalculatorGUI/Components/ExtendedProfileScore.cs b/PerformanceCalculatorGUI/Components/ExtendedProfileScore.cs
index e8aacd4e2..795015ea6 100644
--- a/PerformanceCalculatorGUI/Components/ExtendedProfileScore.cs
+++ b/PerformanceCalculatorGUI/Components/ExtendedProfileScore.cs
@@ -80,7 +80,7 @@ public partial class ExtendedProfileScore : CompositeDrawable
 
         private const float performance_background_shear = 0.45f;
 
-        protected readonly ExtendedScore Score;
+        public readonly ExtendedScore Score;
 
         [Resolved]
         private OsuColour colours { get; set; }
diff --git a/PerformanceCalculatorGUI/Components/ExtendedUserModSelectOverlay.cs b/PerformanceCalculatorGUI/Components/ExtendedUserModSelectOverlay.cs
index e557474ae..f37e09ba4 100644
--- a/PerformanceCalculatorGUI/Components/ExtendedUserModSelectOverlay.cs
+++ b/PerformanceCalculatorGUI/Components/ExtendedUserModSelectOverlay.cs
@@ -17,7 +17,8 @@ public ExtendedUserModSelectOverlay()
         protected override void PopIn()
         {
             Header.Hide();
-            MainAreaContent.Padding = new MarginPadding { Bottom = 64 };
+            MainAreaContent.Padding = new MarginPadding();
+            TopLevelContent.Children[0].Hide(); // hide the gray background of the ShearedOverlayContainer
 
             base.PopIn();
         }
diff --git a/PerformanceCalculatorGUI/Components/ProfileSortCriteria.cs b/PerformanceCalculatorGUI/Components/ProfileSortCriteria.cs
new file mode 100644
index 000000000..bd664a8ff
--- /dev/null
+++ b/PerformanceCalculatorGUI/Components/ProfileSortCriteria.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.
+
+namespace PerformanceCalculatorGUI.Components
+{
+    public enum ProfileSortCriteria
+    {
+        Live,
+        Difference,
+        Local
+    }
+}
diff --git a/PerformanceCalculatorGUI/Components/StrainVisualizer.cs b/PerformanceCalculatorGUI/Components/StrainVisualizer.cs
index 5954fa3be..4b47fa8bf 100644
--- a/PerformanceCalculatorGUI/Components/StrainVisualizer.cs
+++ b/PerformanceCalculatorGUI/Components/StrainVisualizer.cs
@@ -23,54 +23,6 @@
 
 namespace PerformanceCalculatorGUI.Components
 {
-    public partial class StrainBar : Bar, IHasTooltip
-    {
-        public StrainBar(string tooltip)
-        {
-            TooltipText = tooltip;
-        }
-
-        public LocalisableString TooltipText { get; }
-    }
-
-    public partial class StrainBarGraph : FillFlowContainer<StrainBar>
-    {
-        /// <summary>
-        /// Manually sets the max value, if null <see cref="Enumerable.Max(IEnumerable{float})"/> is instead used
-        /// </summary>
-        public float? MaxValue { get; set; }
-
-        /// <summary>
-        /// A list of floats that defines the length of each <see cref="Bar"/>
-        /// </summary>
-        public IEnumerable<(float val, string tooltip)> Values
-        {
-            set
-            {
-                Clear();
-
-                foreach (var (val, tooltip) in value)
-                {
-                    float length = MaxValue ?? value.Max(x => x.val);
-                    if (length != 0)
-                        length = val / length;
-
-                    float size = value.Count();
-                    if (size != 0)
-                        size = 1.0f / size;
-
-                    Add(new StrainBar(tooltip)
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Size = new Vector2(size, 1),
-                        Length = length,
-                        Direction = BarDirection.BottomToTop
-                    });
-                }
-            }
-        }
-    }
-
     public partial class StrainVisualizer : Container
     {
         public readonly Bindable<Skill[]> Skills = new Bindable<Skill[]>();
@@ -93,6 +45,8 @@ public StrainVisualizer()
             AutoSizeAxes = Axes.Y;
         }
 
+        private float graphAlpha;
+
         private void updateGraphs(ValueChangedEvent<Skill[]> val)
         {
             graphsContainer.Clear();
@@ -107,53 +61,10 @@ private void updateGraphs(ValueChangedEvent<Skill[]> val)
                 return;
             }
 
-            var graphAlpha = Math.Min(1.5f / skills.Length, 0.9f);
-
-            List<(float val, string tooltip)[]> strainLists = new List<(float val, string tooltip)[]>();
-
-            foreach (var skill in skills)
-            {
-                var strains = ((StrainSkill)skill).GetCurrentStrainPeaks().ToArray();
-
-                var skillStrainList = new List<(float val, string tooltip)>();
-
-                for (int i = 0; i < strains.Length; i++)
-                {
-                    var strain = strains[i];
-                    var strainTime = TimeSpan.FromMilliseconds(TimeUntilFirstStrain.Value + i * 400); // 400 is strain length in StrainSkill
-                    var tooltipText = $"~{strainTime:mm\\:ss\\.ff}";
-                    skillStrainList.Add(((float)strain, tooltipText));
-                }
-
-                strainLists.Add(skillStrainList.ToArray());
-            }
-
-            var strainMaxValue = strainLists.Max(list => list.Max(x => x.val));
-
-            for (int i = 0; i < skills.Length; i++)
-            {
-                graphsContainer.AddRange(new Drawable[]
-                {
-                    new BufferedContainer(cachedFrameBuffer: true)
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Alpha = graphAlpha,
-                        Colour = skillColours[i],
-                        Child = new StrainBarGraph
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            MaxValue = strainMaxValue,
-                            Values = strainLists[i]
-                        }
-                    }
-                });
-            }
-
-            graphsContainer.Add(new OsuSpriteText
-            {
-                Font = OsuFont.GetFont(size: 10),
-                Text = $"{strainMaxValue:0.00}"
-            });
+            graphAlpha = Math.Min(1.5f / skills.Length, 0.9f);
+            var strainLists = getStrainLists(skills);
+            addStrainBars(skills, strainLists);
+            addTooltipBars(strainLists);
 
             if (val.OldValue == null || !val.NewValue.All(x => val.OldValue.Any(y => y.GetType().Name == x.GetType().Name)))
             {
@@ -161,8 +72,7 @@ private void updateGraphs(ValueChangedEvent<Skill[]> val)
                 legendContainer.Clear();
                 graphToggles.Clear();
 
-                // we do Children - 1 because max strain value is in the graphsContainer too and we don't want it to have a toggle
-                for (int i = 0; i < graphsContainer.Children.Count - 1; i++)
+                for (int i = 0; i < skills.Length; i++)
                 {
                     // this is ugly, but it works
                     var graphToggleBindable = new Bindable<bool>();
@@ -209,8 +119,7 @@ private void updateGraphs(ValueChangedEvent<Skill[]> val)
             }
             else
             {
-                // skill list is the same, keep graph toggles
-                for (int i = 0; i < graphsContainer.Children.Count - 1; i++)
+                for (int i = 0; i < skills.Length; i++)
                 {
                     // graphs are visible by default, we want to hide ones that were disabled before
                     if (!graphToggles[i].Value)
@@ -274,5 +183,161 @@ private void load(OsuColour colours)
 
             Skills.BindValueChanged(updateGraphs);
         }
+
+        private void addStrainBars(Skill[] skills, List<float[]> strainLists)
+        {
+            var strainMaxValue = strainLists.Max(list => list.Max());
+
+            for (int i = 0; i < skills.Length; i++)
+            {
+                graphsContainer.AddRange(new Drawable[]
+                {
+                    new BufferedContainer(cachedFrameBuffer: true)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = graphAlpha,
+                        Colour = skillColours[i],
+                        Child = new StrainBarGraph
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            MaxValue = strainMaxValue,
+                            Values = strainLists[i]
+                        }
+                    }
+                });
+            }
+
+            graphsContainer.Add(new OsuSpriteText
+            {
+                Font = OsuFont.GetFont(size: 10),
+                Text = $"{strainMaxValue:0.00}"
+            });
+        }
+
+        private void addTooltipBars(List<float[]> strainLists, int nBars = 1000)
+        {
+            double lastStrainTime = strainLists.Max(l => l.Length) * 400;
+
+            var tooltipList = new List<string>();
+
+            for (int i = 0; i < nBars; i++)
+            {
+                var strainTime = TimeSpan.FromMilliseconds(TimeUntilFirstStrain.Value + lastStrainTime * i / nBars);
+                var tooltipText = $"~{strainTime:mm\\:ss\\.ff}";
+                tooltipList.Add(tooltipText);
+            }
+
+            graphsContainer.AddRange(new Drawable[]
+            {
+                new BufferedContainer(cachedFrameBuffer: true)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 1,
+                    Child = new TooltipBarGraph
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Values = tooltipList
+                    }
+                }
+            });
+        }
+
+        private static List<float[]> getStrainLists(Skill[] skills)
+        {
+            List<float[]> strainLists = new List<float[]>();
+
+            foreach (var skill in skills)
+            {
+                var strains = ((StrainSkill)skill).GetCurrentStrainPeaks().ToArray();
+
+                var skillStrainList = new List<float>();
+
+                for (int i = 0; i < strains.Length; i++)
+                {
+                    var strain = strains[i];
+                    skillStrainList.Add(((float)strain));
+                }
+
+                strainLists.Add(skillStrainList.ToArray());
+            }
+
+            return strainLists;
+        }
+    }
+
+    public partial class StrainBarGraph : FillFlowContainer<Bar>
+    {
+        /// <summary>
+        /// Manually sets the max value, if null <see cref="Enumerable.Max(IEnumerable{float})"/> is instead used
+        /// </summary>
+        public float? MaxValue { get; set; }
+
+        /// <summary>
+        /// A list of floats that defines the length of each <see cref="Bar"/>
+        /// </summary>
+        public IEnumerable<float> Values
+        {
+            set
+            {
+                Clear();
+
+                foreach (var val in value)
+                {
+                    float length = MaxValue ?? value.Max();
+                    if (length != 0)
+                        length = val / length;
+
+                    float size = value.Count();
+                    if (size != 0)
+                        size = 1.0f / size;
+
+                    Add(new Bar
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Size = new Vector2(size, 1),
+                        Length = length,
+                        Direction = BarDirection.BottomToTop
+                    });
+                }
+            }
+        }
+    }
+
+    public partial class TooltipBar : Bar, IHasTooltip
+    {
+        public TooltipBar(string tooltip)
+        {
+            TooltipText = tooltip;
+        }
+
+        public LocalisableString TooltipText { get; }
+    }
+
+    public partial class TooltipBarGraph : FillFlowContainer<TooltipBar>
+    {
+        /// <summary>
+        /// A list of strings that defines tooltips, don't make it too big
+        /// </summary>
+        public IEnumerable<string> Values
+        {
+            set
+            {
+                Clear();
+
+                foreach (var tooltip in value)
+                {
+                    float size = value.Count();
+                    if (size != 0)
+                        size = 1.0f / size;
+
+                    Add(new TooltipBar(tooltip)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Size = new Vector2(size, 1),
+                        Direction = BarDirection.BottomToTop
+                    });
+                }
+            }
+        }
     }
 }
diff --git a/PerformanceCalculatorGUI/Components/TextBoxes/ExtendedLabelledTextBox.cs b/PerformanceCalculatorGUI/Components/TextBoxes/ExtendedLabelledTextBox.cs
index cee8e3f31..36b28fe9f 100644
--- a/PerformanceCalculatorGUI/Components/TextBoxes/ExtendedLabelledTextBox.cs
+++ b/PerformanceCalculatorGUI/Components/TextBoxes/ExtendedLabelledTextBox.cs
@@ -7,17 +7,10 @@ namespace PerformanceCalculatorGUI.Components.TextBoxes
 {
     public partial class ExtendedLabelledTextBox : LabelledTextBox
     {
-        public new const float CORNER_RADIUS = 8;
-
         public bool CommitOnFocusLoss
         {
             get => Component.CommitOnFocusLost;
             set => Component.CommitOnFocusLost = value;
         }
-
-        public ExtendedLabelledTextBox()
-        {
-            CornerRadius = CORNER_RADIUS;
-        }
     }
 }
diff --git a/PerformanceCalculatorGUI/PerformanceCalculatorGUI.csproj b/PerformanceCalculatorGUI/PerformanceCalculatorGUI.csproj
index 565744680..85130649f 100644
--- a/PerformanceCalculatorGUI/PerformanceCalculatorGUI.csproj
+++ b/PerformanceCalculatorGUI/PerformanceCalculatorGUI.csproj
@@ -6,10 +6,10 @@
     <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game" Version="2024.625.2" />
-    <PackageReference Include="ppy.osu.Game.Rulesets.Osu" Version="2024.625.2" />
-    <PackageReference Include="ppy.osu.Game.Rulesets.Taiko" Version="2024.625.2" />
-    <PackageReference Include="ppy.osu.Game.Rulesets.Catch" Version="2024.625.2" />
-    <PackageReference Include="ppy.osu.Game.Rulesets.Mania" Version="2024.625.2" />
+    <PackageReference Include="ppy.osu.Game" Version="2024.1023.0" />
+    <PackageReference Include="ppy.osu.Game.Rulesets.Osu" Version="2024.1023.0" />
+    <PackageReference Include="ppy.osu.Game.Rulesets.Taiko" Version="2024.1023.0" />
+    <PackageReference Include="ppy.osu.Game.Rulesets.Catch" Version="2024.1023.0" />
+    <PackageReference Include="ppy.osu.Game.Rulesets.Mania" Version="2024.1023.0" />
   </ItemGroup>
 </Project>
diff --git a/PerformanceCalculatorGUI/PerformanceCalculatorGame.cs b/PerformanceCalculatorGUI/PerformanceCalculatorGame.cs
index 1c7e6f868..90a6dd53e 100644
--- a/PerformanceCalculatorGUI/PerformanceCalculatorGame.cs
+++ b/PerformanceCalculatorGUI/PerformanceCalculatorGame.cs
@@ -3,10 +3,12 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Framework.Input.Handlers.Tablet;
 using osu.Framework.Platform;
 using osu.Game;
 using osu.Game.Graphics.Cursor;
@@ -71,6 +73,13 @@ public override void SetHost(GameHost host)
             base.SetHost(host);
 
             host.Window.CursorState |= CursorState.Hidden;
+
+            var tabletInputHandler = host.AvailableInputHandlers.FirstOrDefault(x => x is OpenTabletDriverHandler && x.IsActive);
+
+            if (tabletInputHandler != null)
+            {
+                tabletInputHandler.Enabled.Value = false;
+            }
         }
 
         protected override void LoadComplete()
diff --git a/PerformanceCalculatorGUI/PerformanceCalculatorSceneManager.cs b/PerformanceCalculatorGUI/PerformanceCalculatorSceneManager.cs
index e58f2195d..2dc52f8c5 100644
--- a/PerformanceCalculatorGUI/PerformanceCalculatorSceneManager.cs
+++ b/PerformanceCalculatorGUI/PerformanceCalculatorSceneManager.cs
@@ -42,6 +42,9 @@ public partial class PerformanceCalculatorSceneManager : CompositeDrawable
         [Resolved]
         private DialogOverlay dialogOverlay { get; set; }
 
+        [Cached]
+        private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
         public PerformanceCalculatorSceneManager()
         {
             RelativeSizeAxes = Axes.Both;
diff --git a/PerformanceCalculatorGUI/Program.cs b/PerformanceCalculatorGUI/Program.cs
index acde56f57..e07c1832c 100644
--- a/PerformanceCalculatorGUI/Program.cs
+++ b/PerformanceCalculatorGUI/Program.cs
@@ -15,7 +15,8 @@ public static void Main(string[] args)
             using DesktopGameHost host = Host.GetSuitableDesktopHost("PerformanceCalculatorGUI", new HostOptions
             {
                 PortableInstallation = true,
-                BypassCompositor = false
+                BypassCompositor = false,
+                FriendlyGameName = "Performance Calculator GUI"
             });
 
             using var game = new PerformanceCalculatorGame();
diff --git a/PerformanceCalculatorGUI/RulesetHelper.cs b/PerformanceCalculatorGUI/RulesetHelper.cs
index c99ad0b9d..d879fc219 100644
--- a/PerformanceCalculatorGUI/RulesetHelper.cs
+++ b/PerformanceCalculatorGUI/RulesetHelper.cs
@@ -15,6 +15,7 @@
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko;
 using osu.Game.Rulesets.Taiko.Objects;
@@ -103,11 +104,11 @@ public static int AdjustManiaScore(int score, IReadOnlyList<Mod> mods)
             return (int)Math.Round(1000000 * scoreMultiplier);
         }
 
-        public static Dictionary<HitResult, int> GenerateHitResultsForRuleset(RulesetInfo ruleset, double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        public static Dictionary<HitResult, int> GenerateHitResultsForRuleset(RulesetInfo ruleset, double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood, int? countLargeTickMisses, int? countSliderTailMisses)
         {
             return ruleset.OnlineID switch
             {
-                0 => generateOsuHitResults(accuracy, beatmap, countMiss, countMeh, countGood),
+                0 => generateOsuHitResults(accuracy, beatmap, countMiss, countMeh, countGood, countLargeTickMisses, countSliderTailMisses),
                 1 => generateTaikoHitResults(accuracy, beatmap, countMiss, countGood),
                 2 => generateCatchHitResults(accuracy, beatmap, countMiss, countMeh, countGood),
                 3 => generateManiaHitResults(accuracy, beatmap, countMiss),
@@ -115,7 +116,7 @@ public static Dictionary<HitResult, int> GenerateHitResultsForRuleset(RulesetInf
             };
         }
 
-        private static Dictionary<HitResult, int> generateOsuHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood)
+        private static Dictionary<HitResult, int> generateOsuHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countMeh, int? countGood, int? countLargeTickMisses, int? countSliderTailMisses)
         {
             int countGreat;
 
@@ -127,28 +128,85 @@ private static Dictionary<HitResult, int> generateOsuHitResults(double accuracy,
             }
             else
             {
-                // Let Great=6, Good=2, Meh=1, Miss=0. The total should be this.
-                var targetTotal = (int)Math.Round(accuracy * totalResultCount * 6);
-
-                // Start by assuming every non miss is a meh
-                // This is how much increase is needed by greats and goods
-                var delta = targetTotal - (totalResultCount - countMiss);
-
-                // Each great increases total by 5 (great-meh=5)
-                countGreat = delta / 5;
-                // Each good increases total by 1 (good-meh=1). Covers remaining difference.
-                countGood = delta % 5;
-                // Mehs are left over. Could be negative if impossible value of amountMiss chosen
-                countMeh = totalResultCount - countGreat - countGood - countMiss;
+                // Total result count excluding countMiss
+                int relevantResultCount = totalResultCount - countMiss;
+
+                // Accuracy excluding countMiss. We need that because we're trying to achieve target accuracy without touching countMiss
+                // So it's better to pretened that there were 0 misses in the 1st place
+                double relevantAccuracy = accuracy * totalResultCount / relevantResultCount;
+
+                // Clamp accuracy to account for user trying to break the algorithm by inputting impossible values
+                relevantAccuracy = Math.Clamp(relevantAccuracy, 0, 1);
+
+                // Main curve for accuracy > 25%, the closer accuracy is to 25% - the more 50s it adds
+                if (relevantAccuracy >= 0.25)
+                {
+                    // Main curve. Zero 50s if accuracy is 100%, one 50 per 9 100s if accuracy is 75% (excluding misses), 4 50s per 9 100s if accuracy is 50%
+                    double ratio50To100 = Math.Pow(1 - (relevantAccuracy - 0.25) / 0.75, 2);
+
+                    // Derived from the formula: Accuracy = (6 * c300 + 2 * c100 + c50) / (6 * totalHits), assuming that c50 = c100 * ratio50to100
+                    double count100Estimate = 6 * relevantResultCount * (1 - relevantAccuracy) / (5 * ratio50To100 + 4);
+
+                    // Get count50 according to c50 = c100 * ratio50to100
+                    double count50Estimate = count100Estimate * ratio50To100;
+
+                    // Round it to get int number of 100s
+                    countGood = (int?)Math.Round(count100Estimate);
+
+                    // Get number of 50s as difference between total mistimed hits and count100
+                    countMeh = (int?)(Math.Round(count100Estimate + count50Estimate) - countGood);
+                }
+                // If accuracy is between 16.67% and 25% - we assume that we have no 300s
+                else if (relevantAccuracy >= 1.0 / 6)
+                {
+                    // Derived from the formula: Accuracy = (6 * c300 + 2 * c100 + c50) / (6 * totalHits), assuming that c300 = 0
+                    double count100Estimate = 6 * relevantResultCount * relevantAccuracy - relevantResultCount;
+
+                    // We only had 100s and 50s in that scenario so rest of the hits are 50s
+                    double count50Estimate = relevantResultCount - count100Estimate;
+
+                    // Round it to get int number of 100s
+                    countGood = (int?)Math.Round(count100Estimate);
+
+                    // Get number of 50s as difference between total mistimed hits and count100
+                    countMeh = (int?)(Math.Round(count100Estimate + count50Estimate) - countGood);
+                }
+                // If accuracy is less than 16.67% - it means that we have only 50s or misses
+                // Assuming that we removed misses in the 1st place - that means that we need to add additional misses to achieve target accuracy
+                else
+                {
+                    // Derived from the formula: Accuracy = (6 * c300 + 2 * c100 + c50) / (6 * totalHits), assuming that c300 = c100 = 0
+                    double count50Estimate = 6 * relevantResultCount * relevantAccuracy;
+
+                    // We have 0 100s, because we can't start adding 100s again after reaching "only 50s" point
+                    countGood = 0;
+
+                    // Round it to get int number of 50s
+                    countMeh = (int?)Math.Round(count50Estimate);
+
+                    // Fill the rest results with misses overwriting initial countMiss
+                    countMiss = (int)(totalResultCount - countMeh);
+                }
+
+                // Rest of the hits are 300s
+                countGreat = (int)(totalResultCount - countGood - countMeh - countMiss);
             }
 
-            return new Dictionary<HitResult, int>
+            var result = new Dictionary<HitResult, int>
             {
                 { HitResult.Great, countGreat },
                 { HitResult.Ok, countGood ?? 0 },
                 { HitResult.Meh, countMeh ?? 0 },
                 { HitResult.Miss, countMiss }
             };
+
+            if (countLargeTickMisses != null)
+                result[HitResult.LargeTickMiss] = countLargeTickMisses.Value;
+
+            if (countSliderTailMisses != null)
+                result[HitResult.SliderTailHit] = beatmap.HitObjects.Count(x => x is Slider) - countSliderTailMisses.Value;
+
+            return result;
         }
 
         private static Dictionary<HitResult, int> generateTaikoHitResults(double accuracy, IBeatmap beatmap, int countMiss, int? countGood)
@@ -239,11 +297,11 @@ private static Dictionary<HitResult, int> generateManiaHitResults(double accurac
             };
         }
 
-        public static double GetAccuracyForRuleset(RulesetInfo ruleset, Dictionary<HitResult, int> statistics)
+        public static double GetAccuracyForRuleset(RulesetInfo ruleset, IBeatmap beatmap, Dictionary<HitResult, int> statistics)
         {
             return ruleset.OnlineID switch
             {
-                0 => getOsuAccuracy(statistics),
+                0 => getOsuAccuracy(beatmap, statistics),
                 1 => getTaikoAccuracy(statistics),
                 2 => getCatchAccuracy(statistics),
                 3 => getManiaAccuracy(statistics),
@@ -251,15 +309,35 @@ public static double GetAccuracyForRuleset(RulesetInfo ruleset, Dictionary<HitRe
             };
         }
 
-        private static double getOsuAccuracy(Dictionary<HitResult, int> statistics)
+        private static double getOsuAccuracy(IBeatmap beatmap, Dictionary<HitResult, int> statistics)
         {
             var countGreat = statistics[HitResult.Great];
             var countGood = statistics[HitResult.Ok];
             var countMeh = statistics[HitResult.Meh];
             var countMiss = statistics[HitResult.Miss];
-            var total = countGreat + countGood + countMeh + countMiss;
 
-            return (double)((6 * countGreat) + (2 * countGood) + countMeh) / (6 * total);
+            double total = 6 * countGreat + 2 * countGood + countMeh;
+            double max = 6 * (countGreat + countGood + countMeh + countMiss);
+
+            if (statistics.ContainsKey(HitResult.SliderTailHit))
+            {
+                var countSliders = beatmap.HitObjects.Count(x => x is Slider);
+                var countSliderTailHit = statistics[HitResult.SliderTailHit];
+
+                total += 3 * countSliderTailHit;
+                max += 3 * countSliders;
+            }
+
+            if (statistics.ContainsKey(HitResult.LargeTickMiss))
+            {
+                var countLargeTicks = beatmap.HitObjects.Sum(obj => obj.NestedHitObjects.Count(x => x is SliderTick or SliderRepeat));
+                var countLargeTickHit = countLargeTicks - statistics[HitResult.LargeTickMiss];
+
+                total += 0.6 * countLargeTickHit;
+                max += 0.6 * countLargeTicks;
+            }
+
+            return total / max;
         }
 
         private static double getTaikoAccuracy(Dictionary<HitResult, int> statistics)
diff --git a/PerformanceCalculatorGUI/Screens/BeatmapLeaderboardScreen.cs b/PerformanceCalculatorGUI/Screens/BeatmapLeaderboardScreen.cs
index d34dee42a..00a8334f5 100644
--- a/PerformanceCalculatorGUI/Screens/BeatmapLeaderboardScreen.cs
+++ b/PerformanceCalculatorGUI/Screens/BeatmapLeaderboardScreen.cs
@@ -233,7 +233,6 @@ private void calculate()
                     var difficultyCalculator = rulesetInstance.CreateDifficultyCalculator(working);
 
                     Mod[] mods = score.Mods.Select(x => x.ToMod(rulesetInstance)).ToArray();
-                    mods = RulesetHelper.ConvertToLegacyDifficultyAdjustmentMods(rulesetInstance, mods);
 
                     var difficultyAttributes = difficultyCalculator.Calculate(mods);
                     var performanceCalculator = rulesetInstance.CreatePerformanceCalculator();
diff --git a/PerformanceCalculatorGUI/Screens/ObjectInspection/Catch/CatchObjectInspectorRuleset.cs b/PerformanceCalculatorGUI/Screens/ObjectInspection/Catch/CatchObjectInspectorRuleset.cs
index 98f6da372..b4a9be35d 100644
--- a/PerformanceCalculatorGUI/Screens/ObjectInspection/Catch/CatchObjectInspectorRuleset.cs
+++ b/PerformanceCalculatorGUI/Screens/ObjectInspection/Catch/CatchObjectInspectorRuleset.cs
@@ -65,10 +65,6 @@ public CatchObjectInspectorInputManager(RulesetInfo ruleset) : base(ruleset)
             protected override KeyBindingContainer<CatchAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
             => new EmptyKeyBindingContainer(ruleset, variant, unique);
 
-            protected override void SyncInputState(InputState state)
-            {
-            }
-
             private partial class EmptyKeyBindingContainer : RulesetKeyBindingContainer
             {
                 public EmptyKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique) : base(ruleset, variant, unique)
diff --git a/PerformanceCalculatorGUI/Screens/ObjectInspection/Osu/OsuObjectInspectorRuleset.cs b/PerformanceCalculatorGUI/Screens/ObjectInspection/Osu/OsuObjectInspectorRuleset.cs
index 51b6d94b5..f612f990c 100644
--- a/PerformanceCalculatorGUI/Screens/ObjectInspection/Osu/OsuObjectInspectorRuleset.cs
+++ b/PerformanceCalculatorGUI/Screens/ObjectInspection/Osu/OsuObjectInspectorRuleset.cs
@@ -114,7 +114,15 @@ private void updateState(DrawableHitObject hitObject, ArmedState state)
                             hitObject.RemoveTransform(existing);
 
                             using (hitObject.BeginAbsoluteSequence(hitObject.StartTimeBindable.Value))
-                                hitObject.Delay(nextHitObject.StartTime - hitObject.StartTimeBindable.Value).FadeOut().Expire();
+                            {
+                                var hitObjectDuration = hitObject.HitObject.GetEndTime() - hitObject.StartTimeBindable.Value;
+
+                                hitObject.Delay(hitObjectDuration)
+                                         .FadeTo(0.25f, 200f, Easing.Out)
+                                         .Delay(nextHitObject.StartTime - hitObject.StartTimeBindable.Value - hitObjectDuration)
+                                         .FadeOut(100f, Easing.Out)
+                                         .Expire();
+                            }
                         }
 
                         break;
diff --git a/PerformanceCalculatorGUI/Screens/ObjectInspection/Taiko/TaikoObjectInspectorRuleset.cs b/PerformanceCalculatorGUI/Screens/ObjectInspection/Taiko/TaikoObjectInspectorRuleset.cs
index b0ec71bc9..cb1806d19 100644
--- a/PerformanceCalculatorGUI/Screens/ObjectInspection/Taiko/TaikoObjectInspectorRuleset.cs
+++ b/PerformanceCalculatorGUI/Screens/ObjectInspection/Taiko/TaikoObjectInspectorRuleset.cs
@@ -67,10 +67,6 @@ public TaikoObjectInspectorInputManager(RulesetInfo ruleset) : base(ruleset)
             protected override KeyBindingContainer<TaikoAction> CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
             => new EmptyKeyBindingContainer(ruleset, variant, unique);
 
-            protected override void SyncInputState(InputState state)
-            {
-            }
-
             private partial class EmptyKeyBindingContainer : RulesetKeyBindingContainer
             {
                 public EmptyKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique) : base(ruleset, variant, unique)
diff --git a/PerformanceCalculatorGUI/Screens/ProfileScreen.cs b/PerformanceCalculatorGUI/Screens/ProfileScreen.cs
index e46a56381..d2e597936 100644
--- a/PerformanceCalculatorGUI/Screens/ProfileScreen.cs
+++ b/PerformanceCalculatorGUI/Screens/ProfileScreen.cs
@@ -11,6 +11,7 @@
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Events;
 using osu.Framework.Logging;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterfaceV2;
@@ -19,9 +20,11 @@
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osuTK.Graphics;
+using osuTK.Input;
 using PerformanceCalculatorGUI.Components;
 using PerformanceCalculatorGUI.Components.TextBoxes;
 using PerformanceCalculatorGUI.Configuration;
+using ButtonState = PerformanceCalculatorGUI.Components.ButtonState;
 
 namespace PerformanceCalculatorGUI.Screens
 {
@@ -35,7 +38,7 @@ public partial class ProfileScreen : PerformanceCalculatorScreen
 
         private GridContainer layout;
 
-        private FillFlowContainer scores;
+        private FillFlowContainer<ExtendedProfileScore> scores;
 
         private LabelledTextBox usernameTextBox;
         private Container userPanelContainer;
@@ -45,6 +48,9 @@ public partial class ProfileScreen : PerformanceCalculatorScreen
 
         private CancellationTokenSource calculationCancellatonToken;
 
+        private OverlaySortTabControl<ProfileSortCriteria> sortingTabControl;
+        private readonly Bindable<ProfileSortCriteria> sorting = new Bindable<ProfileSortCriteria>(ProfileSortCriteria.Local);
+
         [Resolved]
         private NotificationDisplay notificationDisplay { get; set; }
 
@@ -78,7 +84,13 @@ private void load()
                 {
                     RelativeSizeAxes = Axes.Both,
                     ColumnDimensions = new[] { new Dimension() },
-                    RowDimensions = new[] { new Dimension(GridSizeMode.Absolute, username_container_height), new Dimension(GridSizeMode.Absolute), new Dimension() },
+                    RowDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.Absolute, username_container_height),
+                        new Dimension(GridSizeMode.Absolute),
+                        new Dimension(GridSizeMode.AutoSize),
+                        new Dimension()
+                    },
                     Content = new[]
                     {
                         new Drawable[]
@@ -128,11 +140,30 @@ private void load()
                             }
                         },
                         new Drawable[]
+                        {
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
+                                Children = new Drawable[]
+                                {
+                                    sortingTabControl = new OverlaySortTabControl<ProfileSortCriteria>
+                                    {
+                                        Anchor = Anchor.CentreRight,
+                                        Origin = Anchor.CentreRight,
+                                        Margin = new MarginPadding { Right = 22 },
+                                        Current = { BindTarget = sorting },
+                                        Alpha = 0
+                                    }
+                                }
+                            }
+                        },
+                        new Drawable[]
                         {
                             new OsuScrollContainer(Direction.Vertical)
                             {
                                 RelativeSizeAxes = Axes.Both,
-                                Child = scores = new FillFlowContainer
+                                Child = scores = new FillFlowContainer<ExtendedProfileScore>
                                 {
                                     RelativeSizeAxes = Axes.X,
                                     AutoSizeAxes = Axes.Y,
@@ -149,6 +180,7 @@ private void load()
             };
 
             usernameTextBox.OnCommit += (_, _) => { calculateProfile(usernameTextBox.Current.Value); };
+            sorting.ValueChanged += e => { updateSorting(e.NewValue); };
 
             if (RuntimeInfo.IsDesktop)
                 HotReloadCallbackReceiver.CompilationFinished += _ => Schedule(() => { calculateProfile(currentUser); });
@@ -191,7 +223,16 @@ private void calculateProfile(string username)
                         RelativeSizeAxes = Axes.X
                     });
 
-                    layout.RowDimensions = new[] { new Dimension(GridSizeMode.Absolute, username_container_height), new Dimension(GridSizeMode.AutoSize), new Dimension() };
+                    sortingTabControl.Alpha = 1.0f;
+                    sortingTabControl.Current.Value = ProfileSortCriteria.Local;
+
+                    layout.RowDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.Absolute, username_container_height),
+                        new Dimension(GridSizeMode.AutoSize),
+                        new Dimension(GridSizeMode.AutoSize),
+                        new Dimension()
+                    };
                 });
 
                 if (token.IsCancellationRequested)
@@ -284,7 +325,7 @@ private void calculateProfile(string username)
                     loadingLayer.Hide();
                     calculationButton.State.Value = ButtonState.Done;
                 });
-            }, token);
+            }, TaskContinuationOptions.None);
         }
 
         protected override void Dispose(bool isDisposing)
@@ -295,5 +336,46 @@ protected override void Dispose(bool isDisposing)
             calculationCancellatonToken?.Dispose();
             calculationCancellatonToken = null;
         }
+
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.Key == Key.Escape && !calculationCancellatonToken.IsCancellationRequested)
+            {
+                calculationCancellatonToken?.Cancel();
+            }
+
+            return base.OnKeyDown(e);
+        }
+
+        private void updateSorting(ProfileSortCriteria sortCriteria)
+        {
+            if (!scores.Children.Any())
+                return;
+
+            ExtendedProfileScore[] sortedScores;
+
+            switch (sortCriteria)
+            {
+                case ProfileSortCriteria.Live:
+                    sortedScores = scores.Children.OrderByDescending(x => x.Score.LivePP).ToArray();
+                    break;
+
+                case ProfileSortCriteria.Local:
+                    sortedScores = scores.Children.OrderByDescending(x => x.Score.PerformanceAttributes.Total).ToArray();
+                    break;
+
+                case ProfileSortCriteria.Difference:
+                    sortedScores = scores.Children.OrderByDescending(x => x.Score.PerformanceAttributes.Total - x.Score.LivePP).ToArray();
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(sortCriteria), sortCriteria, null);
+            }
+
+            for (int i = 0; i < sortedScores.Length; i++)
+            {
+                scores.SetLayoutPosition(sortedScores[i], i);
+            }
+        }
     }
 }
diff --git a/PerformanceCalculatorGUI/Screens/SimulateScreen.cs b/PerformanceCalculatorGUI/Screens/SimulateScreen.cs
index c31a62771..c067745a5 100644
--- a/PerformanceCalculatorGUI/Screens/SimulateScreen.cs
+++ b/PerformanceCalculatorGUI/Screens/SimulateScreen.cs
@@ -28,6 +28,7 @@
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play.HUD;
@@ -51,7 +52,10 @@ public partial class SimulateScreen : PerformanceCalculatorScreen
         private LabelledTextBox beatmapIdTextBox;
         private SwitchButton beatmapImportTypeSwitch;
 
+        private GridContainer missesContainer;
         private LimitedLabelledNumberBox missesTextBox;
+        private LimitedLabelledNumberBox largeTickMissesTextBox;
+        private LimitedLabelledNumberBox sliderTailMissesTextBox;
         private LimitedLabelledNumberBox comboTextBox;
         private LimitedLabelledNumberBox scoreTextBox;
 
@@ -135,8 +139,8 @@ private void load(OsuColour osuColour)
                                 AutoSizeAxes = Axes.Y,
                                 ColumnDimensions = new[]
                                 {
-                                    new Dimension(),
                                     new Dimension(GridSizeMode.Absolute),
+                                    new Dimension(),
                                     new Dimension(GridSizeMode.AutoSize)
                                 },
                                 RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
@@ -254,21 +258,55 @@ private void load(OsuColour osuColour)
                                                         }
                                                     }
                                                 },
-                                                missesTextBox = new LimitedLabelledNumberBox
+                                                comboTextBox = new LimitedLabelledNumberBox
                                                 {
                                                     RelativeSizeAxes = Axes.X,
                                                     Anchor = Anchor.TopLeft,
-                                                    Label = "Misses",
+                                                    Label = "Combo",
                                                     PlaceholderText = "0",
                                                     MinValue = 0
                                                 },
-                                                comboTextBox = new LimitedLabelledNumberBox
+                                                missesContainer = new GridContainer
                                                 {
                                                     RelativeSizeAxes = Axes.X,
-                                                    Anchor = Anchor.TopLeft,
-                                                    Label = "Combo",
-                                                    PlaceholderText = "0",
-                                                    MinValue = 0
+                                                    AutoSizeAxes = Axes.Y,
+                                                    ColumnDimensions = new[]
+                                                    {
+                                                        new Dimension(),
+                                                        new Dimension(),
+                                                        new Dimension()
+                                                    },
+                                                    RowDimensions = new[] { new Dimension(GridSizeMode.AutoSize) },
+                                                    Content = new[]
+                                                    {
+                                                        new Drawable[]
+                                                        {
+                                                            missesTextBox = new LimitedLabelledNumberBox
+                                                            {
+                                                                RelativeSizeAxes = Axes.X,
+                                                                Anchor = Anchor.TopLeft,
+                                                                Label = "Misses",
+                                                                PlaceholderText = "0",
+                                                                MinValue = 0
+                                                            },
+                                                            largeTickMissesTextBox = new LimitedLabelledNumberBox
+                                                            {
+                                                                RelativeSizeAxes = Axes.X,
+                                                                Anchor = Anchor.TopLeft,
+                                                                Label = "Large Tick Misses",
+                                                                PlaceholderText = "0",
+                                                                MinValue = 0
+                                                            },
+                                                            sliderTailMissesTextBox = new LimitedLabelledNumberBox
+                                                            {
+                                                                RelativeSizeAxes = Axes.X,
+                                                                Anchor = Anchor.TopLeft,
+                                                                Label = "Slider Tail Misses",
+                                                                PlaceholderText = "0",
+                                                                MinValue = 0
+                                                            }
+                                                        }
+                                                    }
                                                 },
                                                 scoreTextBox = new LimitedLabelledNumberBox
                                                 {
@@ -423,21 +461,21 @@ private void load(OsuColour osuColour)
                 {
                     beatmapImportContainer.ColumnDimensions = new[]
                     {
-                        new Dimension(GridSizeMode.Absolute),
                         new Dimension(),
+                        new Dimension(GridSizeMode.Absolute),
                         new Dimension(GridSizeMode.AutoSize)
                     };
-
-                    fixupTextBox(beatmapIdTextBox);
                 }
                 else
                 {
                     beatmapImportContainer.ColumnDimensions = new[]
                     {
-                        new Dimension(),
                         new Dimension(GridSizeMode.Absolute),
+                        new Dimension(),
                         new Dimension(GridSizeMode.AutoSize)
                     };
+
+                    fixupTextBox(beatmapIdTextBox);
                 }
             });
 
@@ -445,6 +483,8 @@ private void load(OsuColour osuColour)
             goodsTextBox.Value.BindValueChanged(_ => debouncedCalculatePerformance());
             mehsTextBox.Value.BindValueChanged(_ => debouncedCalculatePerformance());
             missesTextBox.Value.BindValueChanged(_ => debouncedCalculatePerformance());
+            largeTickMissesTextBox.Value.BindValueChanged(_ => debouncedCalculatePerformance());
+            sliderTailMissesTextBox.Value.BindValueChanged(_ => debouncedCalculatePerformance());
             comboTextBox.Value.BindValueChanged(_ => debouncedCalculatePerformance());
             scoreTextBox.Value.BindValueChanged(_ => debouncedCalculatePerformance());
 
@@ -484,14 +524,22 @@ protected override void Dispose(bool isDisposing)
 
         private void modsChanged(ValueChangedEvent<IReadOnlyList<Mod>> mods)
         {
+            // Hotfix for preventing a difficulty and performance calculation from being trigger twice,
+            // as the mod overlay for some reason triggers a ValueChanged twice per mod change.
+            if (mods.OldValue.SequenceEqual(mods.NewValue))
+                return;
+
             modSettingChangeTracker?.Dispose();
 
             if (working is null)
                 return;
 
+            updateMissesTextboxes();
+
             modSettingChangeTracker = new ModSettingChangeTracker(mods.NewValue);
             modSettingChangeTracker.SettingChanged += m =>
             {
+                updateMissesTextboxes();
                 debouncedStatisticsUpdate?.Cancel();
                 debouncedStatisticsUpdate = Scheduler.AddDelayed(() =>
                 {
@@ -503,6 +551,24 @@ private void modsChanged(ValueChangedEvent<IReadOnlyList<Mod>> mods)
             calculateDifficulty();
             updateCombo(false);
             calculatePerformance();
+
+            void updateMissesTextboxes()
+            {
+                if (ruleset.Value.ShortName == "osu")
+                {
+                    // Large tick misses and slider tail misses are only relevant in PP if slider head accuracy exists
+                    if (mods.NewValue.OfType<OsuModClassic>().Any(m => m.NoSliderHeadAccuracy.Value))
+                    {
+                        missesContainer.Content = new[] { new[] { missesTextBox } };
+                        missesContainer.ColumnDimensions = [new Dimension()];
+                    }
+                    else
+                    {
+                        missesContainer.Content = new[] { new[] { missesTextBox, largeTickMissesTextBox, sliderTailMissesTextBox } };
+                        missesContainer.ColumnDimensions = [new Dimension(), new Dimension(), new Dimension()];
+                    }
+                }
+            }
         }
 
         private void resetBeatmap()
@@ -636,8 +702,18 @@ private void calculatePerformance()
                 if (ruleset.Value.OnlineID != -1)
                 {
                     // official rulesets can generate more precise hits from accuracy
-                    statistics = RulesetHelper.GenerateHitResultsForRuleset(ruleset.Value, accuracyTextBox.Value.Value / 100.0, beatmap, missesTextBox.Value.Value, countMeh, countGood);
-                    accuracy = RulesetHelper.GetAccuracyForRuleset(ruleset.Value, statistics);
+                    if (appliedMods.Value.OfType<OsuModClassic>().Any(m => m.NoSliderHeadAccuracy.Value))
+                    {
+                        statistics = RulesetHelper.GenerateHitResultsForRuleset(ruleset.Value, accuracyTextBox.Value.Value / 100.0, beatmap, missesTextBox.Value.Value, countMeh, countGood,
+                            null, null);
+                    }
+                    else
+                    {
+                        statistics = RulesetHelper.GenerateHitResultsForRuleset(ruleset.Value, accuracyTextBox.Value.Value / 100.0, beatmap, missesTextBox.Value.Value, countMeh, countGood,
+                            largeTickMissesTextBox.Value.Value, sliderTailMissesTextBox.Value.Value);
+                    }
+
+                    accuracy = RulesetHelper.GetAccuracyForRuleset(ruleset.Value, beatmap, statistics);
                 }
 
                 var ppAttributes = performanceCalculator?.Calculate(new ScoreInfo(beatmap.BeatmapInfo, ruleset.Value)
@@ -671,6 +747,8 @@ private void populateScoreParams()
             accuracyContainer.Hide();
             comboTextBox.Hide();
             missesTextBox.Hide();
+            largeTickMissesTextBox.Hide();
+            sliderTailMissesTextBox.Hide();
             scoreTextBox.Hide();
 
             if (ruleset.Value.ShortName == "osu" || ruleset.Value.ShortName == "taiko" || ruleset.Value.ShortName == "fruits")
@@ -681,6 +759,12 @@ private void populateScoreParams()
                 updateCombo(true);
                 comboTextBox.Show();
                 missesTextBox.Show();
+
+                if (ruleset.Value.ShortName == "osu")
+                {
+                    largeTickMissesTextBox.Show();
+                    sliderTailMissesTextBox.Show();
+                }
             }
             else if (ruleset.Value.ShortName == "mania")
             {
@@ -701,6 +785,8 @@ private void populateScoreParams()
                 updateCombo(true);
                 comboTextBox.Show();
                 missesTextBox.Show();
+                largeTickMissesTextBox.Show();
+                sliderTailMissesTextBox.Show();
 
                 scoreTextBox.Text = string.Empty;
                 scoreTextBox.Show();
diff --git a/osu.Tools.sln.DotSettings b/osu.Tools.sln.DotSettings
index df16bfa3c..1c52afdeb 100644
--- a/osu.Tools.sln.DotSettings
+++ b/osu.Tools.sln.DotSettings
@@ -769,9 +769,19 @@ See the LICENCE file in the repository root for full licence text.&#xD;
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=StaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=TypeParameters/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=15b5b1f1_002D457c_002D4ca6_002Db278_002D5615aedc07d3/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static readonly fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=236f7aa5_002D7b06_002D43ca_002Dbf2a_002D9b31bfcff09a/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Any" AccessRightKinds="Private" Description="Constant fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="CONSTANT_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=2c62818f_002D621b_002D4425_002Dadc9_002D78611099bfcb/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Any" AccessRightKinds="Any" Description="Type parameters"&gt;&lt;ElementKinds&gt;&lt;Kind Name="TYPE_PARAMETER" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=4a98fdf6_002D7d98_002D4f5a_002Dafeb_002Dea44ad98c70c/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Instance" AccessRightKinds="Private" Description="Instance fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="FIELD" /&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb"&gt;&lt;ExtraRule Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=669e5282_002Dfb4b_002D4e90_002D91e7_002D07d269d04b60/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Any" AccessRightKinds="Protected, ProtectedInternal, Internal, Public, PrivateProtected" Description="Constant fields (not private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="CONSTANT_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=76f79b1e_002Dece7_002D4df2_002Da322_002D1bd7fea25eb7/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Any" AccessRightKinds="Any" Description="Local functions"&gt;&lt;ElementKinds&gt;&lt;Kind Name="LOCAL_FUNCTION" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=8b8504e3_002Df0be_002D4c14_002D9103_002Dc732f2bddc15/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Any" AccessRightKinds="Any" Description="Enum members"&gt;&lt;ElementKinds&gt;&lt;Kind Name="ENUM_MEMBER" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="False" Prefix="" Suffix="" Style="AaBb" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=9d1af99b_002Dbefe_002D48a4_002D9eb3_002D661384e29869/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static, Instance" AccessRightKinds="Private" Description="private methods"&gt;&lt;ElementKinds&gt;&lt;Kind Name="ASYNC_METHOD" /&gt;&lt;Kind Name="METHOD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=9ffbe43b_002Dc610_002D411b_002D9839_002D1416a146d9b0/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static, Instance" AccessRightKinds="Protected, ProtectedInternal, Internal, Public" Description="internal/protected/public methods"&gt;&lt;ElementKinds&gt;&lt;Kind Name="ASYNC_METHOD" /&gt;&lt;Kind Name="METHOD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=a4c2df6c_002Db202_002D48d5_002Db077_002De678cb548c25/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static, Instance" AccessRightKinds="Private" Description="private properties"&gt;&lt;ElementKinds&gt;&lt;Kind Name="PROPERTY" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=a4f433b8_002Dabcd_002D4e55_002Da08f_002D82e78cef0f0c/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Any" AccessRightKinds="Any" Description="Local constants"&gt;&lt;ElementKinds&gt;&lt;Kind Name="LOCAL_CONSTANT" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=c873eafb_002Dd57f_002D481d_002D8c93_002D77f6863c2f88/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Protected, ProtectedInternal, Internal, Public, PrivateProtected" Description="Static readonly fields (not private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=f9fce829_002De6f4_002D4cb2_002D80f1_002D5497c44f51df/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=fd562728_002Dc23d_002D417f_002Da19f_002D9d854247fbea/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static, Instance" AccessRightKinds="Protected, ProtectedInternal, Internal, Public" Description="internal/protected/public properties"&gt;&lt;ElementKinds&gt;&lt;Kind Name="PROPERTY" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FCONSTANT/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
@@ -836,6 +846,7 @@ See the LICENCE file in the repository root for full licence text.&#xD;
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EPredefinedNamingRulesToUserRulesUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:String x:Key="/Default/Environment/UnitTesting/NUnitProvider/SetCurrentDirectoryTo/@EntryValue">TestFolder</s:String>
 	<s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=28A2A5FC43E07C488A4BC7430879479E/@KeyIndexDefined">True</s:Boolean>
 	<s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=28A2A5FC43E07C488A4BC7430879479E/Applicability/=Live/@EntryIndexedValue">True</s:Boolean>