diff --git a/Bindings/Easings.cs b/Bindings/Easings.cs
index 3c08916..e05dc0f 100644
--- a/Bindings/Easings.cs
+++ b/Bindings/Easings.cs
@@ -1,3 +1,11 @@
+/* Raylib-cs
+ * Easings.cs - Useful easing functions for values animation
+ * Copyright 2019 Chris Dill
+ *
+ * Release under zLib License.
+ * See LICENSE for details.
+ */
+
 using System;
 using System.Runtime.InteropServices;
 
@@ -6,96 +14,260 @@ namespace Raylib
     public static partial class Raylib
     {
         // Linear Easing functions
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseLinearNone(float t, float b, float c, float d);
+        public static float EaseLinearNone(float t, float b, float c, float d) 
+        { 
+            return (c * t / d + b);
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseLinearIn(float t, float b, float c, float d);
+        public static float EaseLinearIn(float t, float b, float c, float d) 
+        { 
+            return (c * t / d + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseLinearOut(float t, float b, float c, float d);
+        public static float EaseLinearOut(float t, float b, float c, float d) 
+        { 
+            return (c * t / d + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseLinearInOut(float t, float b, float c, float d);
+        public static float EaseLinearInOut(float t,float b, float c, float d) 
+        { 
+            return (c * t / d + b); 
+        }
 
         // Sine Easing functions
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseSineIn(float t, float b, float c, float d);
+        public static float EaseSineIn(float t, float b, float c, float d) 
+        { 
+            return (-c * (float)Math.Cos(t / d * ((float)Math.PI / 2)) + c + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseSineOut(float t, float b, float c, float d);
+        public static float EaseSineOut(float t, float b, float c, float d) 
+        { 
+            return (c * (float)Math.Sin(t / d * ((float)Math.PI / 2)) + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseSineInOut(float t, float b, float c, float d);
+        public static float EaseSineInOut(float t, float b, float c, float d) 
+        { 
+            return (-c / 2 * ((float)Math.Cos((float)Math.PI * t / d) - 1) + b); 
+        }
 
         // Circular Easing functions
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseCircIn(float t, float b, float c, float d);
+        public static float EaseCircIn(float t, float b, float c, float d) 
+        { 
+            return (-c * ((float)Math.Sqrt(1 - (t /= d) * t) - 1) + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseCircOut(float t, float b, float c, float d);
+        public static float EaseCircOut(float t, float b, float c, float d) 
+        { 
+            return (c * (float)Math.Sqrt(1 - (t = t / d - 1) * t) + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseCircInOut(float t, float b, float c, float d);
+        public static float EaseCircInOut(float t, float b, float c, float d) 
+        {
+            if ((t /= d / 2) < 1) 
+            {
+                return (-c / 2 * ((float)Math.Sqrt(1 - t * t) - 1) + b);
+            }
+            return (c / 2 * ((float)Math.Sqrt(1 - t * (t -= 2)) + 1) + b);
+        }
 
         // Cubic Easing functions
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseCubicIn(float t, float b, float c, float d);
+        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); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseCubicOut(float t, float b, float c, float d);
-
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseCubicInOut(float t, float b, float c, float d);
+        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
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseQuadIn(float t, float b, float c, float d);
+        public static float EaseQuadIn(float t, float b, float c, float d) 
+        { 
+            return (c * (t /= d) * t + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseQuadOut(float t, float b, float c, float d);
+        public static float EaseQuadOut(float t, float b, float c, float d) 
+        { 
+            return (-c * (t /= d) * (t - 2) + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseQuadInOut(float t, float b, float c, float d);
+        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
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseExpoIn(float t, float b, float c, float d);
+        public static float EaseExpoIn(float t, float b, float c, float d) 
+        { 
+            return (t == 0) ? b : (c * (float)Math.Pow(2, 10 * (t / d - 1)) + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseExpoOut(float t, float b, float c, float d);
-
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseExpoInOut(float t, float b, float c, float d);
+        public static float EaseExpoOut(float t, float b, float c, float d) 
+        { 
+            return (t == d) ? (b + c) : (c * (-(float)Math.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 * (float)Math.Pow(2, 10 * (t - 1)) + b);
+            }
+            return (c / 2 * (-(float)Math.Pow(2, -10 * --t) + 2) + b);
+        }
 
         // Back Easing functions
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseBackIn(float t, float b, float c, float d);
+        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);
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseBackOut(float t, float b, float c, float d);
+        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);
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseBackInOut(float t, float b, float c, float d);
+        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
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseBounceOut(float t, float b, float c, float d);
+        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);
+            }
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseBounceIn(float t, float b, float c, float d);
+        public static float EaseBounceIn(float t, float b, float c, float d) 
+        { 
+            return (c - EaseBounceOut(d - t, 0, c, d) + b); 
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseBounceInOut(float t, float b, float c, float d); 
+        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
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseElasticIn(float t, float b, float c, float d);
+        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 * (float)Math.Pow(2, 10 * (t -= 1));
+            
+            return (-(postFix * (float)Math.Sin((t * d - s)*(2 * (float)Math.PI) /p )) + b);
+        }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseElasticOut(float t, float b, float c, float d);
+        public static float EaseElasticOut(float t, float b, float c, float d)
+        {
+            if (t == 0) 
+            {
+                return b;
+            }
+            if ((t /= d) == 1) 
+            {
+                return (b + c);
+            }
 
-        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
-        public static extern float EaseElasticInOut(float t, float b, float c, float d); 
+            float p = d * 0.3f;
+            float a = c; 
+            float s = p / 4;
+            
+            return (a * (float)Math.Pow(2,-10 * t) * (float)Math.Sin((t * d - s) * (2 * (float)Math.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 * (float)Math.Pow(2, 10 * (t -= 1));
+                return -0.5f * (postFix * (float)Math.Sin((t * d - s) * (2 * (float)Math.PI) / p)) + b;
+            }
+            
+            postFix = a * (float)Math.Pow(2, -10 * (t -= 1));
+            
+            return (postFix * (float)Math.Sin((t * d  -s)*(2 * (float)Math.PI)/p) * 0.5f + c + b);
+        }
     }
 }
diff --git a/Bindings/Extensions.cs b/Bindings/Extensions.cs
index e76bea5..7df4dae 100644
--- a/Bindings/Extensions.cs
+++ b/Bindings/Extensions.cs
@@ -1,3 +1,11 @@
+/* Raylib-cs
+ * Extensions.cs - Extra features
+ * Copyright 2019 Chris Dill
+ *
+ * Release under zLib License.
+ * See LICENSE for details.
+ */
+
 using System;
 using System.Runtime.InteropServices;
 
diff --git a/Bindings/Raylib.cs b/Bindings/Raylib.cs
index 181f5f9..dd008c3 100644
--- a/Bindings/Raylib.cs
+++ b/Bindings/Raylib.cs
@@ -1,3 +1,11 @@
+/* Raylib-cs
+ * Raylib.cs - Core bindings to raylib
+ * Copyright 2019 Chris Dill
+ *
+ * Release under zLib License.
+ * See LICENSE for details.
+ */
+
 using System;
 using System.Runtime.InteropServices;
 using System.Security;
diff --git a/Bindings/Raymath.cs b/Bindings/Raymath.cs
index e0b2272..d93942a 100644
--- a/Bindings/Raymath.cs
+++ b/Bindings/Raymath.cs
@@ -1,3 +1,11 @@
+/* Raylib-cs
+ * Raymath.cs - Core bindings to raymth
+ * Copyright 2019 Chris Dill
+ *
+ * Release under zLib License.
+ * See LICENSE for details.
+ */
+
 using System;
 using System.Runtime.InteropServices;
 
diff --git a/Bindings/Rlgl.cs b/Bindings/Rlgl.cs
deleted file mode 100644
index 8927cab..0000000
--- a/Bindings/Rlgl.cs
+++ /dev/null
@@ -1,27 +0,0 @@
- // Rlgl - https://github.com/raysan5/raylib/blob/master/src/rlgl.h
-
-using System;
-using System.Runtime.InteropServices;
-
-namespace Raylib
-{
-    #region Raylib-cs Enums
-
-    #endregion
-
-    #region Raylib-cs Types
-
-
-    #endregion
-
-    public static partial class Raylib
-    {
-        #region Raylib-cs Variables
-
-        #endregion
-
-        #region Raylib-cs Functions
-
-        #endregion
-    }
-}
diff --git a/README.md b/README.md
index 47b3874..0bfc903 100644
--- a/README.md
+++ b/README.md
@@ -22,7 +22,7 @@ static class Program
 
 		while (!rl.WindowShouldClose())
 		{
-			rl.BeginDraw();
+			rl.BeginDrawing();
 
 			rl.ClearBackground(Color.WHITE);
 			rl.DrawText("Hello, world!", 12, 12, 20, Color.BLACK);