diff --git a/Raylib-cs/Easings.cs b/Raylib-cs/Easings.cs
deleted file mode 100644
index 89d14a3..0000000
--- a/Raylib-cs/Easings.cs
+++ /dev/null
@@ -1,264 +0,0 @@
-using System;
-
-namespace Raylib_cs
-{
-    public static class Easings
-    {
-        // Linear Easing functions
-        public static float EaseLinearNone(float t, float b, float c, float d)
-        {
-            return (c * t / d + b);
-        }
-
-        public static float EaseLinearIn(float t, float b, float c, float d)
-        {
-            return (c * t / d + b);
-        }
-
-        public static float EaseLinearOut(float t, float b, float c, float d)
-        {
-            return (c * t / d + b);
-        }
-
-        public static float EaseLinearInOut(float t, float b, float c, float d)
-        {
-            return (c * t / d + b);
-        }
-
-        // Sine Easing functions
-        public static float EaseSineIn(float t, float b, float c, float d)
-        {
-            return (-c * MathF.Cos(t / d * (MathF.PI / 2)) + c + b);
-        }
-
-        public static float EaseSineOut(float t, float b, float c, float d)
-        {
-            return (c * MathF.Sin(t / d * (MathF.PI / 2)) + b);
-        }
-
-        public static float EaseSineInOut(float t, float b, float c, float d)
-        {
-            return (-c / 2 * (MathF.Cos(MathF.PI * t / d) - 1) + b);
-        }
-
-        // Circular Easing functions
-        public static float EaseCircIn(float t, float b, float c, float d)
-        {
-            return (-c * (MathF.Sqrt(1 - (t /= d) * t) - 1) + b);
-        }
-
-        public static float EaseCircOut(float t, float b, float c, float d)
-        {
-            return (c * MathF.Sqrt(1 - (t = t / d - 1) * t) + b);
-        }
-
-        public static float EaseCircInOut(float t, float b, float c, float d)
-        {
-            if ((t /= d / 2) < 1)
-            {
-                return (-c / 2 * (MathF.Sqrt(1 - t * t) - 1) + b);
-            }
-            return (c / 2 * (MathF.Sqrt(1 - t * (t -= 2)) + 1) + b);
-        }
-
-        // Cubic Easing functions
-        public static float EaseCubicIn(float t, float b, float c, float d)
-        {
-            return (c * (t /= d) * t * t + b);
-        }
-
-        public static float EaseCubicOut(float t, float b, float c, float d)
-        {
-            return (c * ((t = t / d - 1) * t * t + 1) + b);
-        }
-
-        public static float EaseCubicInOut(float t, float b, float c, float d)
-        {
-            if ((t /= d / 2) < 1)
-            {
-                return (c / 2 * t * t * t + b);
-            }
-            return (c / 2 * ((t -= 2) * t * t + 2) + b);
-        }
-
-        // Quadratic Easing functions
-        public static float EaseQuadIn(float t, float b, float c, float d)
-        {
-            return (c * (t /= d) * t + b);
-        }
-
-        public static float EaseQuadOut(float t, float b, float c, float d)
-        {
-            return (-c * (t /= d) * (t - 2) + b);
-        }
-
-        public static float EaseQuadInOut(float t, float b, float c, float d)
-        {
-            if ((t /= d / 2) < 1)
-            {
-                return (((c / 2) * (t * t)) + b);
-            }
-            return (-c / 2 * (((t - 2) * (--t)) - 1) + b);
-        }
-
-        // Exponential Easing functions
-        public static float EaseExpoIn(float t, float b, float c, float d)
-        {
-            return (t == 0) ? b : (c * MathF.Pow(2, 10 * (t / d - 1)) + b);
-        }
-
-        public static float EaseExpoOut(float t, float b, float c, float d)
-        {
-            return (t == d) ? (b + c) : (c * (-MathF.Pow(2, -10 * t / d) + 1) + b);
-        }
-
-        public static float EaseExpoInOut(float t, float b, float c, float d)
-        {
-            if (t == 0)
-            {
-                return b;
-            }
-            if (t == d)
-            {
-                return (b + c);
-            }
-            if ((t /= d / 2) < 1)
-            {
-                return (c / 2 * MathF.Pow(2, 10 * (t - 1)) + b);
-            }
-            return (c / 2 * (-MathF.Pow(2, -10 * --t) + 2) + b);
-        }
-
-        // Back Easing functions
-        public static float EaseBackIn(float t, float b, float c, float d)
-        {
-            float s = 1.70158f;
-            float postFix = t /= d;
-            return (c * (postFix) * t * ((s + 1) * t - s) + b);
-        }
-
-        public static float EaseBackOut(float t, float b, float c, float d)
-        {
-            float s = 1.70158f;
-            return (c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b);
-        }
-
-        public static float EaseBackInOut(float t, float b, float c, float d)
-        {
-            float s = 1.70158f;
-            if ((t /= d / 2) < 1)
-            {
-                return (c / 2 * (t * t * (((s *= (1.525f)) + 1) * t - s)) + b);
-            }
-
-            float postFix = t -= 2;
-            return (c / 2 * ((postFix) * t * (((s *= (1.525f)) + 1) * t + s) + 2) + b);
-        }
-
-        // Bounce Easing functions
-        public static float EaseBounceOut(float t, float b, float c, float d)
-        {
-            if ((t /= d) < (1 / 2.75f))
-            {
-                return (c * (7.5625f * t * t) + b);
-            }
-            else if (t < (2 / 2.75f))
-            {
-                float postFix = t -= (1.5f / 2.75f);
-                return (c * (7.5625f * (postFix) * t + 0.75f) + b);
-            }
-            else if (t < (2.5 / 2.75))
-            {
-                float postFix = t -= (2.25f / 2.75f);
-                return (c * (7.5625f * (postFix) * t + 0.9375f) + b);
-            }
-            else
-            {
-                float postFix = t -= (2.625f / 2.75f);
-                return (c * (7.5625f * (postFix) * t + 0.984375f) + b);
-            }
-        }
-
-        public static float EaseBounceIn(float t, float b, float c, float d)
-        {
-            return (c - EaseBounceOut(d - t, 0, c, d) + b);
-        }
-
-        public static float EaseBounceInOut(float t, float b, float c, float d)
-        {
-            if (t < d / 2)
-            {
-                return (EaseBounceIn(t * 2, 0, c, d) * 0.5f + b);
-            }
-            else
-            {
-                return (EaseBounceOut(t * 2 - d, 0, c, d) * 0.5f + c * 0.5f + b);
-            }
-        }
-
-        // Elastic Easing functions
-        public static float EaseElasticIn(float t, float b, float c, float d)
-        {
-            if (t == 0)
-            {
-                return b;
-            }
-            if ((t /= d) == 1)
-            {
-                return (b + c);
-            }
-
-            float p = d * 0.3f;
-            float a = c;
-            float s = p / 4;
-            float postFix = a * MathF.Pow(2, 10 * (t -= 1));
-
-            return (-(postFix * MathF.Sin((t * d - s) * (2 * MathF.PI) / p)) + b);
-        }
-
-        public static float EaseElasticOut(float t, float b, float c, float d)
-        {
-            if (t == 0)
-            {
-                return b;
-            }
-            if ((t /= d) == 1)
-            {
-                return (b + c);
-            }
-
-            float p = d * 0.3f;
-            float a = c;
-            float s = p / 4;
-
-            return (a * MathF.Pow(2, -10 * t) * MathF.Sin((t * d - s) * (2 * MathF.PI) / p) + c + b);
-        }
-
-        public static float EaseElasticInOut(float t, float b, float c, float d)
-        {
-            if (t == 0)
-            {
-                return b;
-            }
-            if ((t /= d / 2) == 2)
-            {
-                return (b + c);
-            }
-
-            float p = d * (0.3f * 1.5f);
-            float a = c;
-            float s = p / 4;
-
-            float postFix = 0f;
-            if (t < 1)
-            {
-                postFix = a * MathF.Pow(2, 10 * (t -= 1));
-                return -0.5f * (postFix * MathF.Sin((t * d - s) * (2 * MathF.PI) / p)) + b;
-            }
-
-            postFix = a * MathF.Pow(2, -10 * (t -= 1));
-
-            return (postFix * MathF.Sin((t * d - s) * (2 * MathF.PI) / p) * 0.5f + c + b);
-        }
-    }
-}