diff --git a/Source/OpenTK/Graphics/ES20/Helper.cs b/Source/OpenTK/Graphics/ES20/Helper.cs
index 7c62aac9..78c9ae4f 100644
--- a/Source/OpenTK/Graphics/ES20/Helper.cs
+++ b/Source/OpenTK/Graphics/ES20/Helper.cs
@@ -1,4 +1,31 @@
-using System;
+#region License
+//
+// The Open Toolkit Library License
+//
+// Copyright (c) 2006 - 2009 the Open Toolkit library.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights to 
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+#endregion
+
+using System;
 using System.Collections.Generic;
 using System.Text;
 
@@ -10,5 +37,348 @@ namespace OpenTK.Graphics.ES20
     public sealed partial class GL : GraphicsBindingsBase
     {
         const string Library = "libGLESv2.dll";
+
+        #region Helper Overloads
+
+#pragma warning disable 3019
+#pragma warning disable 1591
+#pragma warning disable 1572
+#pragma warning disable 1573
+
+        // Note: Mono 1.9.1 truncates StringBuilder results (for 'out string' parameters).
+        // We work around this issue by doubling the StringBuilder capacity.
+
+        #region public static void ClearColor() overloads
+
+        public static void ClearColor(System.Drawing.Color color)
+        {
+            GL.ClearColor(color.R / 255.0f, color.G / 255.0f, color.B / 255.0f, color.A / 255.0f);
+        }
+
+        public static void ClearColor(Color4 color)
+        {
+            GL.ClearColor(color.R, color.G, color.B, color.A);
+        }
+
+        #endregion
+
+        #region public static void BlendColor() overloads
+
+        public static void BlendColor(System.Drawing.Color color)
+        {
+            GL.BlendColor(color.R / 255.0f, color.G / 255.0f, color.B / 255.0f, color.A / 255.0f);
+        }
+
+        #endregion
+
+        #region Uniform
+
+        [CLSCompliant(false)]
+        public static void Uniform2(int location, ref Vector2 vector)
+        {
+            GL.Uniform2(location, vector.X, vector.Y);
+        }
+
+        [CLSCompliant(false)]
+        public static void Uniform3(int location, ref Vector3 vector)
+        {
+            GL.Uniform3(location, vector.X, vector.Y, vector.Z);
+        }
+
+        [CLSCompliant(false)]
+        public static void Uniform4(int location, ref Vector4 vector)
+        {
+            GL.Uniform4(location, vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        public static void Uniform2(int location, Vector2 vector)
+        {
+            GL.Uniform2(location, vector.X, vector.Y);
+        }
+
+        public static void Uniform3(int location, Vector3 vector)
+        {
+            GL.Uniform3(location, vector.X, vector.Y, vector.Z);
+        }
+
+        public static void Uniform4(int location, Vector4 vector)
+        {
+            GL.Uniform4(location, vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        public static void Uniform4(int location, Color4 color)
+        {
+            GL.Uniform4(location, color.R, color.G, color.B, color.A);
+        }
+
+        public static void Uniform4(int location, Quaternion quaternion)
+        {
+            GL.Uniform4(location, quaternion.X, quaternion.Y, quaternion.Z, quaternion.W);
+        }
+
+        public static void UniformMatrix4(int location, bool transpose, ref Matrix4 matrix)
+        {
+            unsafe
+            {
+                fixed (float* matrix_ptr = &matrix.Row0.X)
+                {
+                    GL.UniformMatrix4(location, 1, transpose, matrix_ptr);
+                }
+            }
+        }
+
+
+        #endregion
+
+        #region Shaders
+
+        #region GetActiveAttrib
+
+        public static string GetActiveAttrib(int program, int index, out int size, out ActiveAttribType type)
+        {
+            int length;
+            GetProgram(program, ProgramParameter.ActiveAttributeMaxLength, out length);
+            StringBuilder sb = new StringBuilder(length == 0 ? 1 : length * 2);
+
+            GetActiveAttrib(program, index, sb.Capacity, out length, out size, out type, sb);
+            return sb.ToString();
+        }
+
+        #endregion
+
+        #region GetActiveUniform
+
+        public static string GetActiveUniform(int program, int uniformIndex, out int size, out ActiveUniformType type)
+        {
+            int length;
+            GetProgram(program, ProgramParameter.ActiveUniformMaxLength, out length);
+
+            StringBuilder sb = new StringBuilder(length == 0 ? 1 : length);
+            GetActiveUniform(program, uniformIndex, sb.Capacity, out length, out size, out type, sb);
+            return sb.ToString();
+        }
+
+        #endregion
+
+        #region public static void ShaderSource(Int32 shader, System.String @string)
+
+        public static void ShaderSource(Int32 shader, System.String @string)
+        {
+            unsafe
+            {
+                int length = @string.Length;
+                GL.ShaderSource((UInt32)shader, 1, new string[] { @string }, &length);
+            }
+        }
+
+        #endregion
+
+        #region public static string GetShaderInfoLog(Int32 shader)
+
+        public static string GetShaderInfoLog(Int32 shader)
+        {
+            string info;
+            GetShaderInfoLog(shader, out info);
+            return info;
+        }
+
+        #endregion
+
+        #region public static void GetShaderInfoLog(Int32 shader, out string info)
+
+        public static void GetShaderInfoLog(Int32 shader, out string info)
+        {
+            unsafe
+            {
+                int length;
+                GL.GetShader(shader, ShaderParameter.InfoLogLength, out length);
+                if (length == 0)
+                {
+                    info = String.Empty;
+                    return;
+                }
+                StringBuilder sb = new StringBuilder(length * 2);
+                GL.GetShaderInfoLog((UInt32)shader, sb.Capacity, &length, sb);
+                info = sb.ToString();
+            }
+        }
+
+        #endregion
+
+        #region public static string GetProgramInfoLog(Int32 program)
+
+        public static string GetProgramInfoLog(Int32 program)
+        {
+            string info;
+            GetProgramInfoLog(program, out info);
+            return info;
+        }
+
+        #endregion
+
+        #region public static void GetProgramInfoLog(Int32 program, out string info)
+
+        public static void GetProgramInfoLog(Int32 program, out string info)
+        {
+            unsafe
+            {
+                int length;
+                GL.GetProgram(program, ProgramParameter.InfoLogLength, out length); if (length == 0)
+                {
+                    info = String.Empty;
+                    return;
+                }
+                StringBuilder sb = new StringBuilder(length * 2);
+                GL.GetProgramInfoLog((UInt32)program, sb.Capacity, &length, sb);
+                info = sb.ToString();
+            }
+        }
+
+        #endregion
+
+        #endregion
+
+        #region public static void VertexAttrib2(Int32 index, ref Vector2 v)
+
+        [CLSCompliant(false)]
+        public static void VertexAttrib2(Int32 index, ref Vector2 v)
+        {
+            GL.VertexAttrib2(index, v.X, v.Y);
+        }
+
+        #endregion
+
+        #region public static void VertexAttrib3(Int32 index, ref Vector3 v)
+
+        [CLSCompliant(false)]
+        public static void VertexAttrib3(Int32 index, ref Vector3 v)
+        {
+            GL.VertexAttrib3(index, v.X, v.Y, v.Z);
+        }
+
+        #endregion
+
+        #region public static void VertexAttrib4(Int32 index, ref Vector4 v)
+
+        [CLSCompliant(false)]
+        public static void VertexAttrib4(Int32 index, ref Vector4 v)
+        {
+            GL.VertexAttrib4(index, v.X, v.Y, v.Z, v.W);
+        }
+
+        #endregion
+
+        #region public static void VertexAttrib2(Int32 index, Vector2 v)
+
+        public static void VertexAttrib2(Int32 index, Vector2 v)
+        {
+            GL.VertexAttrib2(index, v.X, v.Y);
+        }
+
+        #endregion
+
+        #region public static void VertexAttrib3(Int32 index, Vector3 v)
+
+        public static void VertexAttrib3(Int32 index, Vector3 v)
+        {
+            GL.VertexAttrib3(index, v.X, v.Y, v.Z);
+        }
+
+        #endregion
+
+        #region public static void VertexAttrib4(Int32 index, Vector4 v)
+
+        public static void VertexAttrib4(Int32 index, Vector4 v)
+        {
+            GL.VertexAttrib4(index, v.X, v.Y, v.Z, v.W);
+        }
+
+        #endregion
+
+        #region public static int GenTexture()
+
+        public static int GenTexture()
+        {
+            int id;
+            GenTextures(1, out id);
+            return id;
+        }
+
+        #endregion
+
+        #region public static void DeleteTexture(int id)
+
+        public static void DeleteTexture(int id)
+        {
+            DeleteTextures(1, ref id);
+        }
+
+        #endregion
+
+        #region Get[Float|Double]
+
+        public static void GetFloat(GetPName pname, out Vector2 vector)
+        {
+            unsafe
+            {
+                fixed (Vector2* ptr = &vector)
+                    GetFloat(pname, (float*)ptr);
+            }
+        }
+
+        public static void GetFloat(GetPName pname, out Vector3 vector)
+        {
+            unsafe
+            {
+                fixed (Vector3* ptr = &vector)
+                    GetFloat(pname, (float*)ptr);
+            }
+        }
+
+        public static void GetFloat(GetPName pname, out Vector4 vector)
+        {
+            unsafe
+            {
+                fixed (Vector4* ptr = &vector)
+                    GetFloat(pname, (float*)ptr);
+            }
+        }
+
+        public static void GetFloat(GetPName pname, out Matrix4 matrix)
+        {
+            unsafe
+            {
+                fixed (Matrix4* ptr = &matrix)
+                    GetFloat(pname, (float*)ptr);
+            }
+        }
+
+        #endregion
+
+        #region Viewport
+
+        public static void Viewport(System.Drawing.Size size)
+        {
+            GL.Viewport(0, 0, size.Width, size.Height);
+        }
+
+        public static void Viewport(System.Drawing.Point location, System.Drawing.Size size)
+        {
+            GL.Viewport(location.X, location.Y, size.Width, size.Height);
+        }
+
+        public static void Viewport(System.Drawing.Rectangle rectangle)
+        {
+            GL.Viewport(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
+        }
+
+        #endregion
+
+#pragma warning restore 3019
+#pragma warning restore 1591
+#pragma warning restore 1572
+#pragma warning restore 1573
+
+        #endregion
     }
 }