Merge pull request #26381 from Joehuu/flash-ongoing-operations-dialog

Flash blocking ongoing operations dialog when trying to force quit
Use repeat step for more delay between the two exits
2026-05-20 14:40:19 +08:00 · 2024-01-05 18:34:06 +09:00 · 2024-01-04 09:00:24 -08:00 · 2024-01-04 19:26:49 +09:00 · 2024-01-04 19:26:28 +09:00 · 2024-01-04 18:45:17 +09:00
82 changed files with 1693 additions and 211 deletions
@@ -42,7 +42,7 @@ body:
  - type: input
    attributes:
      label: Version
-      description: The version you encountered this bug on. This is shown at the bottom of the main menu and also at the end of the settings screen.
+      description: The version you encountered this bug on. This is shown at the end of the settings overlay.
    validations:
      required: true
  - type: markdown
@@ -0,0 +1,739 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable disable
+
+#pragma warning disable IDE1006 // Naming rule violation
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using osu.Framework.Logging;
+
+namespace osu.Desktop
+{
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    internal static class NVAPI
+    {
+        private const string osu_filename = "osu!.exe";
+
+        // This is a good reference:
+        // https://github.com/errollw/Warp-and-Blend-Quadros/blob/master/WarpBlend-Quadros/UnwarpAll-Quadros/include/nvapi.h
+        // Note our Stride == their VERSION (e.g. NVDRS_SETTING_VER)
+
+        public const int MAX_PHYSICAL_GPUS = 64;
+        public const int UNICODE_STRING_MAX = 2048;
+
+        public const string APPLICATION_NAME = @"osu!";
+        public const string PROFILE_NAME = @"osu!";
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus EnumPhysicalGPUsDelegate([Out] IntPtr[] gpuHandles, out int gpuCount);
+
+        public static readonly EnumPhysicalGPUsDelegate EnumPhysicalGPUs;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus EnumLogicalGPUsDelegate([Out] IntPtr[] gpuHandles, out int gpuCount);
+
+        public static readonly EnumLogicalGPUsDelegate EnumLogicalGPUs;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetSystemTypeDelegate(IntPtr gpuHandle, out NvSystemType systemType);
+
+        public static readonly GetSystemTypeDelegate GetSystemType;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetGPUTypeDelegate(IntPtr gpuHandle, out NvGpuType gpuType);
+
+        public static readonly GetGPUTypeDelegate GetGPUType;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus CreateSessionDelegate(out IntPtr sessionHandle);
+
+        public static CreateSessionDelegate CreateSession;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus LoadSettingsDelegate(IntPtr sessionHandle);
+
+        public static LoadSettingsDelegate LoadSettings;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus FindApplicationByNameDelegate(IntPtr sessionHandle, [MarshalAs(UnmanagedType.BStr)] string appName, out IntPtr profileHandle, ref NvApplication application);
+
+        public static FindApplicationByNameDelegate FindApplicationByName;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetCurrentGlobalProfileDelegate(IntPtr sessionHandle, out IntPtr profileHandle);
+
+        public static GetCurrentGlobalProfileDelegate GetCurrentGlobalProfile;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetProfileInfoDelegate(IntPtr sessionHandle, IntPtr profileHandle, ref NvProfile profile);
+
+        public static GetProfileInfoDelegate GetProfileInfo;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate NvStatus GetSettingDelegate(IntPtr sessionHandle, IntPtr profileHandle, NvSettingID settingID, ref NvSetting setting);
+
+        public static GetSettingDelegate GetSetting;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus CreateProfileDelegate(IntPtr sessionHandle, ref NvProfile profile, out IntPtr profileHandle);
+
+        private static readonly CreateProfileDelegate CreateProfile;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus SetSettingDelegate(IntPtr sessionHandle, IntPtr profileHandle, ref NvSetting setting);
+
+        private static readonly SetSettingDelegate SetSetting;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus EnumApplicationsDelegate(IntPtr sessionHandle, IntPtr profileHandle, uint startIndex, ref uint appCount, [In, Out, MarshalAs(UnmanagedType.LPArray)] NvApplication[] applications);
+
+        private static readonly EnumApplicationsDelegate EnumApplications;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus CreateApplicationDelegate(IntPtr sessionHandle, IntPtr profileHandle, ref NvApplication application);
+
+        private static readonly CreateApplicationDelegate CreateApplication;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate NvStatus SaveSettingsDelegate(IntPtr sessionHandle);
+
+        private static readonly SaveSettingsDelegate SaveSettings;
+
+        public static NvStatus Status { get; private set; } = NvStatus.OK;
+        public static bool Available { get; private set; }
+
+        private static IntPtr sessionHandle;
+
+        public static bool IsUsingOptimusDedicatedGpu
+        {
+            get
+            {
+                if (!Available)
+                    return false;
+
+                if (!IsLaptop)
+                    return false;
+
+                IntPtr profileHandle;
+                if (!getProfile(out profileHandle, out _, out bool _))
+                    return false;
+
+                // Get the optimus setting
+                NvSetting setting;
+                if (!getSetting(NvSettingID.SHIM_RENDERING_MODE_ID, profileHandle, out setting))
+                    return false;
+
+                return (setting.U32CurrentValue & (uint)NvShimSetting.SHIM_RENDERING_MODE_ENABLE) > 0;
+            }
+        }
+
+        public static bool IsLaptop
+        {
+            get
+            {
+                if (!Available)
+                    return false;
+
+                // Make sure that this is a laptop.
+                var gpus = new IntPtr[64];
+                if (checkError(EnumPhysicalGPUs(gpus, out int gpuCount)))
+                    return false;
+
+                for (int i = 0; i < gpuCount; i++)
+                {
+                    if (checkError(GetSystemType(gpus[i], out var type)))
+                        return false;
+
+                    if (type == NvSystemType.LAPTOP)
+                        return true;
+                }
+
+                return false;
+            }
+        }
+
+        public static NvThreadControlSetting ThreadedOptimisations
+        {
+            get
+            {
+                if (!Available)
+                    return NvThreadControlSetting.OGL_THREAD_CONTROL_DEFAULT;
+
+                IntPtr profileHandle;
+                if (!getProfile(out profileHandle, out _, out bool _))
+                    return NvThreadControlSetting.OGL_THREAD_CONTROL_DEFAULT;
+
+                // Get the threaded optimisations setting
+                NvSetting setting;
+                if (!getSetting(NvSettingID.OGL_THREAD_CONTROL_ID, profileHandle, out setting))
+                    return NvThreadControlSetting.OGL_THREAD_CONTROL_DEFAULT;
+
+                return (NvThreadControlSetting)setting.U32CurrentValue;
+            }
+            set
+            {
+                if (!Available)
+                    return;
+
+                bool success = setSetting(NvSettingID.OGL_THREAD_CONTROL_ID, (uint)value);
+
+                Logger.Log(success ? $"Threaded optimizations set to \"{value}\"!" : "Threaded optimizations set failed!");
+            }
+        }
+
+        /// <summary>
+        /// Checks if the profile contains the current application.
+        /// </summary>
+        /// <returns>If the profile contains the current application.</returns>
+        private static bool containsApplication(IntPtr profileHandle, NvProfile profile, out NvApplication application)
+        {
+            application = new NvApplication
+            {
+                Version = NvApplication.Stride
+            };
+
+            if (profile.NumOfApps == 0)
+                return false;
+
+            NvApplication[] applications = new NvApplication[profile.NumOfApps];
+            applications[0].Version = NvApplication.Stride;
+
+            uint numApps = profile.NumOfApps;
+
+            if (checkError(EnumApplications(sessionHandle, profileHandle, 0, ref numApps, applications)))
+                return false;
+
+            for (uint i = 0; i < numApps; i++)
+            {
+                if (applications[i].AppName == osu_filename)
+                {
+                    application = applications[i];
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Retrieves the profile of the current application.
+        /// </summary>
+        /// <param name="profileHandle">The profile handle.</param>
+        /// <param name="application">The current application description.</param>
+        /// <param name="isApplicationSpecific">If this profile is not a global (default) profile.</param>
+        /// <returns>If the operation succeeded.</returns>
+        private static bool getProfile(out IntPtr profileHandle, out NvApplication application, out bool isApplicationSpecific)
+        {
+            application = new NvApplication
+            {
+                Version = NvApplication.Stride
+            };
+
+            isApplicationSpecific = true;
+
+            if (checkError(FindApplicationByName(sessionHandle, osu_filename, out profileHandle, ref application)))
+            {
+                isApplicationSpecific = false;
+                if (checkError(GetCurrentGlobalProfile(sessionHandle, out profileHandle)))
+                    return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Creates a profile.
+        /// </summary>
+        /// <param name="profileHandle">The profile handle.</param>
+        /// <returns>If the operation succeeded.</returns>
+        private static bool createProfile(out IntPtr profileHandle)
+        {
+            NvProfile newProfile = new NvProfile
+            {
+                Version = NvProfile.Stride,
+                IsPredefined = 0,
+                ProfileName = PROFILE_NAME,
+                GPUSupport = new uint[32]
+            };
+
+            newProfile.GPUSupport[0] = 1;
+
+            if (checkError(CreateProfile(sessionHandle, ref newProfile, out profileHandle)))
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Retrieves a setting from the profile.
+        /// </summary>
+        /// <param name="settingId">The setting to retrieve.</param>
+        /// <param name="profileHandle">The profile handle to retrieve the setting from.</param>
+        /// <param name="setting">The setting.</param>
+        /// <returns>If the operation succeeded.</returns>
+        private static bool getSetting(NvSettingID settingId, IntPtr profileHandle, out NvSetting setting)
+        {
+            setting = new NvSetting
+            {
+                Version = NvSetting.Stride,
+                SettingID = settingId
+            };
+
+            if (checkError(GetSetting(sessionHandle, profileHandle, settingId, ref setting)))
+                return false;
+
+            return true;
+        }
+
+        private static bool setSetting(NvSettingID settingId, uint settingValue)
+        {
+            NvApplication application;
+            IntPtr profileHandle;
+            bool isApplicationSpecific;
+            if (!getProfile(out profileHandle, out application, out isApplicationSpecific))
+                return false;
+
+            if (!isApplicationSpecific)
+            {
+                // We don't want to interfere with the user's other settings, so let's create a separate config for osu!
+                if (!createProfile(out profileHandle))
+                    return false;
+            }
+
+            NvSetting newSetting = new NvSetting
+            {
+                Version = NvSetting.Stride,
+                SettingID = settingId,
+                U32CurrentValue = settingValue
+            };
+
+            // Set the thread state
+            if (checkError(SetSetting(sessionHandle, profileHandle, ref newSetting)))
+                return false;
+
+            // Get the profile (needed to check app count)
+            NvProfile profile = new NvProfile
+            {
+                Version = NvProfile.Stride
+            };
+            if (checkError(GetProfileInfo(sessionHandle, profileHandle, ref profile)))
+                return false;
+
+            if (!containsApplication(profileHandle, profile, out application))
+            {
+                // Need to add the current application to the profile
+                application.IsPredefined = 0;
+
+                application.AppName = osu_filename;
+                application.UserFriendlyName = APPLICATION_NAME;
+
+                if (checkError(CreateApplication(sessionHandle, profileHandle, ref application)))
+                    return false;
+            }
+
+            // Save!
+            return !checkError(SaveSettings(sessionHandle));
+        }
+
+        /// <summary>
+        /// Creates a session to access the driver configuration.
+        /// </summary>
+        /// <returns>If the operation succeeded.</returns>
+        private static bool createSession()
+        {
+            if (checkError(CreateSession(out sessionHandle)))
+                return false;
+
+            // Load settings into session
+            if (checkError(LoadSettings(sessionHandle)))
+                return false;
+
+            return true;
+        }
+
+        private static bool checkError(NvStatus status)
+        {
+            Status = status;
+            return status != NvStatus.OK;
+        }
+
+        static NVAPI()
+        {
+            // TODO: check whether gpu vendor contains NVIDIA before attempting load?
+
+            try
+            {
+                // Try to load NVAPI
+                if ((IntPtr.Size == 4 && loadLibrary(@"nvapi.dll") == IntPtr.Zero)
+                    || (IntPtr.Size == 8 && loadLibrary(@"nvapi64.dll") == IntPtr.Zero))
+                {
+                    return;
+                }
+
+                InitializeDelegate initialize;
+                getDelegate(0x0150E828, out initialize);
+
+                if (initialize?.Invoke() == NvStatus.OK)
+                {
+                    // IDs can be found here: https://github.com/jNizM/AHK_NVIDIA_NvAPI/blob/master/info/NvAPI_IDs.txt
+
+                    getDelegate(0xE5AC921F, out EnumPhysicalGPUs);
+                    getDelegate(0x48B3EA59, out EnumLogicalGPUs);
+                    getDelegate(0xBAAABFCC, out GetSystemType);
+                    getDelegate(0xC33BAEB1, out GetGPUType);
+                    getDelegate(0x0694D52E, out CreateSession);
+                    getDelegate(0x375DBD6B, out LoadSettings);
+                    getDelegate(0xEEE566B2, out FindApplicationByName);
+                    getDelegate(0x617BFF9F, out GetCurrentGlobalProfile);
+                    getDelegate(0x577DD202, out SetSetting);
+                    getDelegate(0x61CD6FD6, out GetProfileInfo);
+                    getDelegate(0x73BF8338, out GetSetting);
+                    getDelegate(0xCC176068, out CreateProfile);
+                    getDelegate(0x7FA2173A, out EnumApplications);
+                    getDelegate(0x4347A9DE, out CreateApplication);
+                    getDelegate(0xFCBC7E14, out SaveSettings);
+                }
+
+                if (createSession())
+                    Available = true;
+            }
+            catch { }
+        }
+
+        private static void getDelegate<T>(uint id, out T newDelegate) where T : class
+        {
+            IntPtr ptr = IntPtr.Size == 4 ? queryInterface32(id) : queryInterface64(id);
+            newDelegate = ptr == IntPtr.Zero ? null : Marshal.GetDelegateForFunctionPointer(ptr, typeof(T)) as T;
+        }
+
+        [DllImport("kernel32.dll", EntryPoint = "LoadLibrary")]
+        private static extern IntPtr loadLibrary(string dllToLoad);
+
+        [DllImport(@"nvapi.dll", EntryPoint = "nvapi_QueryInterface", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr queryInterface32(uint id);
+
+        [DllImport(@"nvapi64.dll", EntryPoint = "nvapi_QueryInterface", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr queryInterface64(uint id);
+
+        private delegate NvStatus InitializeDelegate();
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    internal struct NvSetting
+    {
+        public uint Version;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string SettingName;
+
+        public NvSettingID SettingID;
+        public uint SettingType;
+        public uint SettingLocation;
+        public uint IsCurrentPredefined;
+        public uint IsPredefinedValid;
+
+        public uint U32PredefinedValue;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string StringPredefinedValue;
+
+        public uint U32CurrentValue;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string StringCurrentValue;
+
+        public static uint Stride => (uint)Marshal.SizeOf(typeof(NvSetting)) | (1 << 16);
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 8, CharSet = CharSet.Unicode)]
+    internal struct NvProfile
+    {
+        public uint Version;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string ProfileName;
+
+        [MarshalAs(UnmanagedType.ByValArray)]
+        public uint[] GPUSupport;
+
+        public uint IsPredefined;
+        public uint NumOfApps;
+        public uint NumOfSettings;
+
+        public static uint Stride => (uint)Marshal.SizeOf(typeof(NvProfile)) | (1 << 16);
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 8, CharSet = CharSet.Unicode)]
+    internal struct NvApplication
+    {
+        public uint Version;
+        public uint IsPredefined;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string AppName;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string UserFriendlyName;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string Launcher;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NVAPI.UNICODE_STRING_MAX)]
+        public string FileInFolder;
+
+        public static uint Stride => (uint)Marshal.SizeOf(typeof(NvApplication)) | (2 << 16);
+    }
+
+    internal enum NvStatus
+    {
+        OK = 0, // Success. Request is completed.
+        ERROR = -1, // Generic error
+        LIBRARY_NOT_FOUND = -2, // NVAPI support library cannot be loaded.
+        NO_IMPLEMENTATION = -3, // not implemented in current driver installation
+        API_NOT_INITIALIZED = -4, // Initialize has not been called (successfully)
+        INVALID_ARGUMENT = -5, // The argument/parameter value is not valid or NULL.
+        NVIDIA_DEVICE_NOT_FOUND = -6, // No NVIDIA display driver, or NVIDIA GPU driving a display, was found.
+        END_ENUMERATION = -7, // No more items to enumerate
+        INVALID_HANDLE = -8, // Invalid handle
+        INCOMPATIBLE_STRUCT_VERSION = -9, // An argument's structure version is not supported
+        HANDLE_INVALIDATED = -10, // The handle is no longer valid (likely due to GPU or display re-configuration)
+        OPENGL_CONTEXT_NOT_CURRENT = -11, // No NVIDIA OpenGL context is current (but needs to be)
+        INVALID_POINTER = -14, // An invalid pointer, usually NULL, was passed as a parameter
+        NO_GL_EXPERT = -12, // OpenGL Expert is not supported by the current drivers
+        INSTRUMENTATION_DISABLED = -13, // OpenGL Expert is supported, but driver instrumentation is currently disabled
+        NO_GL_NSIGHT = -15, // OpenGL does not support Nsight
+
+        EXPECTED_LOGICAL_GPU_HANDLE = -100, // Expected a logical GPU handle for one or more parameters
+        EXPECTED_PHYSICAL_GPU_HANDLE = -101, // Expected a physical GPU handle for one or more parameters
+        EXPECTED_DISPLAY_HANDLE = -102, // Expected an NV display handle for one or more parameters
+        INVALID_COMBINATION = -103, // The combination of parameters is not valid.
+        NOT_SUPPORTED = -104, // Requested feature is not supported in the selected GPU
+        PORTID_NOT_FOUND = -105, // No port ID was found for the I2C transaction
+        EXPECTED_UNATTACHED_DISPLAY_HANDLE = -106, // Expected an unattached display handle as one of the input parameters.
+        INVALID_PERF_LEVEL = -107, // Invalid perf level
+        DEVICE_BUSY = -108, // Device is busy; request not fulfilled
+        NV_PERSIST_FILE_NOT_FOUND = -109, // NV persist file is not found
+        PERSIST_DATA_NOT_FOUND = -110, // NV persist data is not found
+        EXPECTED_TV_DISPLAY = -111, // Expected a TV output display
+        EXPECTED_TV_DISPLAY_ON_DCONNECTOR = -112, // Expected a TV output on the D Connector - HDTV_EIAJ4120.
+        NO_ACTIVE_SLI_TOPOLOGY = -113, // SLI is not active on this device.
+        SLI_RENDERING_MODE_NOTALLOWED = -114, // Setup of SLI rendering mode is not possible right now.
+        EXPECTED_DIGITAL_FLAT_PANEL = -115, // Expected a digital flat panel.
+        ARGUMENT_EXCEED_MAX_SIZE = -116, // Argument exceeds the expected size.
+        DEVICE_SWITCHING_NOT_ALLOWED = -117, // Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active.
+        TESTING_CLOCKS_NOT_SUPPORTED = -118, // Testing of clocks is not supported.
+        UNKNOWN_UNDERSCAN_CONFIG = -119, // The specified underscan config is from an unknown source (e.g. INF)
+        TIMEOUT_RECONFIGURING_GPU_TOPO = -120, // Timeout while reconfiguring GPUs
+        DATA_NOT_FOUND = -121, // Requested data was not found
+        EXPECTED_ANALOG_DISPLAY = -122, // Expected an analog display
+        NO_VIDLINK = -123, // No SLI video bridge is present
+        REQUIRES_REBOOT = -124, // NVAPI requires a reboot for the settings to take effect
+        INVALID_HYBRID_MODE = -125, // The function is not supported with the current Hybrid mode.
+        MIXED_TARGET_TYPES = -126, // The target types are not all the same
+        SYSWOW64_NOT_SUPPORTED = -127, // The function is not supported from 32-bit on a 64-bit system.
+        IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED = -128, // There is no implicit GPU topology active. Use SetHybridMode to change topology.
+        REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS = -129, // Prompt the user to close all non-migratable applications.
+        OUT_OF_MEMORY = -130, // Could not allocate sufficient memory to complete the call.
+        WAS_STILL_DRAWING = -131, // The previous operation that is transferring information to or from this surface is incomplete.
+        FILE_NOT_FOUND = -132, // The file was not found.
+        TOO_MANY_UNIQUE_STATE_OBJECTS = -133, // There are too many unique instances of a particular type of state object.
+        INVALID_CALL = -134, // The method call is invalid. For example, a method's parameter may not be a valid pointer.
+        D3D10_1_LIBRARY_NOT_FOUND = -135, // d3d10_1.dll cannot be loaded.
+        FUNCTION_NOT_FOUND = -136, // Couldn't find the function in the loaded DLL.
+        INVALID_USER_PRIVILEGE = -137, // Current User is not Admin.
+        EXPECTED_NON_PRIMARY_DISPLAY_HANDLE = -138, // The handle corresponds to GDIPrimary.
+        EXPECTED_COMPUTE_GPU_HANDLE = -139, // Setting Physx GPU requires that the GPU is compute-capable.
+        STEREO_NOT_INITIALIZED = -140, // The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed.
+        STEREO_REGISTRY_ACCESS_FAILED = -141, // Access to stereo-related registry keys or values has failed.
+        STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED = -142, // The given registry profile type is not supported.
+        STEREO_REGISTRY_VALUE_NOT_SUPPORTED = -143, // The given registry value is not supported.
+        STEREO_NOT_ENABLED = -144, // Stereo is not enabled and the function needed it to execute completely.
+        STEREO_NOT_TURNED_ON = -145, // Stereo is not turned on and the function needed it to execute completely.
+        STEREO_INVALID_DEVICE_INTERFACE = -146, // Invalid device interface.
+        STEREO_PARAMETER_OUT_OF_RANGE = -147, // Separation percentage or JPEG image capture quality is out of [0-100] range.
+        STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED = -148, // The given frustum adjust mode is not supported.
+        TOPO_NOT_POSSIBLE = -149, // The mosaic topology is not possible given the current state of the hardware.
+        MODE_CHANGE_FAILED = -150, // An attempt to do a display resolution mode change has failed.
+        D3D11_LIBRARY_NOT_FOUND = -151, // d3d11.dll/d3d11_beta.dll cannot be loaded.
+        INVALID_ADDRESS = -152, // Address is outside of valid range.
+        STRING_TOO_SMALL = -153, // The pre-allocated string is too small to hold the result.
+        MATCHING_DEVICE_NOT_FOUND = -154, // The input does not match any of the available devices.
+        DRIVER_RUNNING = -155, // Driver is running.
+        DRIVER_NOTRUNNING = -156, // Driver is not running.
+        ERROR_DRIVER_RELOAD_REQUIRED = -157, // A driver reload is required to apply these settings.
+        SET_NOT_ALLOWED = -158, // Intended setting is not allowed.
+        ADVANCED_DISPLAY_TOPOLOGY_REQUIRED = -159, // Information can't be returned due to "advanced display topology".
+        SETTING_NOT_FOUND = -160, // Setting is not found.
+        SETTING_SIZE_TOO_LARGE = -161, // Setting size is too large.
+        TOO_MANY_SETTINGS_IN_PROFILE = -162, // There are too many settings for a profile.
+        PROFILE_NOT_FOUND = -163, // Profile is not found.
+        PROFILE_NAME_IN_USE = -164, // Profile name is duplicated.
+        PROFILE_NAME_EMPTY = -165, // Profile name is empty.
+        EXECUTABLE_NOT_FOUND = -166, // Application not found in the Profile.
+        EXECUTABLE_ALREADY_IN_USE = -167, // Application already exists in the other profile.
+        DATATYPE_MISMATCH = -168, // Data Type mismatch
+        PROFILE_REMOVED = -169, // The profile passed as parameter has been removed and is no longer valid.
+        UNREGISTERED_RESOURCE = -170, // An unregistered resource was passed as a parameter.
+        ID_OUT_OF_RANGE = -171, // The DisplayId corresponds to a display which is not within the normal outputId range.
+        DISPLAYCONFIG_VALIDATION_FAILED = -172, // Display topology is not valid so the driver cannot do a mode set on this configuration.
+        DPMST_CHANGED = -173, // Display Port Multi-Stream topology has been changed.
+        INSUFFICIENT_BUFFER = -174, // Input buffer is insufficient to hold the contents.
+        ACCESS_DENIED = -175, // No access to the caller.
+        MOSAIC_NOT_ACTIVE = -176, // The requested action cannot be performed without Mosaic being enabled.
+        SHARE_RESOURCE_RELOCATED = -177, // The surface is relocated away from video memory.
+        REQUEST_USER_TO_DISABLE_DWM = -178, // The user should disable DWM before calling NvAPI.
+        D3D_DEVICE_LOST = -179, // D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device.
+        INVALID_CONFIGURATION = -180, // The requested action cannot be performed in the current state.
+        STEREO_HANDSHAKE_NOT_DONE = -181, // Call failed as stereo handshake not completed.
+        EXECUTABLE_PATH_IS_AMBIGUOUS = -182, // The path provided was too short to determine the correct NVDRS_APPLICATION
+        DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED = -183, // Default stereo profile is not currently defined
+        DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST = -184, // Default stereo profile does not exist
+        CLUSTER_ALREADY_EXISTS = -185, // A cluster is already defined with the given configuration.
+        DPMST_DISPLAY_ID_EXPECTED = -186, // The input display id is not that of a multi stream enabled connector or a display device in a multi stream topology
+        INVALID_DISPLAY_ID = -187, // The input display id is not valid or the monitor associated to it does not support the current operation
+        STREAM_IS_OUT_OF_SYNC = -188, // While playing secure audio stream, stream goes out of sync
+        INCOMPATIBLE_AUDIO_DRIVER = -189, // Older audio driver version than required
+        VALUE_ALREADY_SET = -190, // Value already set, setting again not allowed.
+        TIMEOUT = -191, // Requested operation timed out
+        GPU_WORKSTATION_FEATURE_INCOMPLETE = -192, // The requested workstation feature set has incomplete driver internal allocation resources
+        STEREO_INIT_ACTIVATION_NOT_DONE = -193, // Call failed because InitActivation was not called.
+        SYNC_NOT_ACTIVE = -194, // The requested action cannot be performed without Sync being enabled.
+        SYNC_MASTER_NOT_FOUND = -195, // The requested action cannot be performed without Sync Master being enabled.
+        INVALID_SYNC_TOPOLOGY = -196, // Invalid displays passed in the NV_GSYNC_DISPLAY pointer.
+        ECID_SIGN_ALGO_UNSUPPORTED = -197, // The specified signing algorithm is not supported. Either an incorrect value was entered or the current installed driver/hardware does not support the input value.
+        ECID_KEY_VERIFICATION_FAILED = -198, // The encrypted public key verification has failed.
+        FIRMWARE_OUT_OF_DATE = -199, // The device's firmware is out of date.
+        FIRMWARE_REVISION_NOT_SUPPORTED = -200, // The device's firmware is not supported.
+    }
+
+    internal enum NvSystemType
+    {
+        UNKNOWN = 0,
+        LAPTOP = 1,
+        DESKTOP = 2
+    }
+
+    internal enum NvGpuType
+    {
+        UNKNOWN = 0,
+        IGPU = 1, // Integrated
+        DGPU = 2, // Discrete
+    }
+
+    internal enum NvSettingID : uint
+    {
+        OGL_AA_LINE_GAMMA_ID = 0x2089BF6C,
+        OGL_DEEP_COLOR_SCANOUT_ID = 0x2097C2F6,
+        OGL_DEFAULT_SWAP_INTERVAL_ID = 0x206A6582,
+        OGL_DEFAULT_SWAP_INTERVAL_FRACTIONAL_ID = 0x206C4581,
+        OGL_DEFAULT_SWAP_INTERVAL_SIGN_ID = 0x20655CFA,
+        OGL_EVENT_LOG_SEVERITY_THRESHOLD_ID = 0x209DF23E,
+        OGL_EXTENSION_STRING_VERSION_ID = 0x20FF7493,
+        OGL_FORCE_BLIT_ID = 0x201F619F,
+        OGL_FORCE_STEREO_ID = 0x204D9A0C,
+        OGL_IMPLICIT_GPU_AFFINITY_ID = 0x20D0F3E6,
+        OGL_MAX_FRAMES_ALLOWED_ID = 0x208E55E3,
+        OGL_MULTIMON_ID = 0x200AEBFC,
+        OGL_OVERLAY_PIXEL_TYPE_ID = 0x209AE66F,
+        OGL_OVERLAY_SUPPORT_ID = 0x206C28C4,
+        OGL_QUALITY_ENHANCEMENTS_ID = 0x20797D6C,
+        OGL_SINGLE_BACKDEPTH_BUFFER_ID = 0x20A29055,
+        OGL_THREAD_CONTROL_ID = 0x20C1221E,
+        OGL_TRIPLE_BUFFER_ID = 0x20FDD1F9,
+        OGL_VIDEO_EDITING_MODE_ID = 0x20EE02B4,
+        AA_BEHAVIOR_FLAGS_ID = 0x10ECDB82,
+        AA_MODE_ALPHATOCOVERAGE_ID = 0x10FC2D9C,
+        AA_MODE_GAMMACORRECTION_ID = 0x107D639D,
+        AA_MODE_METHOD_ID = 0x10D773D2,
+        AA_MODE_REPLAY_ID = 0x10D48A85,
+        AA_MODE_SELECTOR_ID = 0x107EFC5B,
+        AA_MODE_SELECTOR_SLIAA_ID = 0x107AFC5B,
+        ANISO_MODE_LEVEL_ID = 0x101E61A9,
+        ANISO_MODE_SELECTOR_ID = 0x10D2BB16,
+        APPLICATION_PROFILE_NOTIFICATION_TIMEOUT_ID = 0x104554B6,
+        APPLICATION_STEAM_ID_ID = 0x107CDDBC,
+        CPL_HIDDEN_PROFILE_ID = 0x106D5CFF,
+        CUDA_EXCLUDED_GPUS_ID = 0x10354FF8,
+        D3DOGL_GPU_MAX_POWER_ID = 0x10D1EF29,
+        EXPORT_PERF_COUNTERS_ID = 0x108F0841,
+        FXAA_ALLOW_ID = 0x1034CB89,
+        FXAA_ENABLE_ID = 0x1074C972,
+        FXAA_INDICATOR_ENABLE_ID = 0x1068FB9C,
+        MCSFRSHOWSPLIT_ID = 0x10287051,
+        OPTIMUS_MAXAA_ID = 0x10F9DC83,
+        PHYSXINDICATOR_ID = 0x1094F16F,
+        PREFERRED_PSTATE_ID = 0x1057EB71,
+        PREVENT_UI_AF_OVERRIDE_ID = 0x103BCCB5,
+        PS_FRAMERATE_LIMITER_ID = 0x10834FEE,
+        PS_FRAMERATE_LIMITER_GPS_CTRL_ID = 0x10834F01,
+        SHIM_MAXRES_ID = 0x10F9DC82,
+        SHIM_MCCOMPAT_ID = 0x10F9DC80,
+        SHIM_RENDERING_MODE_ID = 0x10F9DC81,
+        SHIM_RENDERING_OPTIONS_ID = 0x10F9DC84,
+        SLI_GPU_COUNT_ID = 0x1033DCD1,
+        SLI_PREDEFINED_GPU_COUNT_ID = 0x1033DCD2,
+        SLI_PREDEFINED_GPU_COUNT_DX10_ID = 0x1033DCD3,
+        SLI_PREDEFINED_MODE_ID = 0x1033CEC1,
+        SLI_PREDEFINED_MODE_DX10_ID = 0x1033CEC2,
+        SLI_RENDERING_MODE_ID = 0x1033CED1,
+        VRRFEATUREINDICATOR_ID = 0x1094F157,
+        VRROVERLAYINDICATOR_ID = 0x1095F16F,
+        VRRREQUESTSTATE_ID = 0x1094F1F7,
+        VSYNCSMOOTHAFR_ID = 0x101AE763,
+        VSYNCVRRCONTROL_ID = 0x10A879CE,
+        VSYNC_BEHAVIOR_FLAGS_ID = 0x10FDEC23,
+        WKS_API_STEREO_EYES_EXCHANGE_ID = 0x11AE435C,
+        WKS_API_STEREO_MODE_ID = 0x11E91A61,
+        WKS_MEMORY_ALLOCATION_POLICY_ID = 0x11112233,
+        WKS_STEREO_DONGLE_SUPPORT_ID = 0x112493BD,
+        WKS_STEREO_SUPPORT_ID = 0x11AA9E99,
+        WKS_STEREO_SWAP_MODE_ID = 0x11333333,
+        AO_MODE_ID = 0x00667329,
+        AO_MODE_ACTIVE_ID = 0x00664339,
+        AUTO_LODBIASADJUST_ID = 0x00638E8F,
+        ICAFE_LOGO_CONFIG_ID = 0x00DB1337,
+        LODBIASADJUST_ID = 0x00738E8F,
+        PRERENDERLIMIT_ID = 0x007BA09E,
+        PS_DYNAMIC_TILING_ID = 0x00E5C6C0,
+        PS_SHADERDISKCACHE_ID = 0x00198FFF,
+        PS_TEXFILTER_ANISO_OPTS2_ID = 0x00E73211,
+        PS_TEXFILTER_BILINEAR_IN_ANISO_ID = 0x0084CD70,
+        PS_TEXFILTER_DISABLE_TRILIN_SLOPE_ID = 0x002ECAF2,
+        PS_TEXFILTER_NO_NEG_LODBIAS_ID = 0x0019BB68,
+        QUALITY_ENHANCEMENTS_ID = 0x00CE2691,
+        REFRESH_RATE_OVERRIDE_ID = 0x0064B541,
+        SET_POWER_THROTTLE_FOR_PCIe_COMPLIANCE_ID = 0x00AE785C,
+        SET_VAB_DATA_ID = 0x00AB8687,
+        VSYNCMODE_ID = 0x00A879CF,
+        VSYNCTEARCONTROL_ID = 0x005A375C,
+        TOTAL_DWORD_SETTING_NUM = 80,
+        TOTAL_WSTRING_SETTING_NUM = 4,
+        TOTAL_SETTING_NUM = 84,
+        INVALID_SETTING_ID = 0xFFFFFFFF
+    }
+
+    internal enum NvShimSetting : uint
+    {
+        SHIM_RENDERING_MODE_INTEGRATED = 0x00000000,
+        SHIM_RENDERING_MODE_ENABLE = 0x00000001,
+        SHIM_RENDERING_MODE_USER_EDITABLE = 0x00000002,
+        SHIM_RENDERING_MODE_MASK = 0x00000003,
+        SHIM_RENDERING_MODE_VIDEO_MASK = 0x00000004,
+        SHIM_RENDERING_MODE_VARYING_BIT = 0x00000008,
+        SHIM_RENDERING_MODE_AUTO_SELECT = 0x00000010,
+        SHIM_RENDERING_MODE_OVERRIDE_BIT = 0x80000000,
+        SHIM_RENDERING_MODE_NUM_VALUES = 8,
+        SHIM_RENDERING_MODE_DEFAULT = SHIM_RENDERING_MODE_AUTO_SELECT
+    }
+
+    internal enum NvThreadControlSetting : uint
+    {
+        OGL_THREAD_CONTROL_ENABLE = 0x00000001,
+        OGL_THREAD_CONTROL_DISABLE = 0x00000002,
+        OGL_THREAD_CONTROL_NUM_VALUES = 2,
+        OGL_THREAD_CONTROL_DEFAULT = 0
+    }
+}
@@ -30,6 +30,11 @@ namespace osu.Desktop
        [STAThread]
        public static void Main(string[] args)
        {
+            // NVIDIA profiles are based on the executable name of a process.
+            // Lazer and stable share the same executable name.
+            // Stable sets this setting to "Off", which may not be what we want, so let's force it back to the default "Auto" on startup.
+            NVAPI.ThreadedOptimisations = NvThreadControlSetting.OGL_THREAD_CONTROL_DEFAULT;
+
            // run Squirrel first, as the app may exit after these run
            if (OperatingSystem.IsWindows())
            {
@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                Mod = new CatchModHidden(),
                PassCondition = () => Player.Results.Count > 0
                                      && Player.ChildrenOfType<DrawableJuiceStream>().Single().Alpha > 0
-                                      && Player.ChildrenOfType<DrawableFruit>().Last().Alpha > 0
+                                      && Player.ChildrenOfType<DrawableFruit>().First().Alpha > 0
            });
        }

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
            RelativeSizeAxes = Axes.X;
            Origin = Anchor.BottomLeft;

-            AddInternal(bananaContainer = new Container { RelativeSizeAxes = Axes.Both });
+            AddInternal(bananaContainer = new NestedFruitContainer { RelativeSizeAxes = Axes.Both });
        }

        protected override void AddNestedHitObject(DrawableHitObject hitObject)
@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
            RelativeSizeAxes = Axes.X;
            Origin = Anchor.BottomLeft;

-            AddInternal(dropletContainer = new Container { RelativeSizeAxes = Axes.Both, });
+            AddInternal(dropletContainer = new NestedFruitContainer { RelativeSizeAxes = Axes.Both, });
        }

        protected override void AddNestedHitObject(DrawableHitObject hitObject)
@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Catch.Objects.Drawables
+{
+    public partial class NestedFruitContainer : Container
+    {
+        /// <remarks>
+        /// This comparison logic is a copy of <see cref="HitObjectContainer"/> comparison logic,
+        /// which can't be easily extracted to a more common place.
+        /// </remarks>
+        /// <seealso cref="HitObjectContainer.Compare"/>
+        protected override int Compare(Drawable x, Drawable y)
+        {
+            if (x is not DrawableCatchHitObject xObj || y is not DrawableCatchHitObject yObj)
+                return base.Compare(x, y);
+
+            int result = yObj.HitObject.StartTime.CompareTo(xObj.HitObject.StartTime);
+            return result == 0 ? CompareReverseChildID(x, y) : result;
+        }
+    }
+}
@@ -19,6 +19,8 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
 {
    public partial class ArgonJudgementPiece : JudgementPiece, IAnimatableJudgement
    {
+        private const float judgement_y_position = 160;
+
        private RingExplosion? ringExplosion;

        [Resolved]
@@ -30,7 +32,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
            AutoSizeAxes = Axes.Both;

            Origin = Anchor.Centre;
-            Y = 160;
+            Y = judgement_y_position;
        }

        [BackgroundDependencyLoader]
@@ -76,7 +78,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Argon
                    this.ScaleTo(1.6f);
                    this.ScaleTo(1, 100, Easing.In);

-                    this.MoveTo(Vector2.Zero);
+                    this.MoveToY(judgement_y_position);
                    this.MoveToOffset(new Vector2(0, 100), 800, Easing.InQuint);

                    this.RotateTo(0);
@@ -51,7 +51,7 @@ namespace osu.Game.Rulesets.Osu.Tests

            assertHeadJudgement(HitResult.Meh);
            assertTickJudgement(HitResult.LargeTickHit);
-            assertTailJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.SliderTailHit);
            assertSliderJudgement(HitResult.IgnoreHit);
        }

@@ -467,13 +467,13 @@ namespace osu.Game.Rulesets.Osu.Tests

        private void assertHeadMissTailTracked()
        {
-            AddAssert("Tracking retained", () => judgementResults[^2].Type, () => Is.EqualTo(HitResult.LargeTickHit));
+            AddAssert("Tracking retained", () => judgementResults[^2].Type, () => Is.EqualTo(HitResult.SliderTailHit));
            AddAssert("Slider head missed", () => judgementResults.First().IsHit, () => Is.False);
        }

        private void assertMidSliderJudgements()
        {
-            AddAssert("Tracking acquired", () => judgementResults[^2].Type, () => Is.EqualTo(HitResult.LargeTickHit));
+            AddAssert("Tracking acquired", () => judgementResults[^2].Type, () => Is.EqualTo(HitResult.SliderTailHit));
        }

        private void assertMidSliderJudgementFail()
@@ -57,7 +57,7 @@ namespace osu.Game.Rulesets.Osu.Tests
            });

            assertHeadJudgement(HitResult.Ok);
-            assertTailJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.SliderTailHit);
            assertSliderJudgement(HitResult.IgnoreHit);
        }

@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Tests
            assertTickJudgement(1, HitResult.LargeTickHit);
            assertTickJudgement(2, HitResult.LargeTickHit);
            assertTickJudgement(3, HitResult.LargeTickHit);
-            assertTailJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.SliderTailHit);
            assertSliderJudgement(HitResult.IgnoreHit);
        }

@@ -182,7 +182,7 @@ namespace osu.Game.Rulesets.Osu.Tests
            assertHeadJudgement(HitResult.Meh);
            assertAllTickJudgements(HitResult.LargeTickHit);
            assertRepeatJudgement(HitResult.LargeTickHit);
-            assertTailJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.SliderTailHit);
            assertSliderJudgement(HitResult.IgnoreHit);
        }

@@ -210,7 +210,7 @@ namespace osu.Game.Rulesets.Osu.Tests

            assertHeadJudgement(HitResult.Meh);
            assertRepeatJudgement(HitResult.LargeTickHit);
-            assertTailJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.SliderTailHit);
            assertSliderJudgement(HitResult.IgnoreHit);
        }

@@ -245,7 +245,7 @@ namespace osu.Game.Rulesets.Osu.Tests
            assertAllTickJudgements(HitResult.LargeTickMiss);

            // This particular test actually starts tracking the slider just before the end, so the tail should be hit because of its leniency.
-            assertTailJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.SliderTailHit);

            assertSliderJudgement(HitResult.IgnoreHit);
        }
@@ -276,7 +276,7 @@ namespace osu.Game.Rulesets.Osu.Tests

            assertHeadJudgement(HitResult.Meh);
            assertTickJudgement(0, HitResult.LargeTickMiss);
-            assertTailJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.SliderTailHit);
            assertSliderJudgement(HitResult.IgnoreHit);
        }

@@ -307,7 +307,7 @@ namespace osu.Game.Rulesets.Osu.Tests
            assertHeadJudgement(HitResult.Meh);
            assertTickJudgement(0, HitResult.LargeTickMiss);
            assertTickJudgement(1, HitResult.LargeTickMiss);
-            assertTailJudgement(HitResult.LargeTickHit);
+            assertTailJudgement(HitResult.SliderTailHit);
            assertSliderJudgement(HitResult.IgnoreHit);
        }

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Osu.Objects

        public class TailJudgement : SliderEndJudgement
        {
-            public override HitResult MaxResult => HitResult.LargeTickHit;
+            public override HitResult MaxResult => HitResult.SliderTailHit;
            public override HitResult MinResult => HitResult.IgnoreMiss;
        }
    }
@@ -277,6 +277,7 @@ namespace osu.Game.Rulesets.Osu

                HitResult.LargeTickHit,
                HitResult.SmallTickHit,
+                HitResult.SliderTailHit,
                HitResult.SmallBonus,
                HitResult.LargeBonus,
            };
@@ -289,6 +290,7 @@ namespace osu.Game.Rulesets.Osu
                case HitResult.LargeTickHit:
                    return "slider tick";

+                case HitResult.SliderTailHit:
                case HitResult.SmallTickHit:
                    return "slider end";

@@ -91,6 +91,7 @@ namespace osu.Game.Rulesets.Osu.Scoring
                    // When classic slider mechanics are enabled, this result comes from the tail.
                    return 0.02;

+                case HitResult.SliderTailHit:
                case HitResult.LargeTickHit:
                    switch (result.HitObject)
                    {
@@ -57,6 +57,7 @@ namespace osu.Game.Rulesets.Osu.Scoring
                    increase = 0.02;
                    break;

+                case HitResult.SliderTailHit:
                case HitResult.LargeTickHit:
                    // This result comes from either a slider tick or repeat.
                    increase = hitObject is SliderTick ? 0.015 : 0.02;
@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Argon
                    RelativeSizeAxes = Axes.Both,
                    InnerRadius = arc_radius,
                    RoundedCaps = true,
-                    GlowColour = new Color4(171, 255, 255, 255)
+                    GlowColour = new Color4(171, 255, 255, 180)
                }
            };
        }
@@ -112,7 +112,7 @@ namespace osu.Game.Tests.Chat
            });

            AddStep("post message", () => channelManager.PostMessage("Something interesting"));
-            AddUntilStep("message postesd", () => !channel.Messages.Any(m => m is LocalMessage));
+            AddUntilStep("message posted", () => !channel.Messages.Any(m => m is LocalMessage));

            AddStep("post /help command", () => channelManager.PostCommand("help", channel));
            AddStep("post /me command with no action", () => channelManager.PostCommand("me", channel));
@@ -146,6 +146,23 @@ namespace osu.Game.Tests.Chat
            AddAssert("channel has no more messages", () => channel.Messages, () => Is.Empty);
        }

+        [Test]
+        public void TestCommandNameCaseInsensitivity()
+        {
+            Channel channel = null;
+
+            AddStep("join channel and select it", () =>
+            {
+                channelManager.JoinChannel(channel = createChannel(1, ChannelType.Public));
+                channelManager.CurrentChannel.Value = channel;
+            });
+
+            AddStep("post /me command", () => channelManager.PostCommand("ME DANCES"));
+            AddUntilStep("/me command received", () => channel.Messages.Last().Content.Contains("DANCES"));
+            AddStep("post /help command", () => channelManager.PostCommand("HeLp"));
+            AddUntilStep("/help command received", () => channel.Messages.Last().Content.Contains("Supported commands"));
+        }
+
        private void handlePostMessageRequest(PostMessageRequest request)
        {
            var message = new Message(++currentMessageId)
@@ -310,6 +310,26 @@ namespace osu.Game.Tests.Mods
                Assert.That(invalid?.Select(t => t.GetType()), Is.EquivalentTo(expectedInvalid));
        }

+        [Test]
+        public void TestFormatScoreMultiplier()
+        {
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.9999).ToString(), "0.99x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.0).ToString(), "1.00x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.0001).ToString(), "1.01x");
+
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.899999999999999).ToString(), "0.90x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.9).ToString(), "0.90x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.900000000000001).ToString(), "0.90x");
+
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.099999999999999).ToString(), "1.10x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.1).ToString(), "1.10x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.100000000000001).ToString(), "1.10x");
+
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.045).ToString(), "1.05x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.05).ToString(), "1.05x");
+            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.055).ToString(), "1.06x");
+        }
+
        public abstract class CustomMod1 : Mod, IModCompatibilitySpecification
        {
        }
@@ -339,6 +359,16 @@ namespace osu.Game.Tests.Mods
            public override bool ValidForMultiplayerAsFreeMod => false;
        }

+        public class EditableMod : Mod
+        {
+            public override string Name => string.Empty;
+            public override LocalisableString Description => string.Empty;
+            public override string Acronym => string.Empty;
+            public override double ScoreMultiplier => Multiplier;
+
+            public double Multiplier = 1;
+        }
+
        public interface IModCompatibilitySpecification
        {
        }
@@ -84,6 +84,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
        [TestCase(ScoringMode.Standardised, HitResult.SmallTickHit, HitResult.SmallTickHit, 493_652)]
        [TestCase(ScoringMode.Standardised, HitResult.LargeTickMiss, HitResult.LargeTickHit, 0)]
        [TestCase(ScoringMode.Standardised, HitResult.LargeTickHit, HitResult.LargeTickHit, 326_963)]
+        [TestCase(ScoringMode.Standardised, HitResult.SliderTailHit, HitResult.SliderTailHit, 326_963)]
        [TestCase(ScoringMode.Standardised, HitResult.SmallBonus, HitResult.SmallBonus, 1_000_030)]
        [TestCase(ScoringMode.Standardised, HitResult.LargeBonus, HitResult.LargeBonus, 1_000_150)]
        [TestCase(ScoringMode.Classic, HitResult.Miss, HitResult.Great, 0)]
@@ -96,6 +97,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
        [TestCase(ScoringMode.Classic, HitResult.SmallTickHit, HitResult.SmallTickHit, 49_365)]
        [TestCase(ScoringMode.Classic, HitResult.LargeTickMiss, HitResult.LargeTickHit, 0)]
        [TestCase(ScoringMode.Classic, HitResult.LargeTickHit, HitResult.LargeTickHit, 32_696)]
+        [TestCase(ScoringMode.Classic, HitResult.SliderTailHit, HitResult.SliderTailHit, 32_696)]
        [TestCase(ScoringMode.Classic, HitResult.SmallBonus, HitResult.SmallBonus, 100_003)]
        [TestCase(ScoringMode.Classic, HitResult.LargeBonus, HitResult.LargeBonus, 100_015)]
        public void TestFourVariousResultsOneMiss(ScoringMode scoringMode, HitResult hitResult, HitResult maxResult, int expectedScore)
@@ -167,6 +169,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
        [TestCase(HitResult.Perfect, HitResult.Miss)]
        [TestCase(HitResult.SmallTickHit, HitResult.SmallTickMiss)]
        [TestCase(HitResult.LargeTickHit, HitResult.LargeTickMiss)]
+        [TestCase(HitResult.SliderTailHit, HitResult.LargeTickMiss)]
        [TestCase(HitResult.SmallBonus, HitResult.IgnoreMiss)]
        [TestCase(HitResult.LargeBonus, HitResult.IgnoreMiss)]
        public void TestMinResults(HitResult hitResult, HitResult expectedMinResult)
@@ -187,6 +190,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
        [TestCase(HitResult.SmallTickHit, false)]
        [TestCase(HitResult.LargeTickMiss, true)]
        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SliderTailHit, true)]
        [TestCase(HitResult.SmallBonus, false)]
        [TestCase(HitResult.LargeBonus, false)]
        public void TestAffectsCombo(HitResult hitResult, bool expectedReturnValue)
@@ -207,6 +211,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
        [TestCase(HitResult.SmallTickHit, true)]
        [TestCase(HitResult.LargeTickMiss, true)]
        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SliderTailHit, true)]
        [TestCase(HitResult.SmallBonus, false)]
        [TestCase(HitResult.LargeBonus, false)]
        public void TestAffectsAccuracy(HitResult hitResult, bool expectedReturnValue)
@@ -227,6 +232,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
        [TestCase(HitResult.SmallTickHit, false)]
        [TestCase(HitResult.LargeTickMiss, false)]
        [TestCase(HitResult.LargeTickHit, false)]
+        [TestCase(HitResult.SliderTailHit, false)]
        [TestCase(HitResult.SmallBonus, true)]
        [TestCase(HitResult.LargeBonus, true)]
        public void TestIsBonus(HitResult hitResult, bool expectedReturnValue)
@@ -247,6 +253,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
        [TestCase(HitResult.SmallTickHit, true)]
        [TestCase(HitResult.LargeTickMiss, false)]
        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SliderTailHit, true)]
        [TestCase(HitResult.SmallBonus, true)]
        [TestCase(HitResult.LargeBonus, true)]
        public void TestIsHit(HitResult hitResult, bool expectedReturnValue)
@@ -267,6 +274,7 @@ namespace osu.Game.Tests.Rulesets.Scoring
        [TestCase(HitResult.SmallTickHit, true)]
        [TestCase(HitResult.LargeTickMiss, true)]
        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SliderTailHit, true)]
        [TestCase(HitResult.SmallBonus, true)]
        [TestCase(HitResult.LargeBonus, true)]
        public void TestIsScorable(HitResult hitResult, bool expectedReturnValue)
@@ -104,7 +104,7 @@ namespace osu.Game.Tests.Visual.Editing
            if (sameRuleset)
            {
                AddUntilStep("prompt for save dialog shown", () => DialogOverlay.CurrentDialog is PromptForSaveDialog);
-                AddStep("discard changes", () => ((PromptForSaveDialog)DialogOverlay.CurrentDialog).PerformOkAction());
+                AddStep("discard changes", () => ((PromptForSaveDialog)DialogOverlay.CurrentDialog)?.PerformOkAction());
            }

            // ensure editor loader didn't resume.
@@ -25,6 +25,7 @@ using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Taiko;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Storyboards;
 using osu.Game.Tests.Resources;
@@ -94,8 +95,11 @@ namespace osu.Game.Tests.Visual.Editing
        [Test]
        public void TestAddAudioTrack()
        {
-            AddAssert("track is virtual", () => Beatmap.Value.Track is TrackVirtual);
+            AddStep("enter compose mode", () => InputManager.Key(Key.F1));
+            AddUntilStep("wait for timeline load", () => Editor.ChildrenOfType<Timeline>().FirstOrDefault()?.IsLoaded == true);

+            AddStep("enter setup mode", () => InputManager.Key(Key.F4));
+            AddAssert("track is virtual", () => Beatmap.Value.Track is TrackVirtual);
            AddAssert("switch track to real track", () =>
            {
                var setup = Editor.ChildrenOfType<SetupScreen>().First();
@@ -12,6 +12,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play.PlayerSettings;
+using osu.Game.Tests.Resources;
 using osu.Game.Tests.Visual.Ranking;

 namespace osu.Game.Tests.Visual.Gameplay
@@ -44,7 +45,23 @@ namespace osu.Game.Tests.Visual.Gameplay
            {
                offsetControl.ReferenceScore.Value = new ScoreInfo
                {
-                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(0, 2)
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(0, 2),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
+                };
+            });
+
+            AddAssert("No calibration button", () => !offsetControl.ChildrenOfType<SettingsButton>().Any());
+        }
+
+        [Test]
+        public void TestScoreFromDifferentBeatmap()
+        {
+            AddStep("Set short reference score", () =>
+            {
+                offsetControl.ReferenceScore.Value = new ScoreInfo
+                {
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(10),
+                    BeatmapInfo = TestResources.CreateTestBeatmapSetInfo().Beatmaps.First(),
                };
            });

@@ -59,7 +76,8 @@ namespace osu.Game.Tests.Visual.Gameplay
                offsetControl.ReferenceScore.Value = new ScoreInfo
                {
                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(10),
-                    Mods = new Mod[] { new OsuModRelax() }
+                    Mods = new Mod[] { new OsuModRelax() },
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
                };
            });

@@ -77,7 +95,8 @@ namespace osu.Game.Tests.Visual.Gameplay
            {
                offsetControl.ReferenceScore.Value = new ScoreInfo
                {
-                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error)
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
                };
            });

@@ -105,7 +124,8 @@ namespace osu.Game.Tests.Visual.Gameplay
            {
                offsetControl.ReferenceScore.Value = new ScoreInfo
                {
-                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error)
+                    HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(average_error),
+                    BeatmapInfo = Beatmap.Value.BeatmapInfo,
                };
            });

@@ -21,6 +21,7 @@ using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko;
 using osu.Game.Scoring;
+using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
 using osu.Game.Tests.Beatmaps;

@@ -359,6 +360,11 @@ namespace osu.Game.Tests.Visual.Gameplay
                AllowImportCompletion = new SemaphoreSlim(1);
            }

+            protected override GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart) => new MasterGameplayClockContainer(beatmap, gameplayStart)
+            {
+                ShouldValidatePlaybackRate = false,
+            };
+
            protected override async Task ImportScore(Score score)
            {
                ScoreImportStarted = true;
@@ -3,28 +3,40 @@

 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Screens.Menu;
+using osuTK.Input;

 namespace osu.Game.Tests.Visual.Menus
 {
    public partial class TestSceneMainMenu : OsuGameTestScene
    {
+        private SystemTitle systemTitle => Game.ChildrenOfType<SystemTitle>().Single();
+
        [Test]
        public void TestSystemTitle()
        {
-            AddStep("set system title", () => Game.ChildrenOfType<SystemTitle>().Single().Current.Value = new APISystemTitle
+            AddStep("set system title", () => systemTitle.Current.Value = new APISystemTitle
            {
                Image = @"https://assets.ppy.sh/main-menu/project-loved-2@2x.png",
                Url = @"https://osu.ppy.sh/home/news/2023-12-21-project-loved-december-2023",
            });
-            AddStep("set another title", () => Game.ChildrenOfType<SystemTitle>().Single().Current.Value = new APISystemTitle
+            AddAssert("system title not visible", () => systemTitle.State.Value, () => Is.EqualTo(Visibility.Hidden));
+            AddStep("enter menu", () => InputManager.Key(Key.Enter));
+            AddUntilStep("system title visible", () => systemTitle.State.Value, () => Is.EqualTo(Visibility.Visible));
+            AddStep("set another title", () => systemTitle.Current.Value = new APISystemTitle
            {
                Image = @"https://assets.ppy.sh/main-menu/wf2023-vote@2x.png",
                Url = @"https://osu.ppy.sh/community/contests/189",
            });
-            AddStep("unset system title", () => Game.ChildrenOfType<SystemTitle>().Single().Current.Value = null);
+            AddStep("set title with nonexistent image", () => systemTitle.Current.Value = new APISystemTitle
+            {
+                Image = @"https://test.invalid/@2x", // .invalid TLD reserved by https://datatracker.ietf.org/doc/html/rfc2606#section-2
+                Url = @"https://osu.ppy.sh/community/contests/189",
+            });
+            AddStep("unset system title", () => systemTitle.Current.Value = null);
        }
    }
 }
@@ -29,6 +29,7 @@ using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Scoring;
 using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.OnlinePlay.Lounge;
 using osu.Game.Screens.OnlinePlay.Lounge.Components;
@@ -690,6 +691,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
            }

            AddUntilStep("wait for results", () => multiplayerComponents.CurrentScreen is ResultsScreen);
+
+            AddAssert("check is fail", () =>
+            {
+                var scoreInfo = ((ResultsScreen)multiplayerComponents.CurrentScreen).Score;
+
+                return !scoreInfo.Passed && scoreInfo.Rank == ScoreRank.F;
+            });
        }

        [Test]
@@ -799,11 +799,7 @@ namespace osu.Game.Tests.Visual.Navigation
                });
            });

-            AddStep("attempt exit", () =>
-            {
-                for (int i = 0; i < 2; ++i)
-                    Game.ScreenStack.CurrentScreen.Exit();
-            });
+            AddRepeatStep("attempt force exit", () => Game.ScreenStack.CurrentScreen.Exit(), 2);
            AddUntilStep("stopped at exit confirm", () => Game.ChildrenOfType<DialogOverlay>().Single().CurrentDialog is ConfirmExitDialog);
        }

@@ -368,7 +368,7 @@ namespace osu.Game.Tests.Visual.Online
            {
                var cardContainer = this.ChildrenOfType<ReverseChildIDFillFlowContainer<BeatmapCard>>().Single().Parent;
                var expandedContent = this.ChildrenOfType<ExpandedContentScrollContainer>().Single();
-                return expandedContent.ScreenSpaceDrawQuad.GetVertices().ToArray().All(v => cardContainer.ScreenSpaceDrawQuad.Contains(v));
+                return expandedContent.ScreenSpaceDrawQuad.GetVertices().ToArray().All(v => cardContainer!.ScreenSpaceDrawQuad.Contains(v));
            });
        }

@@ -275,7 +275,7 @@ Phasellus eu nunc nec ligula semper fringilla. Aliquam magna neque, placerat sed
            AddStep("set content", () =>
            {
                markdownContainer.Text = @"
-This is a paragraph containing `inline code` synatax.
+This is a paragraph containing `inline code` syntax.
 Oh wow I do love the `WikiMarkdownContainer`, it is very cool!

 This is a line before the fenced code block:
@@ -0,0 +1,131 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Utils;
+using osu.Game.Configuration;
+using osu.Game.Overlays.Settings.Sections.Audio;
+using osu.Game.Scoring;
+using osu.Game.Tests.Visual.Ranking;
+
+namespace osu.Game.Tests.Visual.Settings
+{
+    public partial class TestSceneAudioOffsetAdjustControl : OsuTestScene
+    {
+        [Resolved]
+        private SessionStatics statics { get; set; } = null!;
+
+        [Cached]
+        private SessionAverageHitErrorTracker tracker = new SessionAverageHitErrorTracker();
+
+        private Container content = null!;
+        protected override Container Content => content;
+
+        private OsuConfigManager localConfig = null!;
+        private AudioOffsetAdjustControl adjustControl = null!;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            localConfig = new OsuConfigManager(LocalStorage);
+            Dependencies.CacheAs(localConfig);
+
+            base.Content.AddRange(new Drawable[]
+            {
+                tracker,
+                content = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Width = 400,
+                    AutoSizeAxes = Axes.Y
+                }
+            });
+        }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            Child = adjustControl = new AudioOffsetAdjustControl
+            {
+                Current = localConfig.GetBindable<double>(OsuSetting.AudioOffset),
+            };
+
+            localConfig.SetValue(OsuSetting.AudioOffset, 0.0);
+            tracker.ClearHistory();
+        });
+
+        [Test]
+        public void TestDisplay()
+        {
+            AddStep("set new score", () => statics.SetValue(Static.LastLocalUserScore, new ScoreInfo
+            {
+                HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(RNG.NextDouble(-100, 100)),
+                BeatmapInfo = Beatmap.Value.BeatmapInfo,
+            }));
+            AddStep("clear history", () => tracker.ClearHistory());
+        }
+
+        [Test]
+        public void TestBehaviour()
+        {
+            AddStep("set score with -20ms", () => setScore(-20));
+            AddAssert("suggested global offset is 20ms", () => adjustControl.SuggestedOffset.Value, () => Is.EqualTo(20));
+            AddStep("clear history", () => tracker.ClearHistory());
+
+            AddStep("set score with 40ms", () => setScore(40));
+            AddAssert("suggested global offset is -40ms", () => adjustControl.SuggestedOffset.Value, () => Is.EqualTo(-40));
+            AddStep("clear history", () => tracker.ClearHistory());
+        }
+
+        [Test]
+        public void TestNonZeroGlobalOffset()
+        {
+            AddStep("set global offset to -20ms", () => localConfig.SetValue(OsuSetting.AudioOffset, -20.0));
+            AddStep("set score with -20ms", () => setScore(-20));
+            AddAssert("suggested global offset is 0ms", () => adjustControl.SuggestedOffset.Value, () => Is.EqualTo(0));
+            AddStep("clear history", () => tracker.ClearHistory());
+
+            AddStep("set global offset to 20ms", () => localConfig.SetValue(OsuSetting.AudioOffset, 20.0));
+            AddStep("set score with 40ms", () => setScore(40));
+            AddAssert("suggested global offset is -20ms", () => adjustControl.SuggestedOffset.Value, () => Is.EqualTo(-20));
+            AddStep("clear history", () => tracker.ClearHistory());
+        }
+
+        [Test]
+        public void TestMultiplePlays()
+        {
+            AddStep("set score with -20ms", () => setScore(-20));
+            AddStep("set score with -10ms", () => setScore(-10));
+            AddAssert("suggested global offset is 15ms", () => adjustControl.SuggestedOffset.Value, () => Is.EqualTo(15));
+            AddStep("clear history", () => tracker.ClearHistory());
+
+            AddStep("set score with -20ms", () => setScore(-20));
+            AddStep("set global offset to 30ms", () => localConfig.SetValue(OsuSetting.AudioOffset, 30.0));
+            AddStep("set score with 10ms", () => setScore(10));
+            AddAssert("suggested global offset is 20ms", () => adjustControl.SuggestedOffset.Value, () => Is.EqualTo(20));
+            AddStep("clear history", () => tracker.ClearHistory());
+        }
+
+        private void setScore(double averageHitError)
+        {
+            statics.SetValue(Static.LastLocalUserScore, new ScoreInfo
+            {
+                HitEvents = TestSceneHitEventTimingDistributionGraph.CreateDistributedHitEvents(averageHitError),
+                BeatmapInfo = Beatmap.Value.BeatmapInfo,
+            });
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (localConfig.IsNotNull())
+                localConfig.Dispose();
+
+            base.Dispose(isDisposing);
+        }
+    }
+}
@@ -9,6 +9,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Dialog;

@@ -19,11 +20,15 @@ namespace osu.Game.Tests.Visual.UserInterface
    {
        private DialogOverlay overlay;

+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create dialog overlay", () => Child = overlay = new DialogOverlay());
+        }
+
        [Test]
        public void TestBasic()
        {
-            AddStep("create dialog overlay", () => Child = overlay = new DialogOverlay());
-
            TestPopupDialog firstDialog = null;
            TestPopupDialog secondDialog = null;

@@ -84,7 +89,31 @@ namespace osu.Game.Tests.Visual.UserInterface
            }));

            AddAssert("second dialog displayed", () => overlay.CurrentDialog == secondDialog);
-            AddAssert("first dialog is not part of hierarchy", () => firstDialog.Parent == null);
+            AddUntilStep("first dialog is not part of hierarchy", () => firstDialog.Parent == null);
+        }
+
+        [Test]
+        public void TestTooMuchText()
+        {
+            AddStep("dialog #1", () => overlay.Push(new TestPopupDialog
+            {
+                Icon = FontAwesome.Regular.TrashAlt,
+                HeaderText = @"Confirm deletion ofConfirm deletion ofConfirm deletion ofConfirm deletion ofConfirm deletion ofConfirm deletion of",
+                BodyText = @"Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver.Ayase Rie - Yuima-ru*World TVver. ",
+                Buttons = new PopupDialogButton[]
+                {
+                    new PopupDialogOkButton
+                    {
+                        Text = @"I never want to see this again.",
+                        Action = () => Console.WriteLine(@"OK"),
+                    },
+                    new PopupDialogCancelButton
+                    {
+                        Text = @"Firetruck, I still want quick ranks!",
+                        Action = () => Console.WriteLine(@"Cancel"),
+                    },
+                },
+            }));
        }

        [Test]
@@ -92,7 +121,7 @@ namespace osu.Game.Tests.Visual.UserInterface
        {
            PopupDialog dialog = null;

-            AddStep("create dialog overlay", () => overlay = new SlowLoadingDialogOverlay());
+            AddStep("create slow loading dialog overlay", () => overlay = new SlowLoadingDialogOverlay());

            AddStep("start loading overlay", () => LoadComponentAsync(overlay, Add));

@@ -128,8 +157,6 @@ namespace osu.Game.Tests.Visual.UserInterface
        [Test]
        public void TestDismissBeforePush()
        {
-            AddStep("create dialog overlay", () => Child = overlay = new DialogOverlay());
-
            TestPopupDialog testDialog = null;
            AddStep("dismissed dialog push", () =>
            {
@@ -146,8 +173,6 @@ namespace osu.Game.Tests.Visual.UserInterface
        [Test]
        public void TestDismissBeforePushViaButtonPress()
        {
-            AddStep("create dialog overlay", () => Child = overlay = new DialogOverlay());
-
            TestPopupDialog testDialog = null;
            AddStep("dismissed dialog push", () =>
            {
@@ -163,7 +188,7 @@ namespace osu.Game.Tests.Visual.UserInterface
            });

            AddAssert("no dialog pushed", () => overlay.CurrentDialog == null);
-            AddAssert("dialog is not part of hierarchy", () => testDialog.Parent == null);
+            AddUntilStep("dialog is not part of hierarchy", () => testDialog.Parent == null);
        }

        private partial class TestPopupDialog : PopupDialog
@@ -9,6 +9,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Select;
+using osu.Game.Utils;

 namespace osu.Game.Tests.Visual.UserInterface
 {
@@ -74,7 +75,7 @@ namespace osu.Game.Tests.Visual.UserInterface
        private bool assertModsMultiplier(IEnumerable<Mod> mods)
        {
            double multiplier = mods.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier);
-            string expectedValue = multiplier.Equals(1.0) ? string.Empty : $"{multiplier:N2}x";
+            string expectedValue = multiplier == 1 ? string.Empty : ModUtils.FormatScoreMultiplier(multiplier).ToString();

            return expectedValue == footerButtonMods.MultiplierText.Current.Value;
        }
@@ -1,10 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

-#nullable disable
-
 using NUnit.Framework;
-using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Game.Overlays.Dialog;
@@ -15,24 +12,25 @@ namespace osu.Game.Tests.Visual.UserInterface
 {
    public partial class TestScenePopupDialog : OsuManualInputManagerTestScene
    {
-        private TestPopupDialog dialog;
+        private TestPopupDialog dialog = null!;

        [SetUpSteps]
        public void SetUpSteps()
        {
            AddStep("new popup", () =>
            {
-                Add(dialog = new TestPopupDialog
+                Child = dialog = new TestPopupDialog
                {
-                    RelativeSizeAxes = Axes.Both,
                    State = { Value = Framework.Graphics.Containers.Visibility.Visible },
-                });
+                };
            });
        }

        [Test]
        public void TestDangerousButton([Values(false, true)] bool atEdge)
        {
+            AddStep("finish transforms", () => dialog.FinishTransforms(true));
+
            if (atEdge)
            {
                AddStep("move mouse to button edge", () =>
@@ -20,6 +20,7 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Skinning;
+using osu.Game.Users;

 namespace osu.Game.Configuration
 {
@@ -193,6 +194,7 @@ namespace osu.Game.Configuration
            SetDefault(OsuSetting.LastProcessedMetadataId, -1);

            SetDefault(OsuSetting.ComboColourNormalisationAmount, 0.2f, 0f, 1f, 0.01f);
+            SetDefault<UserStatus?>(OsuSetting.UserOnlineStatus, null);
        }

        protected override bool CheckLookupContainsPrivateInformation(OsuSetting lookup)
@@ -420,5 +422,6 @@ namespace osu.Game.Configuration
        EditorShowSpeedChanges,
        TouchDisableGameplayTaps,
        ModSelectTextSearchStartsActive,
+        UserOnlineStatus,
    }
 }
@@ -0,0 +1,73 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+
+namespace osu.Game.Configuration
+{
+    /// <summary>
+    /// Tracks the local user's average hit error during the ongoing play session.
+    /// </summary>
+    [Cached]
+    public partial class SessionAverageHitErrorTracker : Component
+    {
+        public IBindableList<DataPoint> AverageHitErrorHistory => averageHitErrorHistory;
+        private readonly BindableList<DataPoint> averageHitErrorHistory = new BindableList<DataPoint>();
+
+        private readonly Bindable<ScoreInfo?> latestScore = new Bindable<ScoreInfo?>();
+
+        [Resolved]
+        private OsuConfigManager configManager { get; set; } = null!;
+
+        [BackgroundDependencyLoader]
+        private void load(SessionStatics statics)
+        {
+            statics.BindWith(Static.LastLocalUserScore, latestScore);
+            latestScore.BindValueChanged(score => calculateAverageHitError(score.NewValue), true);
+        }
+
+        private void calculateAverageHitError(ScoreInfo? newScore)
+        {
+            if (newScore == null)
+                return;
+
+            if (newScore.Mods.Any(m => !m.UserPlayable || m is IHasNoTimedInputs))
+                return;
+
+            if (newScore.HitEvents.Count < 10)
+                return;
+
+            if (newScore.HitEvents.CalculateAverageHitError() is not double averageError)
+                return;
+
+            // keep a sane maximum number of entries.
+            if (averageHitErrorHistory.Count >= 50)
+                averageHitErrorHistory.RemoveAt(0);
+
+            double globalOffset = configManager.Get<double>(OsuSetting.AudioOffset);
+            averageHitErrorHistory.Add(new DataPoint(averageError, globalOffset));
+        }
+
+        public void ClearHistory() => averageHitErrorHistory.Clear();
+
+        public readonly struct DataPoint
+        {
+            public double AverageHitError { get; }
+            public double GlobalAudioOffset { get; }
+
+            public double SuggestedGlobalAudioOffset => GlobalAudioOffset - AverageHitError;
+
+            public DataPoint(double averageHitError, double globalOffset)
+            {
+                AverageHitError = averageHitError;
+                GlobalAudioOffset = globalOffset;
+            }
+        }
+    }
+}
@@ -9,6 +9,7 @@ using osu.Game.Input;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
+using osu.Game.Scoring;

 namespace osu.Game.Configuration
 {
@@ -27,6 +28,7 @@ namespace osu.Game.Configuration
            SetDefault(Static.LastModSelectPanelSamplePlaybackTime, (double?)null);
            SetDefault<APISeasonalBackgrounds>(Static.SeasonalBackgrounds, null);
            SetDefault(Static.TouchInputActive, RuntimeInfo.IsMobile);
+            SetDefault<ScoreInfo>(Static.LastLocalUserScore, null);
        }

        /// <summary>
@@ -73,5 +75,10 @@ namespace osu.Game.Configuration
        /// Used in touchscreen detection scenarios (<see cref="TouchInputInterceptor"/>).
        /// </summary>
        TouchInputActive,
+
+        /// <summary>
+        /// Stores the local user's last score (can be completed or aborted).
+        /// </summary>
+        LastLocalUserScore,
    }
 }
@@ -316,7 +316,7 @@ namespace osu.Game.Database
            // when playing a beatmap with no bonus objects, with mods that have a 0.0x multiplier on stable (relax/autopilot).
            // In such cases, just assume 0.
            double comboProportion = maximumLegacyComboScore + maximumLegacyBonusScore > 0
-                ? ((double)score.LegacyTotalScore - legacyAccScore) / (maximumLegacyComboScore + maximumLegacyBonusScore)
+                ? Math.Max((double)score.LegacyTotalScore - legacyAccScore, 0) / (maximumLegacyComboScore + maximumLegacyBonusScore)
                : 0;

            // We assume the bonus proportion only makes up the rest of the score that exceeds maximumLegacyBaseScore.
@@ -25,7 +25,7 @@ namespace osu.Game.Graphics.UserInterface
        private const float idle_width = 0.8f;
        private const float hover_width = 0.9f;

-        private const float hover_duration = 500;
+        private const float hover_duration = 300;
        private const float click_duration = 200;

        public event Action<SelectionState>? StateChanged;
@@ -54,7 +54,7 @@ namespace osu.Game.Graphics.UserInterface
        private readonly Box rightGlow;
        private readonly Box background;
        private readonly SpriteText spriteText;
-        private Vector2 hoverSpacing => new Vector2(3f, 0f);
+        private Vector2 hoverSpacing => new Vector2(1.4f, 0f);

        public DialogButton(HoverSampleSet sampleSet = HoverSampleSet.Button)
            : base(sampleSet)
@@ -279,15 +279,15 @@ namespace osu.Game.Graphics.UserInterface

            if (newState == SelectionState.Selected)
            {
-                spriteText.TransformSpacingTo(hoverSpacing, hover_duration, Easing.OutElastic);
-                ColourContainer.ResizeWidthTo(hover_width, hover_duration, Easing.OutElastic);
+                spriteText.TransformSpacingTo(hoverSpacing, hover_duration, Easing.OutQuint);
+                ColourContainer.ResizeWidthTo(hover_width, hover_duration, Easing.OutQuint);
                glowContainer.FadeIn(hover_duration, Easing.OutQuint);
            }
            else
            {
-                ColourContainer.ResizeWidthTo(idle_width, hover_duration, Easing.OutElastic);
-                spriteText.TransformSpacingTo(Vector2.Zero, hover_duration, Easing.OutElastic);
-                glowContainer.FadeOut(hover_duration, Easing.OutQuint);
+                ColourContainer.ResizeWidthTo(idle_width, hover_duration / 2, Easing.OutQuint);
+                spriteText.TransformSpacingTo(Vector2.Zero, hover_duration / 2, Easing.OutQuint);
+                glowContainer.FadeOut(hover_duration / 2, Easing.OutQuint);
            }
        }

@@ -363,6 +363,7 @@ namespace osu.Game.Graphics.UserInterface
                base.LoadComplete();

                SearchBar.State.ValueChanged += _ => updateColour();
+                Enabled.BindValueChanged(_ => updateColour());
                updateColour();
            }

@@ -383,6 +384,9 @@ namespace osu.Game.Graphics.UserInterface
                var hoveredColour = colourProvider?.Light4 ?? colours.PinkDarker;
                var unhoveredColour = colourProvider?.Background5 ?? Color4.Black.Opacity(0.5f);

+                Colour = Color4.White;
+                Alpha = Enabled.Value ? 1 : 0.3f;
+
                if (SearchBar.State.Value == Visibility.Visible)
                {
                    Icon.Colour = hovered ? hoveredColour.Lighten(0.5f) : Colour4.White;
@@ -62,6 +62,9 @@ namespace osu.Game.Online.API

        private Bindable<UserActivity> activity { get; } = new Bindable<UserActivity>();

+        private Bindable<UserStatus?> configStatus { get; } = new Bindable<UserStatus?>();
+        private Bindable<UserStatus?> localUserStatus { get; } = new Bindable<UserStatus?>();
+
        protected bool HasLogin => authentication.Token.Value != null || (!string.IsNullOrEmpty(ProvidedUsername) && !string.IsNullOrEmpty(password));

        private readonly CancellationTokenSource cancellationToken = new CancellationTokenSource();
@@ -85,12 +88,20 @@ namespace osu.Game.Online.API
            authentication.TokenString = config.Get<string>(OsuSetting.Token);
            authentication.Token.ValueChanged += onTokenChanged;

+            config.BindWith(OsuSetting.UserOnlineStatus, configStatus);
+
            localUser.BindValueChanged(u =>
            {
                u.OldValue?.Activity.UnbindFrom(activity);
                u.NewValue.Activity.BindTo(activity);
+
+                if (u.OldValue != null)
+                    localUserStatus.UnbindFrom(u.OldValue.Status);
+                localUserStatus.BindTo(u.NewValue.Status);
            }, true);

+            localUserStatus.BindValueChanged(val => configStatus.Value = val.NewValue);
+
            var thread = new Thread(run)
            {
                Name = "APIAccess",
@@ -200,6 +211,7 @@ namespace osu.Game.Online.API
                setLocalUser(new APIUser
                {
                    Username = ProvidedUsername,
+                    Status = { Value = configStatus.Value ?? UserStatus.Online }
                });
            }

@@ -246,8 +258,7 @@ namespace osu.Game.Online.API
            };
            userReq.Success += user =>
            {
-                // todo: save/pull from settings
-                user.Status.Value = UserStatus.Online;
+                user.Status.Value = configStatus.Value ?? UserStatus.Online;

                setLocalUser(user);

@@ -247,7 +247,7 @@ namespace osu.Game.Online.Chat
            string command = parameters[0];
            string content = parameters.Length == 2 ? parameters[1] : string.Empty;

-            switch (command)
+            switch (command.ToLowerInvariant())
            {
                case "np":
                    AddInternal(new NowPlayingCommand(target));
@@ -23,7 +23,6 @@ namespace osu.Game.Online.Metadata
        public override IBindable<bool> IsWatchingUserPresence => isWatchingUserPresence;
        private readonly BindableBool isWatchingUserPresence = new BindableBool();

-        // ReSharper disable once InconsistentlySynchronizedField
        public override IBindableDictionary<int, UserPresence> UserStates => userStates;
        private readonly BindableDictionary<int, UserPresence> userStates = new BindableDictionary<int, UserPresence>();

@@ -192,7 +191,7 @@ namespace osu.Game.Online.Metadata
        {
            Schedule(() =>
            {
-                if (presence != null)
+                if (presence?.Status != null)
                    userStates[userId] = presence.Value;
                else
                    userStates.Remove(userId);
@@ -994,7 +994,7 @@ namespace osu.Game
                Margin = new MarginPadding(5),
            }, topMostOverlayContent.Add);

-            if (!args?.Any(a => a == @"--no-version-overlay") ?? true)
+            if (!IsDeployedBuild)
            {
                dependencies.Cache(versionManager = new VersionManager { Depth = int.MinValue });
                loadComponentSingleFile(versionManager, ScreenContainer.Add);
@@ -200,6 +200,8 @@ namespace osu.Game

        private RulesetConfigCache rulesetConfigCache;

+        private SessionAverageHitErrorTracker hitErrorTracker;
+
        protected SpectatorClient SpectatorClient { get; private set; }

        protected MultiplayerClient MultiplayerClient { get; private set; }
@@ -349,6 +351,7 @@ namespace osu.Game
                dependencies.CacheAs(powerStatus);

            dependencies.Cache(SessionStatics = new SessionStatics());
+            dependencies.Cache(hitErrorTracker = new SessionAverageHitErrorTracker());
            dependencies.Cache(Colours = new OsuColour());

            RegisterImportHandler(BeatmapManager);
@@ -408,6 +411,7 @@ namespace osu.Game
            });

            base.Content.Add(new TouchInputInterceptor());
+            base.Content.Add(hitErrorTracker);

            KeyBindingStore = new RealmKeyBindingStore(realm, keyCombinationProvider);
            KeyBindingStore.Register(globalBindings, RulesetStore.AvailableRulesets);
@@ -14,6 +14,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
+using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Graphics.Containers;
 using osuTK;
@@ -25,14 +26,13 @@ namespace osu.Game.Overlays.Dialog
    public abstract partial class PopupDialog : VisibilityContainer
    {
        public const float ENTER_DURATION = 500;
-        public const float EXIT_DURATION = 200;
+        public const float EXIT_DURATION = 500;

        private readonly Vector2 ringSize = new Vector2(100f);
        private readonly Vector2 ringMinifiedSize = new Vector2(20f);
-        private readonly Vector2 buttonsEnterSpacing = new Vector2(0f, 50f);

        private readonly Box flashLayer;
-        private Sample flashSample = null!;
+        private Sample? flashSample;

        private readonly Container content;
        private readonly Container ring;
@@ -108,13 +108,20 @@ namespace osu.Game.Overlays.Dialog

        protected PopupDialog()
        {
-            RelativeSizeAxes = Axes.Both;
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;

            Children = new Drawable[]
            {
                content = new Container
                {
-                    RelativeSizeAxes = Axes.Both,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
                    Alpha = 0f,
                    Children = new Drawable[]
                    {
@@ -122,11 +129,13 @@ namespace osu.Game.Overlays.Dialog
                        {
                            RelativeSizeAxes = Axes.Both,
                            Masking = true,
+                            CornerRadius = 20,
+                            CornerExponent = 2.5f,
                            EdgeEffect = new EdgeEffectParameters
                            {
                                Type = EdgeEffectType.Shadow,
-                                Colour = Color4.Black.Opacity(0.5f),
-                                Radius = 8,
+                                Colour = Color4.Black.Opacity(0.2f),
+                                Radius = 14,
                            },
                            Children = new Drawable[]
                            {
@@ -142,23 +151,29 @@ namespace osu.Game.Overlays.Dialog
                                    ColourDark = Color4Extensions.FromHex(@"1e171e"),
                                    TriangleScale = 4,
                                },
+                                flashLayer = new Box
+                                {
+                                    Alpha = 0,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Blending = BlendingParameters.Additive,
+                                    Colour = Color4Extensions.FromHex(@"221a21"),
+                                },
                            },
                        },
                        new FillFlowContainer
                        {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.BottomCentre,
                            RelativeSizeAxes = Axes.X,
                            AutoSizeAxes = Axes.Y,
                            Direction = FillDirection.Vertical,
                            Spacing = new Vector2(0f, 10f),
-                            Padding = new MarginPadding { Bottom = 10 },
+                            Padding = new MarginPadding { Vertical = 60 },
                            Children = new Drawable[]
                            {
                                new Container
                                {
                                    Origin = Anchor.TopCentre,
                                    Anchor = Anchor.TopCentre,
+                                    Padding = new MarginPadding { Bottom = 30 },
                                    Size = ringSize,
                                    Children = new Drawable[]
                                    {
@@ -181,6 +196,7 @@ namespace osu.Game.Overlays.Dialog
                                                    Origin = Anchor.Centre,
                                                    Anchor = Anchor.Centre,
                                                    Icon = FontAwesome.Solid.TimesCircle,
+                                                    Y = -2,
                                                    Size = new Vector2(50),
                                                },
                                            },
@@ -194,6 +210,7 @@ namespace osu.Game.Overlays.Dialog
                                    RelativeSizeAxes = Axes.X,
                                    AutoSizeAxes = Axes.Y,
                                    TextAnchor = Anchor.TopCentre,
+                                    Padding = new MarginPadding { Horizontal = 5 },
                                },
                                body = new OsuTextFlowContainer(t => t.Font = t.Font.With(size: 18))
                                {
@@ -202,25 +219,19 @@ namespace osu.Game.Overlays.Dialog
                                    TextAnchor = Anchor.TopCentre,
                                    RelativeSizeAxes = Axes.X,
                                    AutoSizeAxes = Axes.Y,
-                                    Padding = new MarginPadding(5),
+                                    Padding = new MarginPadding { Horizontal = 5 },
+                                },
+                                buttonsContainer = new FillFlowContainer<PopupDialogButton>
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    RelativeSizeAxes = Axes.X,
+                                    AutoSizeAxes = Axes.Y,
+                                    Direction = FillDirection.Vertical,
+                                    Padding = new MarginPadding { Top = 30 },
                                },
                            },
                        },
-                        buttonsContainer = new FillFlowContainer<PopupDialogButton>
-                        {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.TopCentre,
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                            Direction = FillDirection.Vertical,
-                        },
-                        flashLayer = new Box
-                        {
-                            Alpha = 0,
-                            RelativeSizeAxes = Axes.Both,
-                            Blending = BlendingParameters.Additive,
-                            Colour = Color4Extensions.FromHex(@"221a21"),
-                        },
                    },
                },
            };
@@ -231,7 +242,7 @@ namespace osu.Game.Overlays.Dialog
        }

        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        private void load(AudioManager audio, OsuColour colours)
        {
            flashSample = audio.Samples.Get(@"UI/default-select-disabled");
        }
@@ -256,7 +267,7 @@ namespace osu.Game.Overlays.Dialog
            flashLayer.FadeInFromZero(80, Easing.OutQuint)
                      .Then()
                      .FadeOutFromOne(1500, Easing.OutQuint);
-            flashSample.Play();
+            flashSample?.Play();
        }

        protected override bool OnKeyDown(KeyDownEvent e)
@@ -288,15 +299,15 @@ namespace osu.Game.Overlays.Dialog
            // Reset various animations but only if the dialog animation fully completed
            if (content.Alpha == 0)
            {
-                buttonsContainer.TransformSpacingTo(buttonsEnterSpacing);
-                buttonsContainer.MoveToY(buttonsEnterSpacing.Y);
+                content.ScaleTo(0.7f);
                ring.ResizeTo(ringMinifiedSize);
            }

-            content.FadeIn(ENTER_DURATION, Easing.OutQuint);
-            ring.ResizeTo(ringSize, ENTER_DURATION, Easing.OutQuint);
-            buttonsContainer.TransformSpacingTo(Vector2.Zero, ENTER_DURATION, Easing.OutQuint);
-            buttonsContainer.MoveToY(0, ENTER_DURATION, Easing.OutQuint);
+            content
+                .ScaleTo(1, 750, Easing.OutElasticHalf)
+                .FadeIn(ENTER_DURATION, Easing.OutQuint);
+
+            ring.ResizeTo(ringSize, ENTER_DURATION * 1.5f, Easing.OutQuint);
        }

        protected override void PopOut()
@@ -306,7 +317,9 @@ namespace osu.Game.Overlays.Dialog
                // This is presumed to always be a sane default "cancel" action.
                buttonsContainer.Last().TriggerClick();

-            content.FadeOut(EXIT_DURATION, Easing.InSine);
+            content
+                .ScaleTo(0.7f, EXIT_DURATION, Easing.Out)
+                .FadeOut(EXIT_DURATION, Easing.OutQuint);
        }

        private void pressButtonAtIndex(int index)
@@ -29,16 +29,18 @@ namespace osu.Game.Overlays

        public DialogOverlay()
        {
-            RelativeSizeAxes = Axes.Both;
+            AutoSizeAxes = Axes.Y;

            Child = dialogContainer = new Container
            {
-                RelativeSizeAxes = Axes.Both,
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
            };

-            Width = 0.4f;
-            Anchor = Anchor.BottomCentre;
-            Origin = Anchor.BottomCentre;
+            Width = 500;
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
        }

        [BackgroundDependencyLoader]
@@ -143,6 +143,8 @@ namespace osu.Game.Overlays.Login
                    panel.Status.BindTo(api.LocalUser.Value.Status);
                    panel.Activity.BindTo(api.LocalUser.Value.Activity);

+                    panel.Status.BindValueChanged(_ => updateDropdownCurrent(), true);
+
                    dropdown.Current.BindValueChanged(action =>
                    {
                        switch (action.NewValue)
@@ -174,6 +176,24 @@ namespace osu.Game.Overlays.Login
                ScheduleAfterChildren(() => GetContainingInputManager()?.ChangeFocus(form));
        });

+        private void updateDropdownCurrent()
+        {
+            switch (panel.Status.Value)
+            {
+                case UserStatus.Online:
+                    dropdown.Current.Value = UserAction.Online;
+                    break;
+
+                case UserStatus.DoNotDisturb:
+                    dropdown.Current.Value = UserAction.DoNotDisturb;
+                    break;
+
+                case UserStatus.Offline:
+                    dropdown.Current.Value = UserAction.AppearOffline;
+                    break;
+            }
+        }
+
        public override bool AcceptsFocus => true;

        protected override bool OnClick(ClickEvent e) => true;
@@ -4,7 +4,6 @@
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.LocalisationExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -15,6 +14,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Utils;
 using osuTK;

 namespace osu.Game.Overlays.Mods
@@ -147,7 +147,7 @@ namespace osu.Game.Overlays.Mods
        {
            protected override double RollingDuration => 500;

-            protected override LocalisableString FormatCount(double count) => count.ToLocalisableString(@"0.00x");
+            protected override LocalisableString FormatCount(double count) => ModUtils.FormatScoreMultiplier(count);

            protected override OsuSpriteText CreateSpriteText() => new OsuSpriteText
            {
@@ -145,7 +145,7 @@ namespace osu.Game.Overlays.Profile.Header
            bool anyInfoAdded = false;

            anyInfoAdded |= tryAddInfo(FontAwesome.Solid.MapMarker, user.Location);
-            anyInfoAdded |= tryAddInfo(OsuIcon.Heart, user.Interests);
+            anyInfoAdded |= tryAddInfo(FontAwesome.Solid.Heart, user.Interests);
            anyInfoAdded |= tryAddInfo(FontAwesome.Solid.Suitcase, user.Occupation);

            if (anyInfoAdded)
@@ -0,0 +1,162 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Specialized;
+using System.Diagnostics;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Localisation;
+using osuTK;
+
+namespace osu.Game.Overlays.Settings.Sections.Audio
+{
+    public partial class AudioOffsetAdjustControl : SettingsItem<double>
+    {
+        public IBindable<double?> SuggestedOffset => ((AudioOffsetPreview)Control).SuggestedOffset;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            LabelText = AudioSettingsStrings.AudioOffset;
+        }
+
+        protected override Drawable CreateControl() => new AudioOffsetPreview();
+
+        private partial class AudioOffsetPreview : CompositeDrawable, IHasCurrentValue<double>
+        {
+            public Bindable<double> Current
+            {
+                get => current.Current;
+                set => current.Current = value;
+            }
+
+            private readonly BindableNumberWithCurrent<double> current = new BindableNumberWithCurrent<double>();
+
+            private readonly IBindableList<SessionAverageHitErrorTracker.DataPoint> averageHitErrorHistory = new BindableList<SessionAverageHitErrorTracker.DataPoint>();
+
+            public readonly Bindable<double?> SuggestedOffset = new Bindable<double?>();
+
+            private Container<Box> notchContainer = null!;
+            private TextFlowContainer hintText = null!;
+            private RoundedButton applySuggestion = null!;
+
+            [BackgroundDependencyLoader]
+            private void load(SessionAverageHitErrorTracker hitErrorTracker)
+            {
+                averageHitErrorHistory.BindTo(hitErrorTracker.AverageHitErrorHistory);
+
+                RelativeSizeAxes = Axes.X;
+                AutoSizeAxes = Axes.Y;
+                InternalChild = new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Spacing = new Vector2(10),
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        new TimeSlider
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Current = { BindTarget = Current },
+                            KeyboardStep = 1,
+                        },
+                        notchContainer = new Container<Box>
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Height = 10,
+                            Padding = new MarginPadding { Horizontal = Nub.DEFAULT_EXPANDED_SIZE / 2 },
+                            Anchor = Anchor.TopCentre,
+                            Origin = Anchor.TopCentre,
+                        },
+                        hintText = new OsuTextFlowContainer(t => t.Font = OsuFont.Default.With(size: 16))
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                        },
+                        applySuggestion = new RoundedButton
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Text = "Apply suggested offset",
+                            Action = () =>
+                            {
+                                if (SuggestedOffset.Value.HasValue)
+                                    current.Value = SuggestedOffset.Value.Value;
+                                hitErrorTracker.ClearHistory();
+                            }
+                        }
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                averageHitErrorHistory.BindCollectionChanged(updateDisplay, true);
+                SuggestedOffset.BindValueChanged(_ => updateHintText(), true);
+            }
+
+            private void updateDisplay(object? _, NotifyCollectionChangedEventArgs e)
+            {
+                switch (e.Action)
+                {
+                    case NotifyCollectionChangedAction.Add:
+                        foreach (SessionAverageHitErrorTracker.DataPoint dataPoint in e.NewItems!)
+                        {
+                            notchContainer.ForEach(n => n.Alpha *= 0.95f);
+                            notchContainer.Add(new Box
+                            {
+                                RelativeSizeAxes = Axes.Y,
+                                Width = 2,
+                                RelativePositionAxes = Axes.X,
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                X = getXPositionForOffset(dataPoint.SuggestedGlobalAudioOffset)
+                            });
+                        }
+
+                        break;
+
+                    case NotifyCollectionChangedAction.Remove:
+                        foreach (SessionAverageHitErrorTracker.DataPoint dataPoint in e.OldItems!)
+                        {
+                            var notch = notchContainer.FirstOrDefault(n => n.X == getXPositionForOffset(dataPoint.SuggestedGlobalAudioOffset));
+                            Debug.Assert(notch != null);
+                            notchContainer.Remove(notch, true);
+                        }
+
+                        break;
+
+                    case NotifyCollectionChangedAction.Reset:
+                        notchContainer.Clear();
+                        break;
+                }
+
+                SuggestedOffset.Value = averageHitErrorHistory.Any() ? averageHitErrorHistory.Average(dataPoint => dataPoint.SuggestedGlobalAudioOffset) : null;
+            }
+
+            private float getXPositionForOffset(double offset) => (float)(Math.Clamp(offset, current.MinValue, current.MaxValue) / (2 * current.MaxValue));
+
+            private void updateHintText()
+            {
+                hintText.Text = SuggestedOffset.Value == null
+                    ? @"Play a few beatmaps to receive a suggested offset!"
+                    : $@"Based on the last {averageHitErrorHistory.Count} play(s), the suggested offset is {SuggestedOffset.Value:N0} ms.";
+                applySuggestion.Enabled.Value = SuggestedOffset.Value != null;
+            }
+        }
+    }
+}
@@ -7,7 +7,6 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Localisation;

 namespace osu.Game.Overlays.Settings.Sections.Audio
@@ -16,23 +15,17 @@ namespace osu.Game.Overlays.Settings.Sections.Audio
    {
        protected override LocalisableString Header => AudioSettingsStrings.OffsetHeader;

-        public override IEnumerable<LocalisableString> FilterTerms => base.FilterTerms.Concat(new LocalisableString[] { "universal", "uo", "timing", "delay", "latency" });
+        public override IEnumerable<LocalisableString> FilterTerms => base.FilterTerms.Concat(new LocalisableString[] { "universal", "uo", "timing", "delay", "latency", "wizard" });

        [BackgroundDependencyLoader]
        private void load(OsuConfigManager config)
        {
            Children = new Drawable[]
            {
-                new SettingsSlider<double, TimeSlider>
+                new AudioOffsetAdjustControl
                {
-                    LabelText = AudioSettingsStrings.AudioOffset,
                    Current = config.GetBindable<double>(OsuSetting.AudioOffset),
-                    KeyboardStep = 1f
                },
-                new SettingsButton
-                {
-                    Text = AudioSettingsStrings.OffsetWizard
-                }
            };
        }
    }
@@ -3,19 +3,21 @@

 #nullable disable

+using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+using osu.Framework.Testing;
+using osu.Game.Graphics;
+using osu.Game.Localisation;
 using osu.Game.Overlays.Settings;
 using osu.Game.Overlays.Settings.Sections;
 using osu.Game.Overlays.Settings.Sections.Input;
 using osuTK.Graphics;
-using System.Collections.Generic;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Localisation;
-using osu.Game.Graphics;
-using osu.Game.Localisation;

 namespace osu.Game.Overlays
 {
@@ -55,6 +57,21 @@ namespace osu.Game.Overlays

        public override bool AcceptsFocus => lastOpenedSubPanel == null || lastOpenedSubPanel.State.Value == Visibility.Hidden;

+        public void ShowAtControl<T>()
+            where T : Drawable
+        {
+            Show();
+
+            // wait for load of sections
+            if (!SectionsContainer.Any())
+            {
+                Scheduler.Add(ShowAtControl<T>);
+                return;
+            }
+
+            SectionsContainer.ScrollTo(SectionsContainer.ChildrenOfType<T>().Single());
+        }
+
        private T createSubPanel<T>(T subPanel)
            where T : SettingsSubPanel
        {
@@ -40,8 +40,6 @@ namespace osu.Game.Overlays.Toolbar
        [BackgroundDependencyLoader]
        private void load(OsuColour colours, IAPIProvider api, LoginOverlay? login)
        {
-            BackgroundContent.Add(new OpaqueBackground { Depth = 1 });
-
            Flow.Add(new Container
            {
                Masking = true,
@@ -17,7 +17,7 @@ namespace osu.Game.Overlays.Wiki
 {
    public partial class WikiHeader : BreadcrumbControlOverlayHeader
    {
-        private const string index_path = "Main_Page";
+        private const string index_path = "Main_page";

        public static LocalisableString IndexPageString => LayoutStrings.HeaderHelpIndex;

@@ -19,7 +19,7 @@ namespace osu.Game.Overlays
 {
    public partial class WikiOverlay : OnlineOverlay<WikiHeader>
    {
-        private const string index_path = @"main_page";
+        private const string index_path = "Main_page";

        public string CurrentPath => path.Value;

@@ -161,7 +161,7 @@ namespace osu.Game.Overlays
            path.Value = "error";

            LoadDisplay(articlePage = new WikiArticlePage($@"{api.WebsiteRootUrl}/wiki/",
-                $"Something went wrong when trying to fetch page \"{originalPath}\".\n\n[Return to the main page](Main_Page)."));
+                $"Something went wrong when trying to fetch page \"{originalPath}\".\n\n[Return to the main page](Main_page)."));
        }

        private void showParentPage()
@@ -73,6 +73,7 @@ namespace osu.Game.Rulesets.Judgements
                        return HitResult.SmallTickMiss;

                    case HitResult.LargeTickHit:
+                    case HitResult.SliderTailHit:
                        return HitResult.LargeTickMiss;

                    default:
@@ -104,6 +105,7 @@ namespace osu.Game.Rulesets.Judgements
                case HitResult.SmallTickMiss:
                    return -DEFAULT_MAX_HEALTH_INCREASE * 0.5;

+                case HitResult.SliderTailHit:
                case HitResult.LargeTickHit:
                    return DEFAULT_MAX_HEALTH_INCREASE;

@@ -195,7 +195,7 @@ namespace osu.Game.Rulesets.Mods
        /// <summary>
        /// Whether all settings in this mod are set to their default state.
        /// </summary>
-        protected virtual bool UsesDefaultConfiguration => SettingsBindables.All(s => s.IsDefault);
+        public virtual bool UsesDefaultConfiguration => SettingsBindables.All(s => s.IsDefault);

        /// <summary>
        /// Creates a copy of this <see cref="Mod"/> initialised to a default state.
@@ -56,9 +56,6 @@ namespace osu.Game.Rulesets.Mods
        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
        {
            Combo.BindTo(scoreProcessor.Combo);
-
-            // Default value of ScoreProcessor's Rank in Flashlight Mod should be SS+
-            scoreProcessor.Rank.Value = ScoreRank.XH;
        }

        public ScoreRank AdjustRank(ScoreRank rank, double accuracy)
@@ -17,8 +17,6 @@ namespace osu.Game.Rulesets.Mods

        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
        {
-            // Default value of ScoreProcessor's Rank in Hidden Mod should be SS+
-            scoreProcessor.Rank.Value = ScoreRank.XH;
        }

        public ScoreRank AdjustRank(ScoreRank rank, double accuracy)
@@ -139,6 +139,13 @@ namespace osu.Game.Rulesets.Scoring
        [Order(15)]
        ComboBreak,

+        /// <summary>
+        /// A special judgement similar to <see cref="LargeTickHit"/> that's used to increase the valuation of the final tick of a slider.
+        /// </summary>
+        [EnumMember(Value = "slider_tail_hit")]
+        [Order(16)]
+        SliderTailHit,
+
        /// <summary>
        /// A special result used as a padding value for legacy rulesets. It is a hit type and affects combo, but does not affect the base score (does not affect accuracy).
        ///
@@ -188,6 +195,7 @@ namespace osu.Game.Rulesets.Scoring
                case HitResult.LargeTickMiss:
                case HitResult.LegacyComboIncrease:
                case HitResult.ComboBreak:
+                case HitResult.SliderTailHit:
                    return true;

                default:
@@ -246,6 +254,7 @@ namespace osu.Game.Rulesets.Scoring
                case HitResult.LargeTickMiss:
                case HitResult.SmallTickHit:
                case HitResult.SmallTickMiss:
+                case HitResult.SliderTailHit:
                    return true;

                default:
@@ -329,6 +338,9 @@ namespace osu.Game.Rulesets.Scoring
                case HitResult.ComboBreak:
                    return true;

+                case HitResult.SliderTailHit:
+                    return true;
+
                default:
                    // Note that IgnoreHit and IgnoreMiss are excluded as they do not affect score.
                    return result >= HitResult.Miss && result < HitResult.IgnoreMiss;
@@ -383,6 +395,9 @@ namespace osu.Game.Rulesets.Scoring
            if (minResult == HitResult.IgnoreMiss)
                return;

+            if (maxResult == HitResult.SliderTailHit && minResult != HitResult.LargeTickMiss)
+                throw new ArgumentOutOfRangeException(nameof(minResult), $"{HitResult.LargeTickMiss} is the only valid minimum result for a {maxResult} judgement.");
+
            if (maxResult == HitResult.LargeTickHit && minResult != HitResult.LargeTickMiss)
                throw new ArgumentOutOfRangeException(nameof(minResult), $"{HitResult.LargeTickMiss} is the only valid minimum result for a {maxResult} judgement.");

@@ -86,7 +86,9 @@ namespace osu.Game.Rulesets.Scoring
        /// <summary>
        /// The current rank.
        /// </summary>
-        public readonly Bindable<ScoreRank> Rank = new Bindable<ScoreRank>(ScoreRank.X);
+        public IBindable<ScoreRank> Rank => rank;
+
+        private readonly Bindable<ScoreRank> rank = new Bindable<ScoreRank>(ScoreRank.X);

        /// <summary>
        /// The highest combo achieved by this score.
@@ -186,9 +188,13 @@ namespace osu.Game.Rulesets.Scoring
            Combo.ValueChanged += combo => HighestCombo.Value = Math.Max(HighestCombo.Value, combo.NewValue);
            Accuracy.ValueChanged += accuracy =>
            {
-                Rank.Value = RankFromAccuracy(accuracy.NewValue);
+                // Once failed, we shouldn't update the rank anymore.
+                if (rank.Value == ScoreRank.F)
+                    return;
+
+                rank.Value = RankFromAccuracy(accuracy.NewValue);
                foreach (var mod in Mods.Value.OfType<IApplicableToScoreProcessor>())
-                    Rank.Value = mod.AdjustRank(Rank.Value, accuracy.NewValue);
+                    rank.Value = mod.AdjustRank(Rank.Value, accuracy.NewValue);
            };

            Mods.ValueChanged += mods =>
@@ -322,6 +328,9 @@ namespace osu.Game.Rulesets.Scoring
                case HitResult.LargeTickHit:
                    return 30;

+                case HitResult.SliderTailHit:
+                    return 150;
+
                case HitResult.Meh:
                    return 50;

@@ -408,8 +417,7 @@ namespace osu.Game.Rulesets.Scoring
            TotalScore.Value = 0;
            Accuracy.Value = 1;
            Combo.Value = 0;
-            Rank.Disabled = false;
-            Rank.Value = ScoreRank.X;
+            rank.Value = ScoreRank.X;
            HighestCombo.Value = 0;
        }

@@ -445,7 +453,7 @@ namespace osu.Game.Rulesets.Scoring
                return;

            score.Passed = false;
-            Rank.Value = ScoreRank.F;
+            rank.Value = ScoreRank.F;

            PopulateScore(score);
        }
@@ -207,6 +207,7 @@ namespace osu.Game.Scoring

            clone.Statistics = new Dictionary<HitResult, int>(clone.Statistics);
            clone.MaximumStatistics = new Dictionary<HitResult, int>(clone.MaximumStatistics);
+            clone.HitEvents = new List<HitEvent>(clone.HitEvents);

            // Ensure we have fresh mods to avoid any references (ie. after gameplay).
            clone.clearAllMods();
@@ -349,6 +350,7 @@ namespace osu.Game.Scoring
                {
                    case HitResult.SmallTickHit:
                    case HitResult.LargeTickHit:
+                    case HitResult.SliderTailHit:
                    case HitResult.LargeBonus:
                    case HitResult.SmallBonus:
                        if (MaximumStatistics.TryGetValue(r.result, out int count) && count > 0)
@@ -62,6 +62,9 @@ namespace osu.Game.Screens.Edit.Compose.Components

        protected override bool OnDragStart(DragStartEvent e)
        {
+            if (e.Button != MouseButton.Left)
+                return false;
+
            if (rotationHandler == null) return false;

            rotationHandler.Begin();
@@ -144,13 +144,26 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
            track.BindValueChanged(_ =>
            {
                waveform.Waveform = beatmap.Value.Waveform;
-                waveform.RelativePositionAxes = Axes.X;
-                waveform.X = -(float)(Editor.WAVEFORM_VISUAL_OFFSET / beatmap.Value.Track.Length);
+                Scheduler.AddOnce(applyVisualOffset, beatmap);
            }, true);

            Zoom = (float)(defaultTimelineZoom * editorBeatmap.BeatmapInfo.TimelineZoom);
        }

+        private void applyVisualOffset(IBindable<WorkingBeatmap> beatmap)
+        {
+            waveform.RelativePositionAxes = Axes.X;
+
+            if (beatmap.Value.Track.Length > 0)
+                waveform.X = -(float)(Editor.WAVEFORM_VISUAL_OFFSET / beatmap.Value.Track.Length);
+            else
+            {
+                // sometimes this can be the case immediately after a track switch.
+                // reschedule with the hope that the track length eventually populates.
+                Scheduler.AddOnce(applyVisualOffset, beatmap);
+            }
+        }
+
        protected override void LoadComplete()
        {
            base.LoadComplete();
@@ -224,7 +224,7 @@ namespace osu.Game.Screens.Edit.Timing
                row.Alpha = time < selectedGroupStartTime || time > selectedGroupEndTime ? 0.2f : 1;
                row.WaveformOffsetTo(-offset, animated);
                row.WaveformScale = new Vector2(scale, 1);
-                row.BeatIndex = (int)Math.Floor(index);
+                row.BeatIndex = (int)Math.Round(index);

                index++;
            }
@@ -5,6 +5,7 @@

 using System;
 using System.Diagnostics;
+using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -25,6 +26,7 @@ using osu.Game.Input.Bindings;
 using osu.Game.IO;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Dialog;
 using osu.Game.Overlays.SkinEditor;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Backgrounds;
@@ -94,6 +96,7 @@ namespace osu.Game.Screens.Menu
        private ParallaxContainer buttonsContainer;
        private SongTicker songTicker;
        private Container logoTarget;
+        private SystemTitle systemTitle;
        private MenuTip menuTip;
        private FillFlowContainer bottomElementsFlow;
        private SupporterDisplay supporterDisplay;
@@ -173,7 +176,7 @@ namespace osu.Game.Screens.Menu
                            Anchor = Anchor.TopCentre,
                            Origin = Anchor.TopCentre,
                        },
-                        new SystemTitle
+                        systemTitle = new SystemTitle
                        {
                            Anchor = Anchor.TopCentre,
                            Origin = Anchor.TopCentre,
@@ -196,10 +199,12 @@ namespace osu.Game.Screens.Menu
                    case ButtonSystemState.Initial:
                    case ButtonSystemState.Exit:
                        ApplyToBackground(b => b.FadeColour(Color4.White, 500, Easing.OutSine));
+                        systemTitle.State.Value = Visibility.Hidden;
                        break;

                    default:
                        ApplyToBackground(b => b.FadeColour(OsuColour.Gray(0.8f), 500, Easing.OutSine));
+                        systemTitle.State.Value = Visibility.Visible;
                        break;
                }
            };
@@ -387,7 +392,12 @@ namespace osu.Game.Screens.Menu
            if (requiresConfirmation)
            {
                if (dialogOverlay.CurrentDialog is ConfirmExitDialog exitDialog)
-                    exitDialog.PerformOkAction();
+                {
+                    if (exitDialog.Buttons.OfType<PopupDialogOkButton>().FirstOrDefault() != null)
+                        exitDialog.PerformOkAction();
+                    else
+                        exitDialog.Flash();
+                }
                else
                {
                    dialogOverlay.Push(new ConfirmExitDialog(() =>
@@ -31,6 +31,9 @@ namespace osu.Game.Screens.Menu
    /// </summary>
    public partial class MainMenuButton : BeatSyncedContainer, IStateful<ButtonState>
    {
+        public const float BOUNCE_COMPRESSION = 0.9f;
+        public const float HOVER_SCALE = 1.2f;
+        public const float BOUNCE_ROTATION = 8;
        public event Action<ButtonState>? StateChanged;

        public readonly Key[] TriggerKeys;
@@ -125,8 +128,9 @@ namespace osu.Game.Screens.Menu
                            Shadow = true,
                            Anchor = Anchor.Centre,
                            Origin = Anchor.Centre,
-                            Size = new Vector2(30),
+                            Size = new Vector2(32),
                            Position = new Vector2(0, 0),
+                            Margin = new MarginPadding { Top = -4 },
                            Icon = symbol
                        },
                        new OsuSpriteText
@@ -136,6 +140,7 @@ namespace osu.Game.Screens.Menu
                            Anchor = Anchor.Centre,
                            Origin = Anchor.Centre,
                            Position = new Vector2(0, 35),
+                            Margin = new MarginPadding { Left = -3 },
                            Text = text
                        }
                    }
@@ -153,14 +158,14 @@ namespace osu.Game.Screens.Menu

            double duration = timingPoint.BeatLength / 2;

-            icon.RotateTo(rightward ? 10 : -10, duration * 2, Easing.InOutSine);
+            icon.RotateTo(rightward ? BOUNCE_ROTATION : -BOUNCE_ROTATION, duration * 2, Easing.InOutSine);

            icon.Animate(
                i => i.MoveToY(-10, duration, Easing.Out),
-                i => i.ScaleTo(1, duration, Easing.Out)
+                i => i.ScaleTo(HOVER_SCALE, duration, Easing.Out)
            ).Then(
                i => i.MoveToY(0, duration, Easing.In),
-                i => i.ScaleTo(new Vector2(1, 0.9f), duration, Easing.In)
+                i => i.ScaleTo(new Vector2(HOVER_SCALE, HOVER_SCALE * BOUNCE_COMPRESSION), duration, Easing.In)
            );

            rightward = !rightward;
@@ -177,8 +182,8 @@ namespace osu.Game.Screens.Menu
            double duration = TimeUntilNextBeat;

            icon.ClearTransforms();
-            icon.RotateTo(rightward ? -10 : 10, duration, Easing.InOutSine);
-            icon.ScaleTo(new Vector2(1, 0.9f), duration, Easing.Out);
+            icon.RotateTo(rightward ? -BOUNCE_ROTATION : BOUNCE_ROTATION, duration, Easing.InOutSine);
+            icon.ScaleTo(new Vector2(HOVER_SCALE, HOVER_SCALE * BOUNCE_COMPRESSION), duration, Easing.Out);
            return true;
        }

@@ -94,22 +94,34 @@ namespace osu.Game.Screens.Menu
        {
            string[] tips =
            {
-                "You can press Ctrl-T anywhere in the game to toggle the toolbar!",
-                "You can press Ctrl-O anywhere in the game to access options!",
+                "Press Ctrl-T anywhere in the game to toggle the toolbar!",
+                "Press Ctrl-O anywhere in the game to access options!",
                "All settings are dynamic and take effect in real-time. Try changing the skin while watching autoplay!",
                "New features are coming online every update. Make sure to stay up-to-date!",
                "If you find the UI too large or small, try adjusting UI scale in settings!",
                "Try adjusting the \"Screen Scaling\" mode to change your gameplay or UI area, even in fullscreen!",
                "What used to be \"osu!direct\" is available to all users just like on the website. You can access it anywhere using Ctrl-B!",
-                "Seeking in replays is available by dragging on the difficulty bar at the bottom of the screen!",
+                "Seeking in replays is available by dragging on the progress bar at the bottom of the screen or by using the left and right arrow keys!",
                "Multithreading support means that even with low \"FPS\" your input and judgements will be accurate!",
-                "Try scrolling down in the mod select panel to find a bunch of new fun mods!",
+                "Try scrolling right in mod select to find a bunch of new fun mods!",
                "Most of the web content (profiles, rankings, etc.) are available natively in-game from the icons on the toolbar!",
                "Get more details, hide or delete a beatmap by right-clicking on its panel at song select!",
                "All delete operations are temporary until exiting. Restore accidentally deleted content from the maintenance settings!",
                "Check out the \"playlists\" system, which lets users create their own custom and permanent leaderboards!",
                "Toggle advanced frame / thread statistics with Ctrl-F11!",
                "Take a look under the hood at performance counters and enable verbose performance logging with Ctrl-F2!",
+                "You can pause during a replay by pressing Space!",
+                "Most of the hotkeys in the game are configurable and can be changed to anything you want. Check the bindings panel under input settings!",
+                "When your gameplay HUD is hidden, you can press and hold Ctrl to view it temporarily!",
+                "Your gameplay HUD can be customized by using the skin layout editor. Open it at any time via Ctrl-Shift-S!",
+                "Drag and drop any image into the skin editor to load it in quickly!",
+                "You can create mod presets to make toggling your favorite mod combinations easier!",
+                "Many mods have customisation settings that drastically change how they function. Click the Mod Customisation button in mod select to view settings!",
+                "Press Ctrl-Shift-R to switch to a random skin!",
+                "Press Ctrl-Shift-F to toggle the FPS Counter. But make sure not to pay too much attention to it!",
+                "While watching a replay, press Ctrl-H to toggle replay settings!",
+                "You can easily copy the mods from scores on a leaderboard by right-clicking on them!",
+                "Ctrl-Enter at song select will start a beatmap in autoplay mode!"
            };

            return tips[RNG.Next(0, tips.Length)];
@@ -18,10 +18,12 @@ using osu.Game.Online.API.Requests.Responses;

 namespace osu.Game.Screens.Menu
 {
-    public partial class SystemTitle : CompositeDrawable
+    public partial class SystemTitle : VisibilityContainer
    {
        internal Bindable<APISystemTitle?> Current { get; } = new Bindable<APISystemTitle?>();

+        private const float transition_duration = 500;
+
        private Container content = null!;
        private CancellationTokenSource? cancellationTokenSource;
        private SystemTitleImage? currentImage;
@@ -32,9 +34,13 @@ namespace osu.Game.Screens.Menu
        private void load(OsuGame? game)
        {
            AutoSizeAxes = Axes.Both;
+            AutoSizeDuration = transition_duration;
+            AutoSizeEasing = Easing.OutQuint;

            InternalChild = content = new OsuClickableContainer
            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
                AutoSizeAxes = Axes.Both,
                Action = () =>
                {
@@ -51,6 +57,10 @@ namespace osu.Game.Screens.Menu
            };
        }

+        protected override void PopIn() => content.FadeInFromZero(transition_duration, Easing.OutQuint);
+
+        protected override void PopOut() => content.FadeOut(transition_duration, Easing.OutQuint);
+
        protected override bool OnHover(HoverEvent e)
        {
            content.ScaleTo(1.05f, 2000, Easing.OutQuint);
@@ -138,8 +148,8 @@ namespace osu.Game.Screens.Menu
            [BackgroundDependencyLoader]
            private void load(LargeTextureStore textureStore)
            {
-                var texture = textureStore.Get(SystemTitle.Image);
-                if (SystemTitle.Image.Contains(@"@2x"))
+                Texture? texture = textureStore.Get(SystemTitle.Image);
+                if (texture != null && SystemTitle.Image.Contains(@"@2x"))
                    texture.ScaleAdjust *= 2;

                AutoSizeAxes = Axes.Both;
@@ -349,6 +349,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
            addItemButton.Alpha = localUserCanAddItem ? 1 : 0;

            Scheduler.AddOnce(UpdateMods);
+
+            Activity.Value = new UserActivity.InLobby(Room);
        }

        private bool localUserCanAddItem => client.IsHost || Room.QueueMode.Value != QueueMode.HostOnly;
@@ -26,9 +26,6 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
    {
        protected override bool PauseOnFocusLost => false;

-        // Disallow fails in multiplayer for now.
-        protected override bool CheckModsAllowFailure() => false;
-
        protected override UserActivity InitialActivity => new UserActivity.InMultiplayerGame(Beatmap.Value.BeatmapInfo, Ruleset.Value);

        [Resolved]
@@ -55,6 +52,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
            {
                AllowPause = false,
                AllowRestart = false,
+                AllowFailAnimation = false,
                AllowSkipping = room.AutoSkip.Value,
                AutomaticallySkipIntro = room.AutoSkip.Value,
                AlwaysShowLeaderboard = true,
@@ -4,12 +4,14 @@
 #nullable disable

 using System.Collections.Generic;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
 using osu.Game.Screens.Play.Break;

 namespace osu.Game.Screens.Play
@@ -113,7 +115,7 @@ namespace osu.Game.Screens.Play
            if (scoreProcessor != null)
            {
                info.AccuracyDisplay.Current.BindTo(scoreProcessor.Accuracy);
-                info.GradeDisplay.Current.BindTo(scoreProcessor.Rank);
+                ((IBindable<ScoreRank>)info.GradeDisplay.Current).BindTo(scoreProcessor.Rank);
            }
        }

@@ -46,7 +46,7 @@ namespace osu.Game.Screens.Play
        public bool HasPassed { get; set; }

        /// <summary>
-        /// Whether the user failed during gameplay.
+        /// Whether the user failed during gameplay. This is only set when the gameplay session has completed due to the fail.
        /// </summary>
        public bool HasFailed { get; set; }

@@ -40,6 +40,12 @@ namespace osu.Game.Screens.Play
            Precision = 0.1,
        };

+        /// <summary>
+        /// Whether the audio playback rate should be validated.
+        /// Mostly disabled for tests.
+        /// </summary>
+        internal bool ShouldValidatePlaybackRate { get; init; } = true;
+
        /// <summary>
        /// Whether the audio playback is within acceptable ranges.
        /// Will become false if audio playback is not going as expected.
@@ -223,6 +229,9 @@ namespace osu.Game.Screens.Play

        private void checkPlaybackValidity()
        {
+            if (!ShouldValidatePlaybackRate)
+                return;
+
            if (GameplayClock.IsRunning)
            {
                elapsedGameplayClockTime += GameplayClock.ElapsedFrameTime;
@@ -735,7 +735,7 @@ namespace osu.Game.Screens.Play
            }

            // Only show the completion screen if the player hasn't failed
-            if (HealthProcessor.HasFailed)
+            if (GameplayState.HasFailed)
                return;

            GameplayState.HasPassed = true;
@@ -801,8 +801,6 @@ namespace osu.Game.Screens.Play
                    // This player instance may already be in the process of exiting.
                    return;

-                Debug.Assert(ScoreProcessor.Rank.Value != ScoreRank.F);
-
                this.Push(CreateResults(prepareScoreForDisplayTask.GetResultSafely()));
            }, Time.Current + delay, 50);

@@ -924,37 +922,44 @@ namespace osu.Game.Screens.Play
            if (!CheckModsAllowFailure())
                return false;

-            Debug.Assert(!GameplayState.HasFailed);
-            Debug.Assert(!GameplayState.HasPassed);
-            Debug.Assert(!GameplayState.HasQuit);
+            if (Configuration.AllowFailAnimation)
+            {
+                Debug.Assert(!GameplayState.HasFailed);
+                Debug.Assert(!GameplayState.HasPassed);
+                Debug.Assert(!GameplayState.HasQuit);

-            GameplayState.HasFailed = true;
+                GameplayState.HasFailed = true;

-            updateGameplayState();
+                updateGameplayState();

-            // There is a chance that we could be in a paused state as the ruleset's internal clock (see FrameStabilityContainer)
-            // could process an extra frame after the GameplayClock is stopped.
-            // In such cases we want the fail state to precede a user triggered pause.
-            if (PauseOverlay.State.Value == Visibility.Visible)
-                PauseOverlay.Hide();
+                // There is a chance that we could be in a paused state as the ruleset's internal clock (see FrameStabilityContainer)
+                // could process an extra frame after the GameplayClock is stopped.
+                // In such cases we want the fail state to precede a user triggered pause.
+                if (PauseOverlay.State.Value == Visibility.Visible)
+                    PauseOverlay.Hide();

-            failAnimationContainer.Start();
+                failAnimationContainer.Start();

-            // Failures can be triggered either by a judgement, or by a mod.
-            //
-            // For the case of a judgement, due to ordering considerations, ScoreProcessor will not have received
-            // the final judgement which triggered the failure yet (see DrawableRuleset.NewResult handling above).
-            //
-            // A schedule here ensures that any lingering judgements from the current frame are applied before we
-            // finalise the score as "failed".
-            Schedule(() =>
+                // Failures can be triggered either by a judgement, or by a mod.
+                //
+                // For the case of a judgement, due to ordering considerations, ScoreProcessor will not have received
+                // the final judgement which triggered the failure yet (see DrawableRuleset.NewResult handling above).
+                //
+                // A schedule here ensures that any lingering judgements from the current frame are applied before we
+                // finalise the score as "failed".
+                Schedule(() =>
+                {
+                    ScoreProcessor.FailScore(Score.ScoreInfo);
+                    OnFail();
+
+                    if (GameplayState.Mods.OfType<IApplicableFailOverride>().Any(m => m.RestartOnFail))
+                        Restart(true);
+                });
+            }
+            else
            {
                ScoreProcessor.FailScore(Score.ScoreInfo);
-                OnFail();
-
-                if (GameplayState.Mods.OfType<IApplicableFailOverride>().Any(m => m.RestartOnFail))
-                    Restart(true);
-            });
+            }

            return true;
        }
@@ -15,6 +15,12 @@ namespace osu.Game.Screens.Play
        /// </summary>
        public bool ShowResults { get; set; } = true;

+        /// <summary>
+        /// Whether the fail animation / screen should be triggered on failing.
+        /// If false, the score will still be marked as failed but gameplay will continue.
+        /// </summary>
+        public bool AllowFailAnimation { get; set; } = true;
+
        /// <summary>
        /// Whether the player should be allowed to trigger a restart.
        /// </summary>
@@ -263,10 +263,6 @@ namespace osu.Game.Screens.Play

            Debug.Assert(CurrentPlayer != null);

-            var lastScore = CurrentPlayer.Score;
-
-            AudioSettings.ReferenceScore.Value = lastScore?.ScoreInfo;
-
            // prepare for a retry.
            CurrentPlayer = null;
            playerConsumed = false;
@@ -14,7 +14,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
 {
    public partial class AudioSettings : PlayerSettingsGroup
    {
-        public Bindable<ScoreInfo> ReferenceScore { get; } = new Bindable<ScoreInfo>();
+        private Bindable<ScoreInfo> referenceScore { get; } = new Bindable<ScoreInfo>();

        private readonly PlayerCheckbox beatmapHitsoundsToggle;

@@ -26,15 +26,16 @@ namespace osu.Game.Screens.Play.PlayerSettings
                beatmapHitsoundsToggle = new PlayerCheckbox { LabelText = SkinSettingsStrings.BeatmapHitsounds },
                new BeatmapOffsetControl
                {
-                    ReferenceScore = { BindTarget = ReferenceScore },
+                    ReferenceScore = { BindTarget = referenceScore },
                },
            };
        }

        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load(OsuConfigManager config, SessionStatics statics)
        {
            beatmapHitsoundsToggle.Current = config.GetBindable<bool>(OsuSetting.BeatmapHitsounds);
+            statics.BindWith(Static.LastLocalUserScore, referenceScore);
        }
    }
 }
@@ -7,6 +7,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
@@ -20,7 +21,9 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Input.Bindings;
 using osu.Game.Localisation;
+using osu.Game.Overlays;
 using osu.Game.Overlays.Settings;
+using osu.Game.Overlays.Settings.Sections.Audio;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
@@ -157,11 +160,11 @@ namespace osu.Game.Screens.Play.PlayerSettings
                    // Apply to all difficulties in a beatmap set for now (they generally always share timing).
                    foreach (var b in setInfo.Beatmaps)
                    {
-                        BeatmapUserSettings settings = b.UserSettings;
+                        BeatmapUserSettings userSettings = b.UserSettings;
                        double val = Current.Value;

-                        if (settings.Offset != val)
-                            settings.Offset = val;
+                        if (userSettings.Offset != val)
+                            userSettings.Offset = val;
                    }
                });
            }
@@ -174,6 +177,9 @@ namespace osu.Game.Screens.Play.PlayerSettings
            if (score.NewValue == null)
                return;

+            if (!score.NewValue.BeatmapInfo.AsNonNull().Equals(beatmap.Value.BeatmapInfo))
+                return;
+
            if (score.NewValue.Mods.Any(m => !m.UserPlayable || m is IHasNoTimedInputs))
                return;

@@ -209,6 +215,8 @@ namespace osu.Game.Screens.Play.PlayerSettings
            lastPlayAverage = average;
            lastPlayBeatmapOffset = Current.Value;

+            LinkFlowContainer globalOffsetText;
+
            referenceScoreContainer.AddRange(new Drawable[]
            {
                lastPlayGraph = new HitEventTimingDistributionGraph(hitEvents)
@@ -222,9 +230,24 @@ namespace osu.Game.Screens.Play.PlayerSettings
                    Text = BeatmapOffsetControlStrings.CalibrateUsingLastPlay,
                    Action = () => Current.Value = lastPlayBeatmapOffset - lastPlayAverage
                },
+                globalOffsetText = new LinkFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                }
            });
+
+            if (settings != null)
+            {
+                globalOffsetText.AddText("You can also ");
+                globalOffsetText.AddLink("adjust the global offset", () => settings.ShowAtControl<AudioOffsetAdjustControl>());
+                globalOffsetText.AddText(" based off this play.");
+            }
        }

+        [Resolved]
+        private SettingsOverlay? settings { get; set; }
+
        protected override void Dispose(bool isDisposing)
        {
            base.Dispose(isDisposing);
@@ -11,6 +11,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Logging;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Database;
 using osu.Game.Online.API;
 using osu.Game.Online.Multiplayer;
@@ -37,6 +38,10 @@ namespace osu.Game.Screens.Play
        [Resolved]
        private SpectatorClient spectatorClient { get; set; }

+        [Resolved]
+        private SessionStatics statics { get; set; }
+
+        private readonly object scoreSubmissionLock = new object();
        private TaskCompletionSource<bool> scoreSubmissionSource;

        protected SubmittingPlayer(PlayerConfiguration configuration = null)
@@ -176,6 +181,7 @@ namespace osu.Game.Screens.Play
        {
            bool exiting = base.OnExiting(e);
            submitFromFailOrQuit();
+            statics.SetValue(Static.LastLocalUserScore, Score?.ScoreInfo.DeepClone());
            return exiting;
        }

@@ -223,16 +229,19 @@ namespace osu.Game.Screens.Play
                return Task.CompletedTask;
            }

-            if (scoreSubmissionSource != null)
-                return scoreSubmissionSource.Task;
+            lock (scoreSubmissionLock)
+            {
+                if (scoreSubmissionSource != null)
+                    return scoreSubmissionSource.Task;
+
+                scoreSubmissionSource = new TaskCompletionSource<bool>();
+            }

            // if the user never hit anything, this score should not be counted in any way.
            if (!score.ScoreInfo.Statistics.Any(s => s.Key.IsHit() && s.Value > 0))
                return Task.CompletedTask;

            Logger.Log($"Beginning score submission (token:{token.Value})...");
-
-            scoreSubmissionSource = new TaskCompletionSource<bool>();
            var request = CreateSubmissionRequest(score, token.Value);

            request.Success += s =>
@@ -19,6 +19,7 @@ using osu.Game.Graphics.Sprites;
 using osuTK;
 using osuTK.Graphics;
 using osu.Game.Input.Bindings;
+using osu.Game.Utils;

 namespace osu.Game.Screens.Select
 {
@@ -87,12 +88,11 @@ namespace osu.Game.Screens.Select
        private void updateMultiplierText() => Schedule(() =>
        {
            double multiplier = Current.Value?.Aggregate(1.0, (current, mod) => current * mod.ScoreMultiplier) ?? 1;
+            MultiplierText.Text = multiplier == 1 ? string.Empty : ModUtils.FormatScoreMultiplier(multiplier);

-            MultiplierText.Text = multiplier.Equals(1.0) ? string.Empty : $"{multiplier:N2}x";
-
-            if (multiplier > 1.0)
+            if (multiplier > 1)
                MultiplierText.FadeColour(highMultiplierColour, 200);
-            else if (multiplier < 1.0)
+            else if (multiplier < 1)
                MultiplierText.FadeColour(lowMultiplierColour, 200);
            else
                MultiplierText.FadeColour(Color4.White, 200);
@@ -132,8 +132,8 @@ namespace osu.Game.Tests.Beatmaps
        public AudioManager AudioManager => Audio;
        public IResourceStore<byte[]> Files => userSkinResourceStore;
        public new IResourceStore<byte[]> Resources => base.Resources;
-        public IResourceStore<TextureUpload> CreateTextureLoaderStore(IResourceStore<byte[]> underlyingStore) => null;
-        RealmAccess IStorageResourceProvider.RealmAccess => null;
+        public IResourceStore<TextureUpload> CreateTextureLoaderStore(IResourceStore<byte[]> underlyingStore) => null!;
+        RealmAccess IStorageResourceProvider.RealmAccess => null!;

        #endregion

@@ -5,6 +5,8 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using osu.Framework.Extensions.LocalisationExtensions;
+using osu.Framework.Localisation;
 using osu.Game.Online.API;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
@@ -226,5 +228,21 @@ namespace osu.Game.Utils

            return proposedWereValid;
        }
+
+        /// <summary>
+        /// Given a value of a score multiplier, returns a string version with special handling for a value near 1.00x.
+        /// </summary>
+        /// <param name="scoreMultiplier">The value of the score multiplier.</param>
+        /// <returns>A formatted score multiplier with a trailing "x" symbol</returns>
+        public static LocalisableString FormatScoreMultiplier(double scoreMultiplier)
+        {
+            // Round multiplier values away from 1.00x to two significant digits.
+            if (scoreMultiplier > 1)
+                scoreMultiplier = Math.Ceiling(Math.Round(scoreMultiplier * 100, 12)) / 100;
+            else
+                scoreMultiplier = Math.Floor(Math.Round(scoreMultiplier * 100, 12)) / 100;
+
+            return scoreMultiplier.ToLocalisableString("0.00x");
+        }
    }
 }