diff --git a/tests/gtkgears.c b/tests/gtkgears.c
index 11e0ac8874..dfe66c354e 100644
--- a/tests/gtkgears.c
+++ b/tests/gtkgears.c
@@ -1,4 +1,4 @@
-/* The rendering code in here is taken from glxgears, which has the
+/* The rendering code in here is taken from es2gears, which has the
  * following copyright notice:
  *
  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
@@ -19,24 +19,93 @@
  * BRIAN PAUL 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.
+ *
+ * Ported to GLES2.
+ * Kristian Høgsberg <krh@bitplanet.net>
+ * May 3, 2010
+ *
+ * Improve GLES2 port:
+ *   * Refactor gear drawing.
+ *   * Use correct normals for surfaces.
+ *   * Improve shader.
+ *   * Use perspective projection transformation.
+ *   * Add FPS count.
+ *   * Add comments.
+ * Alexandros Frantzis <alexandros.frantzis@linaro.org>
+ * Jul 13, 2010
  */
 
+#define _GNU_SOURCE
 #include <math.h>
+#include <stdlib.h>
+#include <string.h>
 #include <epoxy/gl.h>
 
 #include "gtkgears.h"
 
+#define STRIPS_PER_TOOTH 7
+#define VERTICES_PER_TOOTH 34
+#define GEAR_VERTEX_STRIDE 6
+
+/**
+ * Struct describing the vertices in triangle strip
+ */
+struct vertex_strip {
+   /** The first vertex in the strip */
+   GLint first;
+   /** The number of consecutive vertices in the strip after the first */
+   GLint count;
+};
+
+/* Each vertex consist of GEAR_VERTEX_STRIDE GLfloat attributes */
+typedef GLfloat GearVertex[GEAR_VERTEX_STRIDE];
+
+/**
+ * Struct representing a gear.
+ */
+struct gear {
+   /** The array of vertices comprising the gear */
+   GearVertex *vertices;
+   /** The number of vertices comprising the gear */
+   int nvertices;
+   /** The array of triangle strips comprising the gear */
+   struct vertex_strip *strips;
+   /** The number of triangle strips comprising the gear */
+   int nstrips;
+   /** The Vertex Buffer Object holding the vertices in the graphics card */
+   GLuint vbo;
+};
+
 typedef struct {
+  /* The view rotation [x, y, z] */
   GLfloat view_rot[GTK_GEARS_N_AXIS];
-  GLint gear1, gear2, gear3;
+
+  /* The gears */
+  struct gear *gear1;
+  struct gear *gear2;
+  struct gear *gear3;
+
+  /** The location of the shader uniforms */
+  GLuint ModelViewProjectionMatrix_location;
+  GLuint NormalMatrix_location;
+  GLuint LightSourcePosition_location;
+  GLuint MaterialColor_location;
+
+  /* The current gear rotation angle */
   GLfloat angle;
+
+  /* The projection matrix */
+  GLfloat ProjectionMatrix[16];
+
+  /* The direction of the directional light for the scene */
+  GLfloat LightSourcePosition[4];
+
   gint64 first_frame_time;
   guint tick;
   GtkLabel *fps_label;
 } GtkGearsPrivate;
 
-
-G_DEFINE_TYPE_WITH_PRIVATE (GtkGears, gtk_gears, GTK_TYPE_GL_AREA);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkGears, gtk_gears, GTK_TYPE_GL_AREA)
 
 static gboolean gtk_gears_render        (GtkGLArea     *area,
                                          GdkGLContext  *context);
@@ -47,16 +116,14 @@ static gboolean gtk_gears_tick          (GtkWidget     *widget,
                                          GdkFrameClock *frame_clock,
                                          gpointer       user_data);
 
+static void destroy_gear (struct gear *g);
+
 GtkWidget *
 gtk_gears_new (void)
 {
-  GtkWidget *gears;
-
-  gears = g_object_new (gtk_gears_get_type (),
-                        "has-depth-buffer", TRUE,
-                        NULL);
-
-  return gears;
+  return g_object_new (gtk_gears_get_type (),
+                       "has-depth-buffer", TRUE,
+                       NULL);
 }
 
 static void
@@ -68,6 +135,11 @@ gtk_gears_init (GtkGears *gears)
   priv->view_rot[GTK_GEARS_Y_AXIS] = 30.0;
   priv->view_rot[GTK_GEARS_Z_AXIS] = 20.0;
 
+  priv->LightSourcePosition[0] = 5.0;
+  priv->LightSourcePosition[1] = 5.0;
+  priv->LightSourcePosition[2] = 10.0;
+  priv->LightSourcePosition[3] = 1.0;
+
   priv->tick = gtk_widget_add_tick_callback (GTK_WIDGET (gears), gtk_gears_tick, gears, NULL);
 }
 
@@ -81,6 +153,10 @@ gtk_gears_finalize (GObject *obj)
 
   g_clear_object (&priv->fps_label);
 
+  g_clear_pointer (&priv->gear1, destroy_gear);
+  g_clear_pointer (&priv->gear2, destroy_gear);
+  g_clear_pointer (&priv->gear3, destroy_gear);
+
   G_OBJECT_CLASS (gtk_gears_parent_class)->finalize (obj);
 }
 
@@ -94,190 +170,469 @@ gtk_gears_class_init (GtkGearsClass *klass)
 }
 
 /*
+ * Fills a gear vertex.
  *
- *  Draw a gear wheel.  You'll probably want to call this function when
- *  building a display list since we do a lot of trig here.
+ * @param v the vertex to fill
+ * @param x the x coordinate
+ * @param y the y coordinate
+ * @param z the z coortinate
+ * @param n pointer to the normal table
  *
- *  Input:  inner_radius - radius of hole at center
- *          outer_radius - radius at center of teeth
- *          width - width of gear
- *          teeth - number of teeth
- *          tooth_depth - depth of tooth
+ * @return the operation error code
+ */
+static GearVertex *
+vert (GearVertex *v,
+      GLfloat x,
+      GLfloat y,
+      GLfloat z,
+      GLfloat n[3])
+{
+  v[0][0] = x;
+  v[0][1] = y;
+  v[0][2] = z;
+  v[0][3] = n[0];
+  v[0][4] = n[1];
+  v[0][5] = n[2];
+
+  return v + 1;
+}
+
+static void
+destroy_gear (struct gear *g)
+{
+  g_clear_pointer (&g->strips, g_free);
+  g_free (g);
+}
+
+/**
+ *  Create a gear wheel.
+ *
+ *  @param inner_radius radius of hole at center
+ *  @param outer_radius radius at center of teeth
+ *  @param width width of gear
+ *  @param teeth number of teeth
+ *  @param tooth_depth depth of tooth
+ *
+ *  @return pointer to the constructed struct gear
+ */
+static struct gear *
+create_gear (GLfloat inner_radius,
+             GLfloat outer_radius,
+             GLfloat width,
+             GLint teeth,
+             GLfloat tooth_depth)
+{
+  GLfloat r0, r1, r2;
+  GLfloat da;
+  GearVertex *v;
+  struct gear *gear;
+  double s[5], c[5];
+  GLfloat normal[3];
+  int cur_strip = 0;
+  int i;
+
+  /* Allocate memory for the gear */
+  gear = g_malloc (sizeof *gear);
+
+  /* Calculate the radii used in the gear */
+  r0 = inner_radius;
+  r1 = outer_radius - tooth_depth / 2.0;
+  r2 = outer_radius + tooth_depth / 2.0;
+
+  da = 2.0 * M_PI / teeth / 4.0;
+
+  /* Allocate memory for the triangle strip information */
+  gear->nstrips = STRIPS_PER_TOOTH * teeth;
+  gear->strips = g_malloc0_n (gear->nstrips, sizeof (*gear->strips));
+
+  /* Allocate memory for the vertices */
+  gear->vertices = g_malloc0_n (VERTICES_PER_TOOTH * teeth, sizeof(*gear->vertices));
+  v = gear->vertices;
+
+  for (i = 0; i < teeth; i++) {
+    /* A set of macros for making the creation of the gears easier */
+#define  GEAR_POINT(p, r, da) do { p.x = (r) * c[(da)]; p.y = (r) * s[(da)]; } while(0)
+#define  SET_NORMAL(x, y, z) do { \
+   normal[0] = (x); normal[1] = (y); normal[2] = (z); \
+} while(0)
+
+#define  GEAR_VERT(v, point, sign) vert((v), p[(point)].x, p[(point)].y, (sign) * width * 0.5, normal)
+
+#define START_STRIP do { \
+   gear->strips[cur_strip].first = v - gear->vertices; \
+} while(0);
+
+#define END_STRIP do { \
+   int _tmp = (v - gear->vertices); \
+   gear->strips[cur_strip].count = _tmp - gear->strips[cur_strip].first; \
+   cur_strip++; \
+} while (0)
+
+#define QUAD_WITH_NORMAL(p1, p2) do { \
+   SET_NORMAL((p[(p1)].y - p[(p2)].y), -(p[(p1)].x - p[(p2)].x), 0); \
+   v = GEAR_VERT(v, (p1), -1); \
+   v = GEAR_VERT(v, (p1), 1); \
+   v = GEAR_VERT(v, (p2), -1); \
+   v = GEAR_VERT(v, (p2), 1); \
+} while(0)
+    struct point {
+      GLfloat x;
+      GLfloat y;
+    };
+
+    /* Create the 7 points (only x,y coords) used to draw a tooth */
+    struct point p[7];
+
+    /* Calculate needed sin/cos for varius angles */
+    sincos(i * 2.0 * G_PI / teeth + da * 0, &s[0], &c[0]);
+    sincos(i * 2.0 * M_PI / teeth + da * 1, &s[1], &c[1]);
+    sincos(i * 2.0 * M_PI / teeth + da * 2, &s[2], &c[2]);
+    sincos(i * 2.0 * M_PI / teeth + da * 3, &s[3], &c[3]);
+    sincos(i * 2.0 * M_PI / teeth + da * 4, &s[4], &c[4]);
+
+    GEAR_POINT(p[0], r2, 1);
+    GEAR_POINT(p[1], r2, 2);
+    GEAR_POINT(p[2], r1, 0);
+    GEAR_POINT(p[3], r1, 3);
+    GEAR_POINT(p[4], r0, 0);
+    GEAR_POINT(p[5], r1, 4);
+    GEAR_POINT(p[6], r0, 4);
+
+    /* Front face */
+    START_STRIP;
+    SET_NORMAL(0, 0, 1.0);
+    v = GEAR_VERT(v, 0, +1);
+    v = GEAR_VERT(v, 1, +1);
+    v = GEAR_VERT(v, 2, +1);
+    v = GEAR_VERT(v, 3, +1);
+    v = GEAR_VERT(v, 4, +1);
+    v = GEAR_VERT(v, 5, +1);
+    v = GEAR_VERT(v, 6, +1);
+    END_STRIP;
+
+    /* Inner face */
+    START_STRIP;
+    QUAD_WITH_NORMAL(4, 6);
+    END_STRIP;
+
+    /* Back face */
+    START_STRIP;
+    SET_NORMAL(0, 0, -1.0);
+    v = GEAR_VERT(v, 6, -1);
+    v = GEAR_VERT(v, 5, -1);
+    v = GEAR_VERT(v, 4, -1);
+    v = GEAR_VERT(v, 3, -1);
+    v = GEAR_VERT(v, 2, -1);
+    v = GEAR_VERT(v, 1, -1);
+    v = GEAR_VERT(v, 0, -1);
+    END_STRIP;
+
+    /* Outer face */
+    START_STRIP;
+    QUAD_WITH_NORMAL(0, 2);
+    END_STRIP;
+
+    START_STRIP;
+    QUAD_WITH_NORMAL(1, 0);
+    END_STRIP;
+
+    START_STRIP;
+    QUAD_WITH_NORMAL(3, 1);
+    END_STRIP;
+
+    START_STRIP;
+    QUAD_WITH_NORMAL(5, 3);
+    END_STRIP;
+  }
+
+  gear->nvertices = (v - gear->vertices);
+
+  /* Store the vertices in a vertex buffer object (VBO) */
+  glGenBuffers (1, &gear->vbo);
+  glBindBuffer (GL_ARRAY_BUFFER, gear->vbo);
+  glBufferData (GL_ARRAY_BUFFER,
+                gear->nvertices * sizeof(GearVertex),
+                gear->vertices,
+                GL_STATIC_DRAW);
+
+  return gear;
+}
+
+/** 
+ * Multiplies two 4x4 matrices.
+ *
+ * The result is stored in matrix m.
+ *
+ * @param m the first matrix to multiply
+ * @param n the second matrix to multiply
  */
 static void
-gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
-     GLint teeth, GLfloat tooth_depth)
+multiply (GLfloat *m, const GLfloat *n)
 {
-   GLint i;
-   GLfloat r0, r1, r2;
-   GLfloat angle, da;
-   GLfloat u, v, len;
+   GLfloat tmp[16];
+   const GLfloat *row, *column;
+   div_t d;
+   int i, j;
 
-   r0 = inner_radius;
-   r1 = outer_radius - tooth_depth / 2.0;
-   r2 = outer_radius + tooth_depth / 2.0;
-
-   da = 2.0 * G_PI / teeth / 4.0;
-
-   glShadeModel(GL_FLAT);
-
-   glNormal3f(0.0, 0.0, 1.0);
-
-   /* draw front face */
-   glBegin(GL_QUAD_STRIP);
-   for (i = 0; i <= teeth; i++) {
-      angle = i * 2.0 * G_PI / teeth;
-      glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
-      glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
-      if (i < teeth) {
-	 glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
-	 glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
-		    width * 0.5);
-      }
+   for (i = 0; i < 16; i++) {
+      tmp[i] = 0;
+      d = div(i, 4);
+      row = n + d.quot * 4;
+      column = m + d.rem;
+      for (j = 0; j < 4; j++)
+         tmp[i] += row[j] * column[j * 4];
    }
-   glEnd();
+   memcpy(m, &tmp, sizeof tmp);
+}
 
-   /* draw front sides of teeth */
-   glBegin(GL_QUADS);
-   da = 2.0 * G_PI / teeth / 4.0;
-   for (i = 0; i < teeth; i++) {
-      angle = i * 2.0 * G_PI / teeth;
+/** 
+ * Rotates a 4x4 matrix.
+ *
+ * @param[in,out] m the matrix to rotate
+ * @param angle the angle to rotate
+ * @param x the x component of the direction to rotate to
+ * @param y the y component of the direction to rotate to
+ * @param z the z component of the direction to rotate to
+ */
+static void
+rotate(GLfloat *m, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+   double s, c;
 
-      glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
-      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
-      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
-		 width * 0.5);
-      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
-		 width * 0.5);
-   }
-   glEnd();
+   sincos(angle, &s, &c);
+   GLfloat r[16] = {
+      x * x * (1 - c) + c,     y * x * (1 - c) + z * s, x * z * (1 - c) - y * s, 0,
+      x * y * (1 - c) - z * s, y * y * (1 - c) + c,     y * z * (1 - c) + x * s, 0,
+      x * z * (1 - c) + y * s, y * z * (1 - c) - x * s, z * z * (1 - c) + c,     0,
+      0, 0, 0, 1
+   };
 
-   glNormal3f(0.0, 0.0, -1.0);
+   multiply(m, r);
+}
 
-   /* draw back face */
-   glBegin(GL_QUAD_STRIP);
-   for (i = 0; i <= teeth; i++) {
-      angle = i * 2.0 * G_PI / teeth;
-      glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
-      glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
-      if (i < teeth) {
-	 glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
-		    -width * 0.5);
-	 glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
-      }
-   }
-   glEnd();
+/** 
+ * Translates a 4x4 matrix.
+ * 
+ * @param[in,out] m the matrix to translate
+ * @param x the x component of the direction to translate to
+ * @param y the y component of the direction to translate to
+ * @param z the z component of the direction to translate to
+ */
+static void
+translate(GLfloat *m, GLfloat x, GLfloat y, GLfloat z)
+{
+   GLfloat t[16] = { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  x, y, z, 1 };
 
-   /* draw back sides of teeth */
-   glBegin(GL_QUADS);
-   da = 2.0 * G_PI / teeth / 4.0;
-   for (i = 0; i < teeth; i++) {
-      angle = i * 2.0 * G_PI / teeth;
+   multiply(m, t);
+}
 
-      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
-		 -width * 0.5);
-      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
-		 -width * 0.5);
-      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
-      glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
-   }
-   glEnd();
+/** 
+ * Creates an identity 4x4 matrix.
+ * 
+ * @param m the matrix make an identity matrix
+ */
+static void
+identity(GLfloat *m)
+{
+   GLfloat t[16] = {
+      1.0, 0.0, 0.0, 0.0,
+      0.0, 1.0, 0.0, 0.0,
+      0.0, 0.0, 1.0, 0.0,
+      0.0, 0.0, 0.0, 1.0,
+   };
 
-   /* draw outward faces of teeth */
-   glBegin(GL_QUAD_STRIP);
-   for (i = 0; i < teeth; i++) {
-      angle = i * 2.0 * G_PI / teeth;
+   memcpy(m, t, sizeof(t));
+}
 
-      glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
-      glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
-      u = r2 * cos(angle + da) - r1 * cos(angle);
-      v = r2 * sin(angle + da) - r1 * sin(angle);
-      len = sqrt(u * u + v * v);
-      u /= len;
-      v /= len;
-      glNormal3f(v, -u, 0.0);
-      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
-      glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
-      glNormal3f(cos(angle), sin(angle), 0.0);
-      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
-		 width * 0.5);
-      glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
-		 -width * 0.5);
-      u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
-      v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
-      glNormal3f(v, -u, 0.0);
-      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
-		 width * 0.5);
-      glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
-		 -width * 0.5);
-      glNormal3f(cos(angle), sin(angle), 0.0);
-   }
+/** 
+ * Transposes a 4x4 matrix.
+ *
+ * @param m the matrix to transpose
+ */
+static void
+transpose(GLfloat *m)
+{
+   GLfloat t[16] = {
+      m[0], m[4], m[8],  m[12],
+      m[1], m[5], m[9],  m[13],
+      m[2], m[6], m[10], m[14],
+      m[3], m[7], m[11], m[15]};
 
-   glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
-   glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
+   memcpy(m, t, sizeof(t));
+}
 
-   glEnd();
+/**
+ * Inverts a 4x4 matrix.
+ *
+ * This function can currently handle only pure translation-rotation matrices.
+ * Read http://www.gamedev.net/community/forums/topic.asp?topic_id=425118
+ * for an explanation.
+ */
+static void
+invert(GLfloat *m)
+{
+   GLfloat t[16];
+   identity(t);
 
-   glShadeModel(GL_SMOOTH);
+   // Extract and invert the translation part 't'. The inverse of a
+   // translation matrix can be calculated by negating the translation
+   // coordinates.
+   t[12] = -m[12]; t[13] = -m[13]; t[14] = -m[14];
 
-   /* draw inside radius cylinder */
-   glBegin(GL_QUAD_STRIP);
-   for (i = 0; i <= teeth; i++) {
-      angle = i * 2.0 * G_PI / teeth;
-      glNormal3f(-cos(angle), -sin(angle), 0.0);
-      glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
-      glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
-   }
-   glEnd();
+   // Invert the rotation part 'r'. The inverse of a rotation matrix is
+   // equal to its transpose.
+   m[12] = m[13] = m[14] = 0;
+   transpose(m);
+
+   // inv(m) = inv(r) * inv(t)
+   multiply(m, t);
+}
+
+/** 
+ * Calculate a perspective projection transformation.
+ * 
+ * @param m the matrix to save the transformation in
+ * @param fovy the field of view in the y direction
+ * @param aspect the view aspect ratio
+ * @param zNear the near clipping plane
+ * @param zFar the far clipping plane
+ */
+void perspective(GLfloat *m, GLfloat fovy, GLfloat aspect, GLfloat zNear, GLfloat zFar)
+{
+   GLfloat tmp[16];
+   identity(tmp);
+
+   double sine, cosine, cotangent, deltaZ;
+   GLfloat radians = fovy / 2 * M_PI / 180;
+
+   deltaZ = zFar - zNear;
+   sincos(radians, &sine, &cosine);
+
+   if ((deltaZ == 0) || (sine == 0) || (aspect == 0))
+      return;
+
+   cotangent = cosine / sine;
+
+   tmp[0] = cotangent / aspect;
+   tmp[5] = cotangent;
+   tmp[10] = -(zFar + zNear) / deltaZ;
+   tmp[11] = -1;
+   tmp[14] = -2 * zNear * zFar / deltaZ;
+   tmp[15] = 0;
+
+   memcpy(m, tmp, sizeof(tmp));
+}
+
+/**
+ * Draws a gear.
+ *
+ * @param gear the gear to draw
+ * @param transform the current transformation matrix
+ * @param x the x position to draw the gear at
+ * @param y the y position to draw the gear at
+ * @param angle the rotation angle of the gear
+ * @param color the color of the gear
+ */
+static void
+draw_gear(GtkGears *self,
+          struct gear *gear,
+          GLfloat *transform,
+          GLfloat x,
+          GLfloat y,
+          GLfloat angle,
+          const GLfloat color[4])
+{
+  GtkGearsPrivate *priv = gtk_gears_get_instance_private (self);
+  GLfloat model_view[16];
+  GLfloat normal_matrix[16];
+  GLfloat model_view_projection[16];
+  int n;
+
+  /* Translate and rotate the gear */
+  memcpy(model_view, transform, sizeof (model_view));
+  translate(model_view, x, y, 0);
+  rotate(model_view, 2 * G_PI * angle / 360.0, 0, 0, 1);
+
+  /* Create and set the ModelViewProjectionMatrix */
+  memcpy(model_view_projection, priv->ProjectionMatrix, sizeof(model_view_projection));
+  multiply(model_view_projection, model_view);
+
+  glUniformMatrix4fv(priv->ModelViewProjectionMatrix_location, 1, GL_FALSE,
+                     model_view_projection);
+
+  /* 
+   * Create and set the NormalMatrix. It's the inverse transpose of the
+   * ModelView matrix.
+   */
+  memcpy(normal_matrix, model_view, sizeof (normal_matrix));
+  invert(normal_matrix);
+  transpose(normal_matrix);
+  glUniformMatrix4fv(priv->NormalMatrix_location, 1, GL_FALSE, normal_matrix);
+
+  /* Set the gear color */
+  glUniform4fv(priv->MaterialColor_location, 1, color);
+
+  /* Set the vertex buffer object to use */
+  glBindBuffer(GL_ARRAY_BUFFER, gear->vbo);
+
+  /* Set up the position of the attributes in the vertex buffer object */
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), NULL);
+  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLfloat *) 0 + 3);
+
+  /* Enable the attributes */
+  glEnableVertexAttribArray(0);
+  glEnableVertexAttribArray(1);
+
+  /* Draw the triangle strips that comprise the gear */
+  for (n = 0; n < gear->nstrips; n++) {
+    glDrawArrays(GL_TRIANGLE_STRIP, gear->strips[n].first, gear->strips[n].count);
+  }
+
+  /* Disable the attributes */
+  glDisableVertexAttribArray(1);
+  glDisableVertexAttribArray(0);
 }
 
 /* new window size or exposure */
 static void
-reshape(int width, int height)
+reshape(GtkGears *gears, int width, int height)
 {
-  GLfloat h = (GLfloat) height / (GLfloat) width;
+  GtkGearsPrivate *priv = gtk_gears_get_instance_private (gears);
 
-  glMatrixMode(GL_PROJECTION);
-  glLoadIdentity();
-  glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
+  /* Update the projection matrix */
+  perspective (priv->ProjectionMatrix, 60.0, width / (float)height, 1.0, 1024.0);
 
-  glMatrixMode(GL_MODELVIEW);
-  glLoadIdentity();
-  glTranslatef(0.0, 0.0, -40.0);
+  /* Set the viewport */
+  glViewport (0, 0, (GLint) width, (GLint) height);
 }
 
 static gboolean
 gtk_gears_render (GtkGLArea    *area,
                   GdkGLContext *context)
 {
-  GtkGearsPrivate *priv = gtk_gears_get_instance_private (GTK_GEARS (area));
+  static const GLfloat red[4]   = { 0.8, 0.1, 0.0, 1.0 };
+  static const GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
+  static const GLfloat blue[4]  = { 0.2, 0.2, 1.0, 1.0 };
 
-  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  GtkGears *self = GTK_GEARS (area);
+  GtkGearsPrivate *priv = gtk_gears_get_instance_private (self);
+  GLfloat transform[16];
 
-  glPushMatrix();
-  glRotatef(priv->view_rot[GTK_GEARS_X_AXIS], 1.0, 0.0, 0.0);
-  glRotatef(priv->view_rot[GTK_GEARS_Y_AXIS], 0.0, 1.0, 0.0);
-  glRotatef(priv->view_rot[GTK_GEARS_Z_AXIS], 0.0, 0.0, 1.0);
+  identity (transform);
 
-  glPushMatrix();
-  glTranslatef(-3.0, -2.0, 0.0);
-  glRotatef(priv->angle, 0.0, 0.0, 1.0);
-  glCallList(priv->gear1);
-  glPopMatrix();
+  glClearColor (0.0, 0.0, 0.0, 0.0);
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-  glPushMatrix();
-  glTranslatef(3.1, -2.0, 0.0);
-  glRotatef(-2.0 * priv->angle - 9.0, 0.0, 0.0, 1.0);
-  glCallList(priv->gear2);
-  glPopMatrix();
+  /* Translate and rotate the view */
+  translate (transform, 0, 0, -20);
+  rotate (transform, 2 * G_PI * priv->view_rot[0] / 360.0, 1, 0, 0);
+  rotate (transform, 2 * G_PI * priv->view_rot[1] / 360.0, 0, 1, 0);
+  rotate (transform, 2 * G_PI * priv->view_rot[2] / 360.0, 0, 0, 1);
 
-  glPushMatrix();
-  glTranslatef(-3.1, 4.2, 0.0);
-  glRotatef(-2.0 * priv->angle - 25.0, 0.0, 0.0, 1.0);
-  glCallList(priv->gear3);
-  glPopMatrix();
-
-  glPopMatrix();
+  /* Draw the gears */
+  draw_gear (self, priv->gear1, transform, -3.0, -2.0,      priv->angle,        red);
+  draw_gear (self, priv->gear2, transform,  3.1, -2.0, -2 * priv->angle - 9.0,  green);
+  draw_gear (self, priv->gear3, transform, -3.1,  4.2, -2 * priv->angle - 25.0, blue);
 
   return TRUE;
 }
@@ -293,55 +648,114 @@ gtk_gears_size_allocate (GtkWidget     *widget,
   if (gtk_widget_get_realized (widget))
     {
       gtk_gl_area_make_current (glarea);
-      reshape (allocation->width, allocation->height);
+      reshape ((GtkGears *) glarea, allocation->width, allocation->height);
     }
 }
 
+static const char vertex_shader[] =
+"#version 150\n"
+"\n"
+"in vec3 position;\n"
+"in vec3 normal;\n"
+"\n"
+"uniform mat4 ModelViewProjectionMatrix;\n"
+"uniform mat4 NormalMatrix;\n"
+"uniform vec4 LightSourcePosition;\n"
+"uniform vec4 MaterialColor;\n"
+"\n"
+"smooth out vec4 Color;\n"
+"\n"
+"void main(void)\n"
+"{\n"
+"    // Transform the normal to eye coordinates\n"
+"    vec3 N = normalize(vec3(NormalMatrix * vec4(normal, 1.0)));\n"
+"\n"
+"    // The LightSourcePosition is actually its direction for directional light\n"
+"    vec3 L = normalize(LightSourcePosition.xyz);\n"
+"\n"
+"    // Multiply the diffuse value by the vertex color (which is fixed in this case)\n"
+"    // to get the actual color that we will use to draw this vertex with\n"
+"    float diffuse = max(dot(N, L), 0.0);\n"
+"    Color = diffuse * MaterialColor;\n"
+"\n"
+"    // Transform the position to clip coordinates\n"
+"    gl_Position = ModelViewProjectionMatrix * vec4(position, 1.0);\n"
+"}";
+
+static const char fragment_shader[] =
+"#version 150\n"
+"\n"
+"smooth in vec4 Color;\n"
+"\n"
+"void main(void)\n"
+"{\n"
+"    gl_FragColor = Color;\n"
+"}";
+
 static void
 gtk_gears_realize (GtkWidget *widget)
 {
   GtkGLArea *glarea = GTK_GL_AREA (widget);
-  GtkGears *gears = GTK_GEARS(widget);
+  GtkGears *gears = GTK_GEARS (widget);
   GtkGearsPrivate *priv = gtk_gears_get_instance_private (gears);
-  GtkAllocation allocation;
-  static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
-  static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
-  static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
-  static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
+  GLuint vao, v, f, program;
+  const char *p;
+  char msg[512];
 
   GTK_WIDGET_CLASS (gtk_gears_parent_class)->realize (widget);
 
   gtk_gl_area_make_current (glarea);
 
-  glLightfv(GL_LIGHT0, GL_POSITION, pos);
-  glEnable(GL_CULL_FACE);
-  glEnable(GL_LIGHTING);
-  glEnable(GL_LIGHT0);
-  glEnable(GL_DEPTH_TEST);
+  glEnable (GL_CULL_FACE);
+  glEnable (GL_DEPTH_TEST);
+
+  /* Create the VAO */
+  glGenVertexArrays (1, &vao);
+  glBindVertexArray (vao);
+
+  /* Compile the vertex shader */
+  p = vertex_shader;
+  v = glCreateShader(GL_VERTEX_SHADER);
+  glShaderSource(v, 1, &p, NULL);
+  glCompileShader(v);
+  glGetShaderInfoLog(v, sizeof msg, NULL, msg);
+  g_print ("vertex shader info: %s\n", msg);
+
+  /* Compile the fragment shader */
+  p = fragment_shader;
+  f = glCreateShader(GL_FRAGMENT_SHADER);
+  glShaderSource(f, 1, &p, NULL);
+  glCompileShader(f);
+  glGetShaderInfoLog(f, sizeof msg, NULL, msg);
+  g_print ("fragment shader info: %s\n", msg);
+
+  /* Create and link the shader program */
+  program = glCreateProgram();
+  glAttachShader(program, v);
+  glAttachShader(program, f);
+  glBindAttribLocation(program, 0, "position");
+  glBindAttribLocation(program, 1, "normal");
+
+  glLinkProgram(program);
+  glGetProgramInfoLog(program, sizeof msg, NULL, msg);
+  g_print ("program info: %s\n", msg);
+
+  /* Enable the shaders */
+  glUseProgram(program);
+
+  /* Get the locations of the uniforms so we can access them */
+  priv->ModelViewProjectionMatrix_location = glGetUniformLocation(program, "ModelViewProjectionMatrix");
+  priv->NormalMatrix_location = glGetUniformLocation(program, "NormalMatrix");
+  priv->LightSourcePosition_location = glGetUniformLocation(program, "LightSourcePosition");
+  priv->MaterialColor_location = glGetUniformLocation(program, "MaterialColor");
+
+  /* Set the LightSourcePosition uniform which is constant throught the program */
+  glUniform4fv(priv->LightSourcePosition_location, 1, priv->LightSourcePosition);
 
   /* make the gears */
-  priv->gear1 = glGenLists(1);
-  glNewList(priv->gear1, GL_COMPILE);
-  glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
-  gear(1.0, 4.0, 1.0, 20, 0.7);
-  glEndList();
-
-  priv->gear2 = glGenLists(1);
-  glNewList(priv->gear2, GL_COMPILE);
-  glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
-  gear(0.5, 2.0, 2.0, 10, 0.7);
-  glEndList();
-
-  priv->gear3 = glGenLists(1);
-  glNewList(priv->gear3, GL_COMPILE);
-  glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
-  gear(1.3, 2.0, 0.5, 10, 0.7);
-  glEndList();
-
-  glEnable(GL_NORMALIZE);
-
-  gtk_widget_get_allocation (widget, &allocation);
-  reshape (allocation.width, allocation.height);
+  priv->gear1 = create_gear(1.0, 4.0, 1.0, 20, 0.7);
+  priv->gear2 = create_gear(0.5, 2.0, 2.0, 10, 0.7);
+  priv->gear3 = create_gear(1.3, 2.0, 0.5, 10, 0.7);
 }
 
 static gboolean