From 8c7bfc0f607988d7fe788d7695c817efad37fea5 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 19 May 2026 17:47:28 +0000
Subject: [PATCH 1/4] perf: bump framework to 2026.519.1 and apply
 System.Numerics hot-path optimizations

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/c0af79df-8006-4631-912e-eef9cc6d726b

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>
---
 osu.Android.props                                             | 2 +-
 .../Difficulty/Preprocessing/OsuDifficultyHitObject.cs        | 2 +-
 osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs | 2 +-
 osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerDisc.cs      | 4 ++--
 .../Skinning/Argon/ArgonSpinnerProgressArc.cs                 | 4 ++--
 osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerRingArc.cs   | 4 ++--
 osu.Game.Rulesets.Osu/Skinning/Default/DefaultSpinnerDisc.cs  | 4 ++--
 osu.Game/osu.Game.csproj                                      | 4 ++--
 osu.iOS.props                                                 | 2 +-
 9 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/osu.Android.props b/osu.Android.props
index b38e5b7eea5c..bad6fd6c2ba8 100644
--- a/osu.Android.props
+++ b/osu.Android.props
@@ -52,7 +52,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.517.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.519.1" />
     <!-- `ppy.osu.Framework.NativeLibs` is a transitive dependency of `ppy.osu.Framework`
          that ships desktop-only natives (Linux/macOS/Windows) under `runtimes/<rid>/native/`
          — including a bare Linux `libbass.so`/`libbass_fx.so`/`libbassmix.so` for linux-arm64.
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs b/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
index 67d12b3d1225..c9e09ff7a204 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
@@ -335,7 +335,7 @@ private void computeSliderCursorPosition()
                     // This code is designed to prevent buffing situations where lazy end is actually a less efficient movement.
                     Vector2 lazyMovement = Vector2.Subtract((Vector2)LazyEndPosition, currCursorPosition);
 
-                    if (lazyMovement.Length() < currMovement.Length())
+                    if (lazyMovement.LengthSquared() < currMovement.LengthSquared())
                         currMovement = lazyMovement;
 
                     currMovementLength = scalingFactor * currMovement.Length();
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs
index 25e5f2fd2c66..7888626d9bdb 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs
@@ -72,7 +72,7 @@ public void UpdateProgress(double completionProgress)
 
             // Ensure the value is substantially high enough to allow for Atan2 to get a valid angle.
             // Needed for when near completion, or in case of a very short slider.
-            if (diff.Length() < 0.01f)
+            if (diff.LengthSquared() < 0.0001f)
                 return;
 
             ball.Rotation = -90 + (float)(-Math.Atan2(diff.X, diff.Y) * 180 / Math.PI);
diff --git a/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerDisc.cs b/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerDisc.cs
index a83e54ff1081..4642f2ca57ac 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerDisc.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerDisc.cs
@@ -205,7 +205,7 @@ protected override void Update()
             else
             {
                 trackingElementInterpolation =
-                    (float)Interpolation.Damp(trackingElementInterpolation, drawableSpinner.RotationTracker.Tracking ? 1 : 0, 0.985f, (float)Math.Abs(Clock.ElapsedFrameTime));
+                    (float)Interpolation.Damp(trackingElementInterpolation, drawableSpinner.RotationTracker.Tracking ? 1 : 0, 0.985f, MathF.Abs((float)Clock.ElapsedFrameTime));
 
                 fill.Alpha = trackingElementInterpolation * (tracking_alpha - idle_alpha) + idle_alpha;
                 centre.Size = new Vector2(trackingElementInterpolation * (tracking_centre_size - idle_centre_size) + idle_centre_size);
@@ -214,7 +214,7 @@ protected override void Update()
             const float initial_fill_scale = 0.1f;
             float targetScale = initial_fill_scale + (0.98f - initial_fill_scale) * drawableSpinner.Progress;
 
-            fill.Scale = new Vector2((float)Interpolation.Lerp(fill.Scale.X, targetScale, Math.Clamp(Math.Abs(Time.Elapsed) / 100, 0, 1)));
+            fill.Scale = new Vector2((float)Interpolation.Lerp(fill.Scale.X, targetScale, Math.Clamp(MathF.Abs((float)Time.Elapsed) / 100f, 0f, 1f)));
             ticks.Rotation = drawableSpinner.RotationTracker.Rotation;
         }
 
diff --git a/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerProgressArc.cs b/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerProgressArc.cs
index e3246d33311c..e62f5d52a712 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerProgressArc.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerProgressArc.cs
@@ -68,8 +68,8 @@ protected override void Update()
 
             background.Alpha = spinner.Progress >= 1 ? 0 : 1;
 
-            fill.Alpha = (float)Interpolation.DampContinuously(fill.Alpha, spinner.Progress > 0 && spinner.Progress < 1 ? 1 : 0, 40f, (float)Math.Abs(Time.Elapsed));
-            fill.Progress = (float)Interpolation.DampContinuously(fill.Progress, spinner.Progress >= 1 ? 0 : arc_fill * spinner.Progress, 40f, (float)Math.Abs(Time.Elapsed));
+            fill.Alpha = (float)Interpolation.DampContinuously(fill.Alpha, spinner.Progress > 0 && spinner.Progress < 1 ? 1 : 0, 40f, MathF.Abs((float)Time.Elapsed));
+            fill.Progress = (float)Interpolation.DampContinuously(fill.Progress, spinner.Progress >= 1 ? 0 : arc_fill * spinner.Progress, 40f, MathF.Abs((float)Time.Elapsed));
 
             fill.Rotation = (float)(90 - fill.Progress * 180);
         }
diff --git a/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerRingArc.cs b/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerRingArc.cs
index 12cd0994b475..676fae4ace80 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerRingArc.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Argon/ArgonSpinnerRingArc.cs
@@ -44,8 +44,8 @@ protected override void Update()
         {
             base.Update();
 
-            fill.Progress = (float)Interpolation.DampContinuously(fill.Progress, spinner.Progress >= 1 ? arc_fill_complete : arc_fill, 40f, (float)Math.Abs(Time.Elapsed));
-            fill.InnerRadius = (float)Interpolation.DampContinuously(fill.InnerRadius, spinner.Progress >= 1 ? arc_radius * 2.2f : arc_radius, 40f, (float)Math.Abs(Time.Elapsed));
+            fill.Progress = (float)Interpolation.DampContinuously(fill.Progress, spinner.Progress >= 1 ? arc_fill_complete : arc_fill, 40f, MathF.Abs((float)Time.Elapsed));
+            fill.InnerRadius = (float)Interpolation.DampContinuously(fill.InnerRadius, spinner.Progress >= 1 ? arc_radius * 2.2f : arc_radius, 40f, MathF.Abs((float)Time.Elapsed));
 
             fill.Rotation = (float)(-fill.Progress * 180);
         }
diff --git a/osu.Game.Rulesets.Osu/Skinning/Default/DefaultSpinnerDisc.cs b/osu.Game.Rulesets.Osu/Skinning/Default/DefaultSpinnerDisc.cs
index 478678f4c0f9..f857fb34676b 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Default/DefaultSpinnerDisc.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Default/DefaultSpinnerDisc.cs
@@ -112,13 +112,13 @@ protected override void Update()
             }
             else
             {
-                fill.Alpha = (float)Interpolation.Damp(fill.Alpha, drawableSpinner.RotationTracker.Tracking ? tracking_alpha : idle_alpha, 0.98f, (float)Math.Abs(Clock.ElapsedFrameTime));
+                fill.Alpha = (float)Interpolation.Damp(fill.Alpha, drawableSpinner.RotationTracker.Tracking ? tracking_alpha : idle_alpha, 0.98f, MathF.Abs((float)Clock.ElapsedFrameTime));
             }
 
             const float initial_fill_scale = 0.2f;
             float targetScale = initial_fill_scale + (1 - initial_fill_scale) * drawableSpinner.Progress;
 
-            fill.Scale = new Vector2((float)Interpolation.Lerp(fill.Scale.X, targetScale, Math.Clamp(Math.Abs(Time.Elapsed) / 100, 0, 1)));
+            fill.Scale = new Vector2((float)Interpolation.Lerp(fill.Scale.X, targetScale, Math.Clamp(MathF.Abs((float)Time.Elapsed) / 100f, 0f, 1f)));
             mainContainer.Rotation = drawableSpinner.RotationTracker.Rotation;
         }
 
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index 349b0fa86ef4..30a42f4732c4 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -38,10 +38,10 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Realm" Version="20.1.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2026.517.1" />
+    <PackageReference Include="ppy.osu.Framework" Version="2026.519.1" />
     <!--
       Explicitly pin `ppy.Veldrid.SPIRV` to the winnerspiros fork build that
-      `ppy.osu.Framework 2026.517.1` was compiled against. This version is the only
+      `ppy.osu.Framework 2026.519.1` was compiled against. This version is the only
       one whose `runtimes/android-arm64/native/libveldrid-spirv.so` is aligned to 16 KB
       pages (required by Android 16+). It lives only as a release asset on
       <https://github.com/winnerspiros/veldrid-spirv/releases/tag/1.0> and is vendored
diff --git a/osu.iOS.props b/osu.iOS.props
index 0daf92271a71..c9917bf84db5 100644
--- a/osu.iOS.props
+++ b/osu.iOS.props
@@ -33,6 +33,6 @@
     <SuppressTrimAnalysisWarnings>true</SuppressTrimAnalysisWarnings>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2026.517.1" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2026.519.1" />
   </ItemGroup>
 </Project>

From e73c3c9ce345f1de8078273e3217b24c5fe44274 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 19 May 2026 18:09:09 +0000
Subject: [PATCH 2/4] perf: deep System.Numerics hot-path optimization pass (28
 files)

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/f74b2f21-6bd8-45e8-b698-3737ddf65ed7

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>
---
 .../Edit/Blueprints/FruitPlacementBlueprint.cs         |  2 +-
 .../Edit/Blueprints/JuiceStreamPlacementBlueprint.cs   |  2 +-
 .../Edit/CatchBlueprintContainer.cs                    |  2 +-
 .../Edit/Blueprints/GridPlacementBlueprint.cs          |  2 +-
 osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapProvider.cs  |  2 +-
 osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs     |  4 ++--
 osu.Game.Rulesets.Osu/Mods/OsuModRandom.cs             |  2 +-
 osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs     |  3 ++-
 osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs             |  4 ++--
 .../Drawables/Connections/FollowPointConnection.cs     |  2 +-
 .../Objects/Drawables/DrawableSliderBall.cs            |  2 +-
 osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs      |  4 ++--
 osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs  |  2 +-
 .../Skinning/Default/SpinnerCentreLayer.cs             |  3 +--
 .../Skinning/Legacy/LegacyCursorTrail.cs               |  2 +-
 osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs         | 10 +++++-----
 osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs    |  3 ++-
 .../Skinning/Legacy/LegacyKiaiGlow.cs                  |  4 ++--
 .../Legacy/TaikoLegacyPlayfieldBackgroundRight.cs      |  4 ++--
 osu.Game/Graphics/Backgrounds/Triangles.cs             |  2 +-
 osu.Game/Graphics/Backgrounds/TrianglesV2.cs           |  2 +-
 osu.Game/Graphics/Cursor/MenuCursorContainer.cs        |  2 +-
 osu.Game/Graphics/ParticleSpewer.cs                    |  7 +++----
 osu.Game/Overlays/MedalAnimation.cs                    |  2 +-
 osu.Game/Overlays/Notifications/Notification.cs        |  3 ++-
 osu.Game/Overlays/NowPlayingOverlay.cs                 |  3 ++-
 osu.Game/Rulesets/Objects/BezierConverter.cs           |  7 +++++--
 osu.Game/Screens/Menu/OsuLogo.cs                       |  3 ++-
 .../OnlinePlay/Matchmaking/Queue/CloudVisualisation.cs |  2 +-
 .../RankedPlay/Card/SongPreviewParticleContainer.cs    |  2 +-
 .../Matchmaking/RankedPlay/Intro/StarRatingSequence.cs |  6 ++++--
 osu.Game/Screens/Play/HUD/ArgonSongProgressBar.cs      |  2 +-
 osu.Game/Seasonal/IntroChristmas.cs                    |  8 ++++----
 33 files changed, 59 insertions(+), 51 deletions(-)

diff --git a/osu.Game.Rulesets.Catch/Edit/Blueprints/FruitPlacementBlueprint.cs b/osu.Game.Rulesets.Catch/Edit/Blueprints/FruitPlacementBlueprint.cs
index 14900758fb84..6cee6730c604 100644
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/FruitPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/FruitPlacementBlueprint.cs
@@ -48,7 +48,7 @@ public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, do
             gridSnapResult.ScreenSpacePosition.X = screenSpacePosition.X;
             var distanceSnapResult = Composer?.TryDistanceSnap(gridSnapResult.ScreenSpacePosition);
 
-            var result = distanceSnapResult != null && Vector2.Distance(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
+            var result = distanceSnapResult != null && Vector2.DistanceSquared(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS * CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
                 ? distanceSnapResult
                 : gridSnapResult;
 
diff --git a/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs b/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs
index 1486f13f0bb2..480ef44a859d 100644
--- a/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Catch/Edit/Blueprints/JuiceStreamPlacementBlueprint.cs
@@ -88,7 +88,7 @@ public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, do
             gridSnapResult.ScreenSpacePosition.X = screenSpacePosition.X;
             var distanceSnapResult = Composer?.TryDistanceSnap(gridSnapResult.ScreenSpacePosition);
 
-            var result = distanceSnapResult != null && Vector2.Distance(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
+            var result = distanceSnapResult != null && Vector2.DistanceSquared(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS * CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
                 ? distanceSnapResult
                 : gridSnapResult;
 
diff --git a/osu.Game.Rulesets.Catch/Edit/CatchBlueprintContainer.cs b/osu.Game.Rulesets.Catch/Edit/CatchBlueprintContainer.cs
index d5fd93d3eff1..b56e41ee5056 100644
--- a/osu.Game.Rulesets.Catch/Edit/CatchBlueprintContainer.cs
+++ b/osu.Game.Rulesets.Catch/Edit/CatchBlueprintContainer.cs
@@ -55,7 +55,7 @@ protected override bool TryMoveBlueprints(DragEvent e, IList<(SelectionBlueprint
             gridSnapResult.ScreenSpacePosition.X = movePosition.X;
             var distanceSnapResult = Composer.TryDistanceSnap(gridSnapResult.ScreenSpacePosition);
 
-            var result = distanceSnapResult != null && Vector2.Distance(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
+            var result = distanceSnapResult != null && Vector2.DistanceSquared(gridSnapResult.ScreenSpacePosition, distanceSnapResult.ScreenSpacePosition) < CatchHitObjectComposer.DISTANCE_SNAP_RADIUS * CatchHitObjectComposer.DISTANCE_SNAP_RADIUS
                 ? distanceSnapResult
                 : gridSnapResult;
 
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/GridPlacementBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/GridPlacementBlueprint.cs
index 4935e0d96590..e1a3d83ccc4d 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/GridPlacementBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/GridPlacementBlueprint.cs
@@ -110,7 +110,7 @@ public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, do
             else
             {
                 // Default to the original spacing and rotation if the distance is too small.
-                if (Vector2.Distance(gridToolboxGroup.StartPosition.Value, pos) < 2)
+                if (Vector2.DistanceSquared(gridToolboxGroup.StartPosition.Value, pos) < 4)
                 {
                     gridToolboxGroup.GridLineSpacing.Value = originalSpacing;
                     if (!gridToolboxGroup.GridLinesRotation.Disabled)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapProvider.cs b/osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapProvider.cs
index f046f815be72..8c435aaa7c57 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapProvider.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapProvider.cs
@@ -19,7 +19,7 @@ public override double ReadCurrentDistanceSnap(HitObject before, HitObject after
         {
             // If the pair of hit objects in question here could feasibly be on the same stack, do not provide a distance snap value -
             // they're likely too close to one another for the distance snap value to be useful anyway even if they somehow are not.
-            if (Vector2.Distance(((OsuHitObject)before).EndPosition, ((OsuHitObject)after).Position) < OsuBeatmapProcessor.STACK_DISTANCE)
+            if (Vector2.DistanceSquared(((OsuHitObject)before).EndPosition, ((OsuHitObject)after).Position) < OsuBeatmapProcessor.STACK_DISTANCE * OsuBeatmapProcessor.STACK_DISTANCE)
                 return 0;
 
             var lastObjectWithVelocity = EditorBeatmap.HitObjects.TakeWhile(ho => ho != after).OfType<IHasSliderVelocity>().LastOrDefault();
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
index 41d3466cbc7a..b178191ddaed 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
@@ -309,9 +309,9 @@ private bool snapToVisibleBlueprints(Vector2 screenSpacePosition, out SnapResult
                 if (!snapPositions.Any())
                     continue;
 
-                var closestSnapPosition = snapPositions.MinBy(p => Vector2.Distance(p, screenSpacePosition));
+                var closestSnapPosition = snapPositions.MinBy(p => Vector2.DistanceSquared(p, screenSpacePosition));
 
-                if (Vector2.Distance(closestSnapPosition, screenSpacePosition) < snapRadius)
+                if (Vector2.DistanceSquared(closestSnapPosition, screenSpacePosition) < snapRadius * snapRadius)
                 {
                     // if the snap target is a stacked object, snap to its unstacked position rather than its stacked position.
                     // this is intended to make working with stacks easier (because thanks to this, you can drag an object to any
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModRandom.cs b/osu.Game.Rulesets.Osu/Mods/OsuModRandom.cs
index 690e8c73865c..490612d1ac88 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModRandom.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModRandom.cs
@@ -129,7 +129,7 @@ private float getRelativeTargetAngle(float targetDistance, float offset, bool fl
             float angle = (float)(2.16 / (1 + 200 * Math.Exp(0.036 * (targetDistance - 310 + customOffsetX))) + 0.5);
             angle += offset + customOffsetY;
 
-            float relativeAngle = (float)Math.PI - angle;
+            float relativeAngle = MathF.PI - angle;
 
             return flowDirection ? -relativeAngle : relativeAngle;
         }
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs b/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
index 0a54f90ad4d1..530d51802a8d 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
@@ -450,7 +450,8 @@ private int nodeIndexFromTime(IHasRepeats curve, double timeSinceStart)
 
         private bool checkForOverlap(IEnumerable<OsuHitObject> objectsToCheck, OsuHitObject target)
         {
-            return objectsToCheck.Any(h => Vector2.Distance(h.Position, target.Position) < target.Radius * 2);
+            float radiusTwice = target.Radius * 2;
+            return objectsToCheck.Any(h => Vector2.DistanceSquared(h.Position, target.Position) < radiusTwice * radiusTwice);
         }
 
         /// <summary>
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs b/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
index d4ce6ae842a3..f92a9e9c4862 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
@@ -57,9 +57,9 @@ private void drawableOnApplyCustomUpdateState(DrawableHitObject drawable, ArmedS
 
             void wiggle()
             {
-                float nextAngle = (float)(objRand.NextDouble() * 2 * Math.PI);
+                float nextAngle = (float)(objRand.NextDouble() * 2) * MathF.PI;
                 float nextDist = (float)(objRand.NextDouble() * Strength.Value * 7);
-                drawable.MoveTo(new Vector2((float)(nextDist * Math.Cos(nextAngle) + origin.X), (float)(nextDist * Math.Sin(nextAngle) + origin.Y)), wiggle_duration);
+                drawable.MoveTo(new Vector2(nextDist * MathF.Cos(nextAngle) + origin.X, nextDist * MathF.Sin(nextAngle) + origin.Y), wiggle_duration);
             }
 
             for (int i = 0; i < amountWiggles; i++)
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs
index b9e68211e539..dd7e5f3e4a50 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs
@@ -62,7 +62,7 @@ private void scheduleRefresh() => Scheduler.AddOnce(() =>
 
             Vector2 distanceVector = endPosition - startPosition;
             int distance = (int)distanceVector.Length();
-            float rotation = (float)(Math.Atan2(distanceVector.Y, distanceVector.X) * (180 / Math.PI));
+            float rotation = MathF.Atan2(distanceVector.Y, distanceVector.X) * (180f / MathF.PI);
 
             double finalTransformEndTime = startTime;
 
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs
index 7888626d9bdb..4daf87de1c2d 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs
@@ -75,7 +75,7 @@ public void UpdateProgress(double completionProgress)
             if (diff.LengthSquared() < 0.0001f)
                 return;
 
-            ball.Rotation = -90 + (float)(-Math.Atan2(diff.X, diff.Y) * 180 / Math.PI);
+            ball.Rotation = -90 + -MathF.Atan2(diff.X, diff.Y) * (180f / MathF.PI);
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs b/osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs
index c3113adc6481..529523baf035 100644
--- a/osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs
+++ b/osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs
@@ -161,7 +161,7 @@ private void addHitObjectReplay(OsuHitObject h)
 
                 Vector2 spinCentreOffset = SPINNER_CENTRE - ((OsuReplayFrame)Frames[^1]).Position;
 
-                if (spinCentreOffset.Length() > SPIN_RADIUS)
+                if (spinCentreOffset.LengthSquared() > SPIN_RADIUS * SPIN_RADIUS)
                 {
                     // If moving in from the outside, don't ease out (default eases out). This means auto will "start" spinning immediately after moving into position.
                     easing = Easing.In;
@@ -215,7 +215,7 @@ private static void calcSpinnerStartPosAndDirection(Vector2 prevPos, out Vector2
                 // Move along the tangent line, now startPosition is at the tangent point.
                 startPosition = prevPos + spinCentreOffset;
             }
-            else if (spinCentreOffset.Length() > 0)
+            else if (spinCentreOffset.LengthSquared() > 0)
             {
                 // Previous cursor position was inside spin circle, set startPosition to the nearest point on spin circle.
                 startPosition = SPINNER_CENTRE - spinCentreOffset * (SPIN_RADIUS / spinCentreOffset.Length());
diff --git a/osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs b/osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs
index 3c58161189cf..ad44323350a2 100644
--- a/osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs
+++ b/osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs
@@ -115,7 +115,7 @@ protected int FindInsertionIndex(ReplayFrame frame)
 
         protected void AddFrameToReplay(ReplayFrame frame) => Frames.Insert(FindInsertionIndex(frame), frame);
 
-        protected static Vector2 CirclePosition(double t, double radius) => new Vector2((float)(Math.Cos(t) * radius), (float)(Math.Sin(t) * radius));
+        protected static Vector2 CirclePosition(double t, double radius) => new Vector2(MathF.Cos((float)t) * (float)radius, MathF.Sin((float)t) * (float)radius);
 
         #endregion
     }
diff --git a/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerCentreLayer.cs b/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerCentreLayer.cs
index 694fe4aa46ca..123ab6bd1ade 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerCentreLayer.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Default/SpinnerCentreLayer.cs
@@ -7,7 +7,6 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Utils;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -50,7 +49,7 @@ private void load(DrawableHitObject drawableHitObject)
         protected override void Update()
         {
             base.Update();
-            symbol.Rotation = (float)Interpolation.Lerp(symbol.Rotation, spinner.RotationTracker.Rotation / 2, Math.Clamp(Math.Abs(Time.Elapsed) / 40, 0, 1));
+            symbol.Rotation = float.Lerp(symbol.Rotation, spinner.RotationTracker.Rotation * 0.5f, (float)Math.Clamp(Math.Abs(Time.Elapsed) / 40, 0, 1));
         }
 
         private Colour4 accentColour;
diff --git a/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyCursorTrail.cs b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyCursorTrail.cs
index 871e4d6b69f3..2e5d6301d71b 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyCursorTrail.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacyCursorTrail.cs
@@ -65,7 +65,7 @@ private void load(OsuConfigManager config, ISkinSource skinSource)
 
         protected override bool InterpolateMovements => !DisjointTrail;
 
-        protected override float IntervalMultiplier => 1 / Math.Max(cursorSize.Value, 1);
+        protected override float IntervalMultiplier => 1f / MathF.Max(cursorSize.Value, 1f);
         protected override bool AvoidDrawingNearCursor => !DisjointTrail;
 
         protected override void Update()
diff --git a/osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs b/osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs
index e57b5b85d016..1bf1335276aa 100644
--- a/osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs
@@ -280,7 +280,7 @@ protected virtual Colour4 PointColour(SmokePoint point)
 
                 if (timeDoingFinalFadeOut > 0 && point.Time >= firstVisiblePointTimeAfterSmokeEnded)
                 {
-                    float fraction = Math.Clamp((float)(timeDoingFinalFadeOut / final_fade_out_duration), 0, 1);
+                    float fraction = MathF.Clamp((float)(timeDoingFinalFadeOut / final_fade_out_duration), 0, 1);
                     fraction = MathF.Pow(fraction, 5);
                     color = new Colour4(color.R, color.G, color.B, (1 - fraction) * re_fade_in_alpha);
                 }
@@ -290,7 +290,7 @@ protected virtual Colour4 PointColour(SmokePoint point)
 
                     if (timeDoingInitialFadeOut > 0)
                     {
-                        float fraction = Math.Clamp((float)(timeDoingInitialFadeOut / initial_fade_out_duration), 0, 1);
+                        float fraction = MathF.Clamp((float)(timeDoingInitialFadeOut / initial_fade_out_duration), 0, 1);
                         color = new Colour4(color.R, color.G, color.B, (1 - fraction) * initial_alpha);
                     }
 
@@ -300,7 +300,7 @@ protected virtual Colour4 PointColour(SmokePoint point)
 
                         if (timeDoingReFadeIn > 0)
                         {
-                            float fraction = Math.Clamp((float)(timeDoingReFadeIn / re_fade_in_duration), 0, 1);
+                            float fraction = MathF.Clamp((float)(timeDoingReFadeIn / re_fade_in_duration), 0, 1);
                             fraction = 1 - MathF.Pow(1 - fraction, 5);
                             color = new Colour4(color.R, color.G, color.B, fraction * (re_fade_in_alpha - color.A) + color.A);
                         }
@@ -313,7 +313,7 @@ protected virtual Colour4 PointColour(SmokePoint point)
             protected virtual float PointScale(SmokePoint point)
             {
                 double timeDoingScale = CurrentTime - point.Time;
-                float fraction = Math.Clamp((float)(timeDoingScale / scale_duration), 0, 1);
+                float fraction = MathF.Clamp((float)(timeDoingScale / scale_duration), 0, 1);
                 fraction = 1 - MathF.Pow(1 - fraction, 5);
                 return fraction * (final_scale - initial_scale) + initial_scale;
             }
@@ -321,7 +321,7 @@ protected virtual float PointScale(SmokePoint point)
             protected virtual Vector2 PointDirection(SmokePoint point, int index)
             {
                 double timeDoingRotation = CurrentTime - point.Time;
-                float fraction = Math.Clamp((float)(timeDoingRotation / rotation_duration), 0, 1);
+                float fraction = MathF.Clamp((float)(timeDoingRotation / rotation_duration), 0, 1);
                 fraction = 1 - MathF.Pow(1 - fraction, 5);
                 float angle = fraction * getRotation(index) + point.Angle;
 
diff --git a/osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs b/osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs
index f679462f378f..86617d441247 100644
--- a/osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs
+++ b/osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs
@@ -182,6 +182,7 @@ private void load()
 
             Vector2 centre = new Vector2(points_per_dimension) / 2;
             float innerRadius = centre.X * inner_portion;
+            float innerRadiusSq = innerRadius * innerRadius;
 
             Drawable[][] points = new Drawable[points_per_dimension][];
 
@@ -191,7 +192,7 @@ private void load()
 
                 for (int c = 0; c < points_per_dimension; c++)
                 {
-                    bool isHit = Vector2.Distance(new Vector2(c + 0.5f, r + 0.5f), centre) <= innerRadius;
+                    bool isHit = Vector2.DistanceSquared(new Vector2(c + 0.5f, r + 0.5f), centre) <= innerRadiusSq;
 
                     if (isHit)
                     {
diff --git a/osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyKiaiGlow.cs b/osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyKiaiGlow.cs
index 62829624e7a1..deed6497ed24 100644
--- a/osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyKiaiGlow.cs
+++ b/osu.Game.Rulesets.Taiko/Skinning/Legacy/LegacyKiaiGlow.cs
@@ -49,9 +49,9 @@ protected override void Update()
             base.Update();
 
             if (isKiaiActive)
-                sprite.Alpha = (float)Math.Min(1, sprite.Alpha + Math.Abs(Clock.ElapsedFrameTime) / 100f);
+                sprite.Alpha = MathF.Min(1f, sprite.Alpha + MathF.Abs((float)Clock.ElapsedFrameTime) / 100f);
             else
-                sprite.Alpha = (float)Math.Max(0, sprite.Alpha - Math.Abs(Clock.ElapsedFrameTime) / 600f);
+                sprite.Alpha = MathF.Max(0f, sprite.Alpha - MathF.Abs((float)Clock.ElapsedFrameTime) / 600f);
         }
 
         protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
diff --git a/osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacyPlayfieldBackgroundRight.cs b/osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacyPlayfieldBackgroundRight.cs
index 5d270574d4bf..87704f0baee8 100644
--- a/osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacyPlayfieldBackgroundRight.cs
+++ b/osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacyPlayfieldBackgroundRight.cs
@@ -47,9 +47,9 @@ protected override void Update()
             base.Update();
 
             if (isKiaiActive)
-                kiai.Alpha = (float)Math.Min(1, kiai.Alpha + Math.Abs(Clock.ElapsedFrameTime) / 200f);
+                kiai.Alpha = MathF.Min(1f, kiai.Alpha + MathF.Abs((float)Clock.ElapsedFrameTime) / 200f);
             else
-                kiai.Alpha = (float)Math.Max(0, kiai.Alpha - Math.Abs(Clock.ElapsedFrameTime) / 200f);
+                kiai.Alpha = MathF.Max(0f, kiai.Alpha - MathF.Abs((float)Clock.ElapsedFrameTime) / 200f);
         }
 
         protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, ChannelAmplitudes amplitudes)
diff --git a/osu.Game/Graphics/Backgrounds/Triangles.cs b/osu.Game/Graphics/Backgrounds/Triangles.cs
index 7678d762560e..32968c17edfc 100644
--- a/osu.Game/Graphics/Backgrounds/Triangles.cs
+++ b/osu.Game/Graphics/Backgrounds/Triangles.cs
@@ -243,7 +243,7 @@ protected virtual TriangleParticle CreateTriangle()
 
             float u1 = 1 - nextRandom(); //uniform(0,1] random floats
             float u2 = 1 - nextRandom();
-            float randStdNormal = (float)(Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2)); // random normal(0,1)
+            float randStdNormal = MathF.Sqrt(-2.0f * MathF.Log(u1)) * MathF.Sin(2.0f * MathF.PI * u2); // random normal(0,1)
             float scale = Math.Max(TriangleScale * (mean + std_dev * randStdNormal), 0.1f); // random normal(mean,stdDev^2)
 
             return new TriangleParticle { Scale = scale };
diff --git a/osu.Game/Graphics/Backgrounds/TrianglesV2.cs b/osu.Game/Graphics/Backgrounds/TrianglesV2.cs
index 7f3acc3172ef..b98702ff933d 100644
--- a/osu.Game/Graphics/Backgrounds/TrianglesV2.cs
+++ b/osu.Game/Graphics/Backgrounds/TrianglesV2.cs
@@ -180,7 +180,7 @@ protected virtual TriangleParticle CreateTriangle()
 
             float u1 = 1 - nextRandom(); //uniform(0,1] random floats
             float u2 = 1 - nextRandom();
-            float randStdNormal = (float)(Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2)); // random normal(0,1)
+            float randStdNormal = MathF.Sqrt(-2.0f * MathF.Log(u1)) * MathF.Sin(2.0f * MathF.PI * u2); // random normal(0,1)
             float speedMultiplier = Math.Max(mean + std_dev * randStdNormal, 0.1f); // random normal(mean,stdDev^2)
 
             return new TriangleParticle { SpeedMultiplier = speedMultiplier };
diff --git a/osu.Game/Graphics/Cursor/MenuCursorContainer.cs b/osu.Game/Graphics/Cursor/MenuCursorContainer.cs
index 9dbdf0bc7397..cf229ac10bae 100644
--- a/osu.Game/Graphics/Cursor/MenuCursorContainer.cs
+++ b/osu.Game/Graphics/Cursor/MenuCursorContainer.cs
@@ -131,7 +131,7 @@ protected override void Update()
             base.Update();
 
             if (dragRotationState != DragRotationState.NotDragging
-                && Vector2.Distance(positionMouseDown, lastMovePosition) > 60)
+                && Vector2.DistanceSquared(positionMouseDown, lastMovePosition) > 3600f)
             {
                 // make the rotation centre point floating.
                 positionMouseDown = Interpolation.ValueAt(0.04f, positionMouseDown, lastMovePosition, 0, Clock.ElapsedFrameTime);
diff --git a/osu.Game/Graphics/ParticleSpewer.cs b/osu.Game/Graphics/ParticleSpewer.cs
index 4f4427a26087..1592206608a3 100644
--- a/osu.Game/Graphics/ParticleSpewer.cs
+++ b/osu.Game/Graphics/ParticleSpewer.cs
@@ -11,7 +11,6 @@
 using osu.Framework.Graphics.Rendering;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Utils;
 using System.Numerics;
 
 namespace osu.Game.Graphics
@@ -230,9 +229,9 @@ protected struct FallingParticle
 
             public float AlphaAtTime(float timeSinceStart) => 1 - progressAtTime(timeSinceStart);
 
-            public float ScaleAtTime(float timeSinceStart) => (float)Interpolation.Lerp(1, EndScale, progressAtTime(timeSinceStart));
+            public float ScaleAtTime(float timeSinceStart) => float.Lerp(1f, EndScale, progressAtTime(timeSinceStart));
 
-            public float AngleAtTime(float timeSinceStart) => (float)Interpolation.Lerp(StartAngle, EndAngle, progressAtTime(timeSinceStart));
+            public float AngleAtTime(float timeSinceStart) => float.Lerp(StartAngle, EndAngle, progressAtTime(timeSinceStart));
 
             public Vector2 PositionAtTime(float timeSinceStart, float gravity, float maxDuration)
             {
@@ -242,7 +241,7 @@ public Vector2 PositionAtTime(float timeSinceStart, float gravity, float maxDura
                 return StartPosition + (Velocity + currentGravity) * timeSinceStart / maxDuration;
             }
 
-            private float progressAtTime(float timeSinceStart) => Math.Clamp(timeSinceStart / Duration, 0, 1);
+            private float progressAtTime(float timeSinceStart) => MathF.Clamp(timeSinceStart / Duration, 0, 1);
         }
     }
 }
diff --git a/osu.Game/Overlays/MedalAnimation.cs b/osu.Game/Overlays/MedalAnimation.cs
index 7365c3efe08a..ff44b0cb167e 100644
--- a/osu.Game/Overlays/MedalAnimation.cs
+++ b/osu.Game/Overlays/MedalAnimation.cs
@@ -283,7 +283,7 @@ private partial class MedalParticle : CircularContainer
         {
             private readonly float direction;
 
-            private Vector2 positionForOffset(float offset) => new Vector2((float)(offset * Math.Sin(direction)), (float)(offset * Math.Cos(direction)));
+            private Vector2 positionForOffset(float offset) => new Vector2(offset * MathF.Sin(direction), offset * MathF.Cos(direction));
 
             public MedalParticle(float direction)
             {
diff --git a/osu.Game/Overlays/Notifications/Notification.cs b/osu.Game/Overlays/Notifications/Notification.cs
index 5a65a295505b..439119c7df6d 100644
--- a/osu.Game/Overlays/Notifications/Notification.cs
+++ b/osu.Game/Overlays/Notifications/Notification.cs
@@ -316,7 +316,8 @@ protected override void OnDrag(DragEvent e)
                 Vector2 change = e.MousePosition - e.MouseDownPosition;
 
                 // Diminish the drag distance as we go further to simulate "rubber band" feeling.
-                change *= change.Length() <= 0 ? 0 : MathF.Pow(change.Length(), 0.8f) / change.Length();
+                float len = change.Length();
+                change *= len <= 0 ? 0 : MathF.Pow(len, -0.2f);
 
                 // Only apply Y change if dragging to the left.
                 if (change.X >= 0)
diff --git a/osu.Game/Overlays/NowPlayingOverlay.cs b/osu.Game/Overlays/NowPlayingOverlay.cs
index b787f8ae2665..c63099ef2c46 100644
--- a/osu.Game/Overlays/NowPlayingOverlay.cs
+++ b/osu.Game/Overlays/NowPlayingOverlay.cs
@@ -508,7 +508,8 @@ protected override void OnDrag(DragEvent e)
                 Vector2 change = e.MousePosition - e.MouseDownPosition;
 
                 // Diminish the drag distance as we go further to simulate "rubber band" feeling.
-                change *= change.Length() <= 0 ? 0 : MathF.Pow(change.Length(), 0.7f) / change.Length();
+                float len = change.Length();
+                change *= len <= 0 ? 0 : MathF.Pow(len, -0.3f);
 
                 this.MoveTo(change);
             }
diff --git a/osu.Game/Rulesets/Objects/BezierConverter.cs b/osu.Game/Rulesets/Objects/BezierConverter.cs
index 10404e4bd3ff..c923726bf2cd 100644
--- a/osu.Game/Rulesets/Objects/BezierConverter.cs
+++ b/osu.Game/Rulesets/Objects/BezierConverter.cs
@@ -242,11 +242,14 @@ public static Vector2[] ConvertCircleToBezierAnchors(ReadOnlySpan<Vector2> contr
             // Adjust rotation, radius, and position
             var result = new Vector2[arc.Length];
 
+            double cosTheta = Math.Cos(pr.ThetaStart);
+            double sinTheta = Math.Sin(pr.ThetaStart);
+
             for (int i = 0; i < arc.Length; i++)
             {
                 result[i] = new Vector2(
-                    (float)((Math.Cos(pr.ThetaStart) * arc[i].X + -Math.Sin(pr.ThetaStart) * pr.Direction * arc[i].Y) * pr.Radius + pr.Centre.X),
-                    (float)((Math.Sin(pr.ThetaStart) * arc[i].X + Math.Cos(pr.ThetaStart) * pr.Direction * arc[i].Y) * pr.Radius + pr.Centre.Y));
+                    (float)((cosTheta * arc[i].X + -sinTheta * pr.Direction * arc[i].Y) * pr.Radius + pr.Centre.X),
+                    (float)((sinTheta * arc[i].X + cosTheta * pr.Direction * arc[i].Y) * pr.Radius + pr.Centre.Y));
             }
 
             return result;
diff --git a/osu.Game/Screens/Menu/OsuLogo.cs b/osu.Game/Screens/Menu/OsuLogo.cs
index 5b8a1bbe1b3f..799702debd94 100644
--- a/osu.Game/Screens/Menu/OsuLogo.cs
+++ b/osu.Game/Screens/Menu/OsuLogo.cs
@@ -441,7 +441,8 @@ protected override void OnDrag(DragEvent e)
             Vector2 change = e.MousePosition - e.MouseDownPosition;
 
             // Diminish the drag distance as we go further to simulate "rubber band" feeling.
-            change *= change.Length() <= 0 ? 0 : MathF.Pow(change.Length(), 0.6f) / change.Length();
+            float len = change.Length();
+            change *= len <= 0 ? 0 : MathF.Pow(len, -0.4f);
 
             logoBounceContainer.MoveTo(change);
         }
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/CloudVisualisation.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/CloudVisualisation.cs
index be319c601b5f..d2186b95084c 100644
--- a/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/CloudVisualisation.cs
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/Queue/CloudVisualisation.cs
@@ -147,7 +147,7 @@ protected override void Update()
             {
                 base.Update();
 
-                float elapsed = (float)Math.Min(20, Time.Elapsed) / 1000;
+                float elapsed = MathF.Min(20f, (float)Time.Elapsed) / 1000f;
 
                 Scale = new Vector2((float)Interpolation.Lerp(Scale.X, targetScale, elapsed / 100));
                 Alpha = (float)Interpolation.Lerp(Alpha, targetAlpha, elapsed / 100);
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/RankedPlay/Card/SongPreviewParticleContainer.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/RankedPlay/Card/SongPreviewParticleContainer.cs
index fdb01d9f246b..fa4ff32fe4c7 100644
--- a/osu.Game/Screens/OnlinePlay/Matchmaking/RankedPlay/Card/SongPreviewParticleContainer.cs
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/RankedPlay/Card/SongPreviewParticleContainer.cs
@@ -120,7 +120,7 @@ protected override void Update()
             {
                 base.Update();
 
-                X = initialX + (float)Math.Cos(Time.Current * 0.002 + seed) * 5;
+                X = initialX + MathF.Cos((float)Time.Current * 0.002f + seed) * 5f;
                 Y -= (float)(Time.Elapsed * 0.04f);
             }
         }
diff --git a/osu.Game/Screens/OnlinePlay/Matchmaking/RankedPlay/Intro/StarRatingSequence.cs b/osu.Game/Screens/OnlinePlay/Matchmaking/RankedPlay/Intro/StarRatingSequence.cs
index 2847d974a6fd..b242b8a8e998 100644
--- a/osu.Game/Screens/OnlinePlay/Matchmaking/RankedPlay/Intro/StarRatingSequence.cs
+++ b/osu.Game/Screens/OnlinePlay/Matchmaking/RankedPlay/Intro/StarRatingSequence.cs
@@ -298,6 +298,8 @@ protected override void Update()
 
             const float min_alpha = 0.4f;
 
+            float expFactor = MathF.Exp(-0.01f * (float)Time.Elapsed);
+
             foreach (var bar in bars)
             {
                 float value = gaussianCurve(bar.StarRating, 1f, starRating, stdDev);
@@ -306,7 +308,7 @@ protected override void Update()
 
                 float targetAlpha = float.Clamp(min_alpha + value * 20f, min_alpha, 1);
 
-                bar.Alpha = float.Lerp(targetAlpha, bar.Alpha, (float)Math.Exp(-0.01f * Time.Elapsed));
+                bar.Alpha = float.Lerp(targetAlpha, bar.Alpha, expFactor);
             }
 
             foreach (var child in starContainer)
@@ -315,7 +317,7 @@ protected override void Update()
 
                 float targetAlpha = float.Clamp(min_alpha + value * 20f, min_alpha, 1);
 
-                child.Alpha = float.Lerp(targetAlpha, child.Alpha, (float)Math.Exp(-0.01f * Time.Elapsed));
+                child.Alpha = float.Lerp(targetAlpha, child.Alpha, expFactor);
             }
 
             static float gaussianCurve(float x, float amplitude, float center, float stdev)
diff --git a/osu.Game/Screens/Play/HUD/ArgonSongProgressBar.cs b/osu.Game/Screens/Play/HUD/ArgonSongProgressBar.cs
index abd97aabdd2f..94a3c0bff368 100644
--- a/osu.Game/Screens/Play/HUD/ArgonSongProgressBar.cs
+++ b/osu.Game/Screens/Play/HUD/ArgonSongProgressBar.cs
@@ -146,7 +146,7 @@ protected override void Update()
                 ChangeInternalChildDepth(audioBar, shouldBeBehind ? -1 : 1);
             }
 
-            float timeDelta = (float)Math.Abs(AudioTime - trackTime);
+            float timeDelta = MathF.Abs((float)(AudioTime - trackTime));
 
             const float colour_transition_threshold = 20000;
 
diff --git a/osu.Game/Seasonal/IntroChristmas.cs b/osu.Game/Seasonal/IntroChristmas.cs
index e8a879fcecf2..553bb9faa7a5 100644
--- a/osu.Game/Seasonal/IntroChristmas.cs
+++ b/osu.Game/Seasonal/IntroChristmas.cs
@@ -296,11 +296,11 @@ protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint,
 
                     for (int i = 0; i < (beatsHandled + 1); i++)
                     {
-                        float angle = (float)(RNG.NextDouble() * 2 * Math.PI);
-                        float randomRadius = (float)(Math.Sqrt(RNG.NextDouble()));
+                        float angle = (float)(RNG.NextDouble() * 2) * MathF.PI;
+                        float randomRadius = MathF.Sqrt((float)RNG.NextDouble());
 
-                        float x = 0.5f + 0.5f * randomRadius * (float)Math.Cos(angle);
-                        float y = 0.5f + 0.5f * randomRadius * (float)Math.Sin(angle);
+                        float x = 0.5f + 0.5f * randomRadius * MathF.Cos(angle);
+                        float y = 0.5f + 0.5f * randomRadius * MathF.Sin(angle);
 
                         Colour4 christmasColour = RNG.NextBool() ? SeasonalUIConfig.PRIMARY_COLOUR_1 : SeasonalUIConfig.PRIMARY_COLOUR_2;
 

From 083f8a72edae0ca200e9bd62a7b984c77bdca22b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 19 May 2026 18:30:58 +0000
Subject: [PATCH 3/4] =?UTF-8?q?fix:=20MathF.Clamp=20=E2=86=92=20float.Clam?=
 =?UTF-8?q?p=20in=20ParticleSpewer=20(MathF=20has=20no=20Clamp=20method)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/850e952a-f9d0-41e8-8029-923e55c58bcf

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>
---
 osu.Game/Graphics/ParticleSpewer.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osu.Game/Graphics/ParticleSpewer.cs b/osu.Game/Graphics/ParticleSpewer.cs
index 1592206608a3..3060615555c1 100644
--- a/osu.Game/Graphics/ParticleSpewer.cs
+++ b/osu.Game/Graphics/ParticleSpewer.cs
@@ -241,7 +241,7 @@ public Vector2 PositionAtTime(float timeSinceStart, float gravity, float maxDura
                 return StartPosition + (Velocity + currentGravity) * timeSinceStart / maxDuration;
             }
 
-            private float progressAtTime(float timeSinceStart) => MathF.Clamp(timeSinceStart / Duration, 0, 1);
+            private float progressAtTime(float timeSinceStart) => float.Clamp(timeSinceStart / Duration, 0, 1);
         }
     }
 }

From faa99f7f24ac9168efd169c0461cbfe647a467b8 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 19 May 2026 18:49:24 +0000
Subject: [PATCH 4/4] =?UTF-8?q?fix:=20MathF.Clamp=20=E2=86=92=20float.Clam?=
 =?UTF-8?q?p=20in=20SmokeSegment;=20fix=20double=E2=86=92float=20cast=20in?=
 =?UTF-8?q?=20OsuModTargetPractice?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/ce8f0232-7f26-43f2-bd5a-69bdb0e1b292

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>
---
 osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs |  2 +-
 osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs     | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs b/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
index 530d51802a8d..f860b982c8ad 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs
@@ -450,7 +450,7 @@ private int nodeIndexFromTime(IHasRepeats curve, double timeSinceStart)
 
         private bool checkForOverlap(IEnumerable<OsuHitObject> objectsToCheck, OsuHitObject target)
         {
-            float radiusTwice = target.Radius * 2;
+            float radiusTwice = (float)target.Radius * 2;
             return objectsToCheck.Any(h => Vector2.DistanceSquared(h.Position, target.Position) < radiusTwice * radiusTwice);
         }
 
diff --git a/osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs b/osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs
index 1bf1335276aa..74e74d1fa491 100644
--- a/osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/SmokeSegment.cs
@@ -280,7 +280,7 @@ protected virtual Colour4 PointColour(SmokePoint point)
 
                 if (timeDoingFinalFadeOut > 0 && point.Time >= firstVisiblePointTimeAfterSmokeEnded)
                 {
-                    float fraction = MathF.Clamp((float)(timeDoingFinalFadeOut / final_fade_out_duration), 0, 1);
+                    float fraction = float.Clamp((float)(timeDoingFinalFadeOut / final_fade_out_duration), 0, 1);
                     fraction = MathF.Pow(fraction, 5);
                     color = new Colour4(color.R, color.G, color.B, (1 - fraction) * re_fade_in_alpha);
                 }
@@ -290,7 +290,7 @@ protected virtual Colour4 PointColour(SmokePoint point)
 
                     if (timeDoingInitialFadeOut > 0)
                     {
-                        float fraction = MathF.Clamp((float)(timeDoingInitialFadeOut / initial_fade_out_duration), 0, 1);
+                        float fraction = float.Clamp((float)(timeDoingInitialFadeOut / initial_fade_out_duration), 0, 1);
                         color = new Colour4(color.R, color.G, color.B, (1 - fraction) * initial_alpha);
                     }
 
@@ -300,7 +300,7 @@ protected virtual Colour4 PointColour(SmokePoint point)
 
                         if (timeDoingReFadeIn > 0)
                         {
-                            float fraction = MathF.Clamp((float)(timeDoingReFadeIn / re_fade_in_duration), 0, 1);
+                            float fraction = float.Clamp((float)(timeDoingReFadeIn / re_fade_in_duration), 0, 1);
                             fraction = 1 - MathF.Pow(1 - fraction, 5);
                             color = new Colour4(color.R, color.G, color.B, fraction * (re_fade_in_alpha - color.A) + color.A);
                         }
@@ -313,7 +313,7 @@ protected virtual Colour4 PointColour(SmokePoint point)
             protected virtual float PointScale(SmokePoint point)
             {
                 double timeDoingScale = CurrentTime - point.Time;
-                float fraction = MathF.Clamp((float)(timeDoingScale / scale_duration), 0, 1);
+                float fraction = float.Clamp((float)(timeDoingScale / scale_duration), 0, 1);
                 fraction = 1 - MathF.Pow(1 - fraction, 5);
                 return fraction * (final_scale - initial_scale) + initial_scale;
             }
@@ -321,7 +321,7 @@ protected virtual float PointScale(SmokePoint point)
             protected virtual Vector2 PointDirection(SmokePoint point, int index)
             {
                 double timeDoingRotation = CurrentTime - point.Time;
-                float fraction = MathF.Clamp((float)(timeDoingRotation / rotation_duration), 0, 1);
+                float fraction = float.Clamp((float)(timeDoingRotation / rotation_duration), 0, 1);
                 fraction = 1 - MathF.Pow(1 - fraction, 5);
                 float angle = fraction * getRotation(index) + point.Angle;