diff --git a/src/debug/quad.cpp b/src/debug/quad.cpp
index 71324829..b4c0024b 100644
--- a/src/debug/quad.cpp
+++ b/src/debug/quad.cpp
@@ -12,7 +12,7 @@
 #   include "config.h"
 #endif
 
-#if !defined USE_D3D9 && !defined _XBOX /* This file is meaningless on Xbox */
+#if 0
 
 #if defined WIN32 && !_XBOX
 #   define _USE_MATH_DEFINES /* for M_PI */
@@ -1119,4 +1119,4 @@ void DebugQuad::ResetState()
 
 } /* namespace lol */
 
-#endif /* !defined _XBOX */
+#endif /* 0 */
diff --git a/src/gpu/shader.cpp b/src/gpu/shader.cpp
index 6136e955..9b7addf1 100644
--- a/src/gpu/shader.cpp
+++ b/src/gpu/shader.cpp
@@ -235,13 +235,14 @@ ShaderAttrib Shader::GetAttribLocation(char const *attr,
                                        VertexUsage usage, int index) const
 {
     ShaderAttrib ret;
+    ret.m_flags = (uint64_t)(uint16_t)usage << 16;
+    ret.m_flags |= (uint64_t)(uint16_t)index;
 #if defined USE_D3D9 || defined _XBOX
-    ret.m_flags = (uint32_t)index << 16;
-    ret.m_flags |= (uint32_t)usage;
 #elif !defined __CELLOS_LV2__
-    ret.m_flags = glGetAttribLocation(data->prog_id, attr);
+    ret.m_flags |= (uint64_t)
+                  (uint32_t)glGetAttribLocation(data->prog_id, attr) << 32;
 #else
-    /* FIXME: can we do this at all? */
+    /* FIXME: can we do this at all on the PS3? */
 #endif
     return ret;
 }
diff --git a/src/gpu/shader.h b/src/gpu/shader.h
index cef975dc..f2b5ffa6 100644
--- a/src/gpu/shader.h
+++ b/src/gpu/shader.h
@@ -26,7 +26,7 @@ struct ShaderUniform
     friend class Shader;
 
 public:
-    ShaderUniform() : flags(0) {}
+    inline ShaderUniform() : flags(0) {}
 
 private:
     uintptr_t frag, vert;
@@ -40,10 +40,10 @@ struct ShaderAttrib
     friend class VertexDeclaration;
 
 public:
-    ShaderAttrib(int flags = 0xffffffff) : m_flags(flags) {}
+    inline ShaderAttrib() : m_flags((uint64_t)0 - 1) {}
 
 private:
-    uint32_t m_flags;
+    uint64_t m_flags;
 };
 
 class ShaderData;
diff --git a/src/gpu/vertexbuffer.cpp b/src/gpu/vertexbuffer.cpp
index a8a98294..3b622598 100644
--- a/src/gpu/vertexbuffer.cpp
+++ b/src/gpu/vertexbuffer.cpp
@@ -114,7 +114,19 @@ void VertexDeclaration::Bind()
 
     g_d3ddevice->SetVertexDeclaration(vdecl);
 #else
+    /* FIXME: Nothing to do? */
+#endif
+}
 
+void VertexDeclaration::Unbind()
+{
+#if defined _XBOX || defined USE_D3D9
+    /* FIXME: Nothing to do? */
+#else
+    /* FIXME: we need to record what happens */
+    //glDisableVertexAttribArray(m_attrib);
+    /* FIXME: only useful for VAOs */
+    //glBindBuffer(GL_ARRAY_BUFFER, 0);
 #endif
 }
 
@@ -135,33 +147,97 @@ void VertexDeclaration::SetStream(VertexBuffer *vb, ShaderAttrib attr1,
     /* Only the first item is required to know which stream this
      * is about; the rest of the information is stored in the
      * vertex declaration already. */
-    uint32_t usage = attr1.m_flags >> 16;
+    uint32_t usage = (attr1.m_flags >> 16) & 0xffff;
     uint32_t index = attr1.m_flags & 0xffff;
-    int usage_index = 0, stream = -1, stride = 0;
+
+    /* Find the stream number */
+    int usage_index = 0, stream = -1;
     for (int i = 0; i < m_count; i++)
-    {
         if (m_streams[i].usage == usage)
             if (usage_index++ == index)
+            {
                 stream = m_streams[i].index;
+                break;
+            }
+
+    /* Compute this stream's stride */
+    int stride = 0;
+    for (int i = 0; i < m_count; i++)
         if (stream == m_streams[i].index)
             stride += m_streams[i].size;
-    }
 
     /* Now we know the stream index and the element stride */
     /* FIXME: precompute most of the crap above! */
     if (stream >= 0)
         g_d3ddevice->SetStreamSource(stream, vb->m_data->m_vbo, 0, stride);
 #else
-    glBindBuffer(GL_ARRAY_BUFFER, vb);
+    glBindBuffer(GL_ARRAY_BUFFER, vb->m_data->m_vbo);
     ShaderAttrib l[12] = { attr1, attr2, attr3, attr4, attr5, attr6,
                            attr7, attr8, attr9, attr10, attr11, attr12 };
-    for (int i = 0; i < 12 && l[i].m_flags != 0xffffffff; i++)
+    for (int n = 0; n < 12 && l[n].m_flags != (uint64_t)0 - 1; n++)
     {
-        uint32_t usage = l[i].m_flags >> 16;
-        uint32_t index = l[i].m_flags & 0xffff;
-    glEnableVertexAttribArray((GLint)attr.flags);
-    /* FIXME: Hardcoded!! Where to get that from? */
-    glVertexAttribPointer((GLint)attr.flags, 3, GL_FLOAT, GL_FALSE, 0, 0);
+        uint32_t reg = l[n].m_flags >> 32;
+        uint32_t usage = (l[n].m_flags >> 16) & 0xffff;
+        uint32_t index = l[n].m_flags & 0xffff;
+
+        glEnableVertexAttribArray((GLint)reg);
+
+        /* We need to parse the whole vertex declaration to retrieve
+         * the information. It sucks. */
+
+        int attr_index = 0, usage_index = 0, stream = -1;
+        /* First, find the stream index */
+        for (; attr_index < m_count; attr_index++)
+            if (m_streams[attr_index].usage == usage)
+                if (usage_index++ == index)
+                {
+                    stream = m_streams[attr_index].index;
+                    break;
+                }
+
+        /* Now compute the stride and offset up to this stream index */
+        int stride = 0, offset = 0;
+        for (int i = 0; i < m_count; i++)
+            if (m_streams[i].index == m_streams[attr_index].index)
+            {
+                stride += m_streams[i].size;
+                if (i < attr_index)
+                    offset += m_streams[i].size;
+            }
+
+        /* Finally, we need to retrieve the type of the data */
+        static struct { GLint size; GLenum type; } const tlut[] =
+        {
+            { 0, 0 },
+            { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, /* half */
+            { 1, GL_FLOAT }, { 2, GL_FLOAT }, { 3, GL_FLOAT },
+                { 4, GL_FLOAT }, /* float */
+            { 1, GL_DOUBLE }, { 2, GL_DOUBLE }, { 3, GL_DOUBLE },
+                { 4, GL_DOUBLE }, /* double */
+            { 1, GL_BYTE }, { 2, GL_BYTE }, { 3, GL_BYTE },
+                { 4, GL_BYTE }, /* int8_t */
+            { 1, GL_UNSIGNED_BYTE }, { 2, GL_UNSIGNED_BYTE },
+                { 3, GL_UNSIGNED_BYTE }, { 4, GL_UNSIGNED_BYTE }, /* uint8_t */
+            { 1, GL_SHORT }, { 2, GL_SHORT }, { 3, GL_SHORT },
+                { 4, GL_SHORT }, /* int16_t */
+            { 1, GL_UNSIGNED_SHORT }, { 2, GL_UNSIGNED_SHORT }, { 3,
+                GL_UNSIGNED_SHORT }, { 4, GL_UNSIGNED_SHORT }, /* uint16_t */
+            { 1, GL_INT }, { 2, GL_INT }, { 3, GL_INT },
+                { 4, GL_INT }, /* int32_t */
+            { 1, GL_UNSIGNED_INT }, { 2, GL_UNSIGNED_INT },
+                { 3, GL_UNSIGNED_INT }, { 4, GL_UNSIGNED_INT }, /* uint32_t */
+        };
+
+        int type_index = m_streams[attr_index].stream_type;
+        if (type_index < 0 || type_index >= sizeof(tlut) / sizeof(*tlut))
+            type_index = 0;
+Log::Error("Size %d Type %d Stride %d offset %d\n", tlut[type_index].size,
+                              tlut[type_index].type,stride,offset);
+
+        glVertexAttribPointer((GLint)reg, tlut[type_index].size,
+                              tlut[type_index].type, GL_FALSE,
+                              stride, (GLvoid const *)(uintptr_t)offset);
+    }
 #endif
 }
 
@@ -306,7 +382,7 @@ void VertexBuffer::Unlock()
 #if defined USE_D3D9 || defined _XBOX
     m_data->m_vbo->Unlock();
 #elif !defined __CELLOS_LV2__ && !defined __ANDROID__
-    glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo);
     glBufferData(GL_ARRAY_BUFFER, m_data->m_size, m_data->m_memory,
                  GL_STATIC_DRAW);
 #endif
diff --git a/src/gpu/vertexbuffer.h b/src/gpu/vertexbuffer.h
index 679e3eba..7b29f973 100644
--- a/src/gpu/vertexbuffer.h
+++ b/src/gpu/vertexbuffer.h
@@ -164,6 +164,7 @@ public:
     ~VertexDeclaration();
 
     void Bind();
+    void Unbind();
     void SetStream(VertexBuffer *vb, ShaderAttrib attr1,
                                      ShaderAttrib attr2 = ShaderAttrib(),
                                      ShaderAttrib attr3 = ShaderAttrib(),
diff --git a/src/gradient.cpp b/src/gradient.cpp
index 4a6ae992..62d4f256 100644
--- a/src/gradient.cpp
+++ b/src/gradient.cpp
@@ -32,13 +32,8 @@ class GradientData
 
 private:
     Shader *shader;
-#if !defined USE_D3D9 && !defined _XBOX /* This file is meaningless on Xbox */
-
-    GLuint bufs[2];
-#if defined HAVE_GL_2X && !defined __APPLE__
-    GLuint vaos[1];
-#endif
-#endif
+    VertexDeclaration *m_vdecl;
+    VertexBuffer *m_vbo, *m_cbo;
 };
 
 /*
@@ -65,10 +60,23 @@ void Gradient::TickDraw(float deltams)
 {
     Entity::TickDraw(deltams);
 
-#if !defined USE_D3D9 && !defined _XBOX /* This file is meaningless on Xbox */
+    float const vertex[] = {   0.0f,   0.0f, 0.0f,
+                             640.0f,   0.0f, 0.0f,
+                               0.0f, 480.0f, 0.0f,
+                               0.0f, 480.0f, 0.0f,
+                             640.0f, 480.0f, 0.0f,
+                             640.0f,   0.0f, 0.0f, };
+
+    float const color[] = { 0.73f, 0.85f, 0.85f, 1.0f,
+                            0.73f, 0.85f, 0.85f, 1.0f,
+                            0.0f, 0.0f, 1.0f, 1.0f,
+                            0.0f, 0.0f, 1.0f, 1.0f,
+                            0.0f, 0.0f, 1.0f, 1.0f,
+                            0.73f, 0.85f, 0.85f, 1.0f, };
+
     if (!data->shader)
     {
-#if !defined __CELLOS_LV2__
+#if !defined __CELLOS_LV2__ && !defined USE_D3D9 && !defined _XBOX
         data->shader = Shader::Create(
             "#version 130\n"
             "\n"
@@ -156,22 +164,19 @@ void Gradient::TickDraw(float deltams)
             "    out_FragColor = col;"
             "}");
 #endif
-#if !defined __CELLOS_LV2__
-        glGenBuffers(2, data->bufs);
-#   if defined HAVE_GL_2X && !defined __APPLE__
-        glGenVertexArrays(1, data->vaos);
-#   endif
-#endif
+        data->m_vbo = new VertexBuffer(sizeof(vertex));
+        data->m_cbo = new VertexBuffer(sizeof(color));
+
+        data->m_vdecl = new VertexDeclaration(VertexStream<vec3>(VertexUsage::Position),
+                                              VertexStream<vec4>(VertexUsage::Color));
     }
 
     mat4 model_matrix = mat4(1.0f);
 
     ShaderUniform uni_mat;
-    GLuint attr_pos, attr_col;
-#if !defined __CELLOS_LV2__
-    attr_pos = data->shader->GetAttribLocation("in_Vertex");
-    attr_col = data->shader->GetAttribLocation("in_Color");
-#endif
+    ShaderAttrib attr_pos, attr_col;
+    attr_pos = data->shader->GetAttribLocation("in_Vertex", VertexUsage::Position, 0);
+    attr_col = data->shader->GetAttribLocation("in_Color", VertexUsage::Color, 0);
 
     data->shader->Bind();
 
@@ -182,61 +187,23 @@ void Gradient::TickDraw(float deltams)
     uni_mat = data->shader->GetUniformLocation("model_matrix");
     data->shader->SetUniform(uni_mat, model_matrix);
 
-    float const vertex[] = {   0.0f,   0.0f, 0.0f,
-                             640.0f,   0.0f, 0.0f,
-                               0.0f, 480.0f, 0.0f,
-                               0.0f, 480.0f, 0.0f,
-                             640.0f, 480.0f, 0.0f,
-                             640.0f,   0.0f, 0.0f, };
-
-    float const color[] = { 0.73f, 0.85f, 0.85f, 1.0f,
-                            0.73f, 0.85f, 0.85f, 1.0f,
-                            0.0f, 0.0f, 1.0f, 1.0f,
-                            0.0f, 0.0f, 1.0f, 1.0f,
-                            0.0f, 0.0f, 1.0f, 1.0f,
-                            0.73f, 0.85f, 0.85f, 1.0f, };
-
     data->shader->Bind();
+    data->m_vdecl->Bind();
 
-    /* Bind vertex, color and texture coordinate buffers */
-#if !defined __CELLOS_LV2__
-#   if defined HAVE_GL_2X && !defined __APPLE__
-    glBindVertexArray(data->vaos[0]);
-#   endif
-    glEnableVertexAttribArray(attr_pos);
-    glEnableVertexAttribArray(attr_col);
-
-    glBindBuffer(GL_ARRAY_BUFFER, data->bufs[0]);
-    glBufferData(GL_ARRAY_BUFFER, 18 * sizeof(GLfloat),
-                 vertex, GL_DYNAMIC_DRAW);
-    glVertexAttribPointer(attr_pos, 3, GL_FLOAT, GL_FALSE, 0, 0);
-
-    glBindBuffer(GL_ARRAY_BUFFER, data->bufs[1]);
-    glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat),
-                 color, GL_DYNAMIC_DRAW);
-    glVertexAttribPointer(attr_col, 4, GL_FLOAT, GL_FALSE, 0, 0);
-#else
-    glEnableClientState(GL_VERTEX_ARRAY);
-    glEnableClientState(GL_COLOR_ARRAY);
+    void *tmp = data->m_vbo->Lock(0, 0);
+    memcpy(tmp, vertex, sizeof(vertex));
+    data->m_vbo->Unlock();
 
-    glVertexPointer(3, GL_FLOAT, 0, vertex);
-    glColorPointer(4, GL_FLOAT, 0, color);
-#endif
+    tmp = data->m_cbo->Lock(0, 0);
+    memcpy(tmp, color, sizeof(color));
+    data->m_cbo->Unlock();
+
+    /* Bind vertex and color buffers */
+    data->m_vdecl->SetStream(data->m_vbo, attr_pos);
+    data->m_vdecl->SetStream(data->m_cbo, attr_col);
 
     /* Draw arrays */
     glDrawArrays(GL_TRIANGLES, 0, 6);
-
-#if !defined __CELLOS_LV2__
-#   if defined HAVE_GL_2X && !defined __APPLE__
-    glBindVertexArray(0);
-#   endif
-    glDisableVertexAttribArray(attr_pos);
-    glDisableVertexAttribArray(attr_col);
-#else
-    glDisableClientState(GL_VERTEX_ARRAY);
-    glDisableClientState(GL_COLOR_ARRAY);
-#endif
-#endif
 }
 
 Gradient::~Gradient()
diff --git a/src/scene.cpp b/src/scene.cpp
index 12cef5ad..1886bcc8 100644
--- a/src/scene.cpp
+++ b/src/scene.cpp
@@ -71,18 +71,8 @@ private:
     int ntiles;
     float angle;
 
-#if defined USE_D3D9
-    IDirect3DVertexDeclaration9 *m_vdecl;
-    IDirect3DVertexBuffer9 **bufs;
-#elif defined _XBOX
-    D3DVertexDeclaration *m_vdecl;
-    D3DVertexBuffer **bufs;
-#else
-#   if defined HAVE_GL_2X && !defined __APPLE__
-    GLuint vao;
-#   endif
-    GLuint *bufs;
-#endif
+    VertexDeclaration *m_vdecl;
+    VertexBuffer **bufs;
     int nbufs;
 
     static Scene *scene;
@@ -104,19 +94,8 @@ Scene::Scene(float angle)
     data->bufs = 0;
     data->nbufs = 0;
 
-#if defined _XBOX || defined USE_D3D9
-    D3DVERTEXELEMENT9 const elements[] =
-    {
-        { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
-        { 1, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
-        D3DDECL_END()
-    };
-    g_d3ddevice->CreateVertexDeclaration(elements, &data->m_vdecl);
-#else
-#   if defined HAVE_GL_2X && !defined __APPLE__
-    glGenVertexArrays(1, &data->vao);
-#   endif
-#endif
+    data->m_vdecl = new VertexDeclaration(VertexStream<vec3>(VertexUsage::Position),
+                                          VertexStream<vec2>(VertexUsage::TexCoord));
 }
 
 Scene::~Scene()
@@ -127,11 +106,8 @@ Scene::~Scene()
     /* FIXME: this must be done while the GL context is still active.
      * Change the code architecture to make sure of that. */
     /* XXX: The test is necessary because of a crash with PSGL. */
-    if (data->nbufs > 0)
-        glDeleteBuffers(data->nbufs, data->bufs);
-#   if defined HAVE_GL_2X && !defined __APPLE__
-    glDeleteVertexArrays(1, &data->vao);
-#   endif
+    for (int i = 0; i < data->nbufs; i++)
+        delete data->bufs[i];
     free(data->bufs);
 #endif
     delete data;
@@ -337,13 +313,9 @@ void Scene::Render() // XXX: rename to Blit()
     // XXX: end of debug stuff
 
     ShaderUniform uni_mat, uni_tex;
-#if defined USE_D3D9 || defined _XBOX
-    /* Nothing? */
-#elif !defined __CELLOS_LV2__
-    int attr_pos, attr_tex;
-    attr_pos = stdshader->GetAttribLocation("in_Position");
-    attr_tex = stdshader->GetAttribLocation("in_TexCoord");
-#endif
+    ShaderAttrib attr_pos, attr_tex;
+    attr_pos = stdshader->GetAttribLocation("in_Position", VertexUsage::Position, 0);
+    attr_tex = stdshader->GetAttribLocation("in_TexCoord", VertexUsage::TexCoord, 0);
 
     stdshader->Bind();
 
@@ -354,10 +326,10 @@ void Scene::Render() // XXX: rename to Blit()
     uni_mat = stdshader->GetUniformLocation("model_matrix");
     stdshader->SetUniform(uni_mat, data->model_matrix);
 
+    data->m_vdecl->Bind();
 #if defined USE_D3D9 || defined _XBOX
     //g_d3ddevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
     g_d3ddevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
-    g_d3ddevice->SetVertexDeclaration(data->m_vdecl);
 #else
     uni_tex = stdshader->GetUniformLocation("in_Texture");
     stdshader->SetUniform(uni_tex, 0);
@@ -380,23 +352,14 @@ void Scene::Render() // XXX: rename to Blit()
         /* Generate new vertex / texture coord buffers if necessary */
         if (buf + 2 > data->nbufs)
         {
-#if defined USE_D3D9
-            data->bufs = (IDirect3DVertexBuffer9 **)realloc(data->bufs, (buf + 2) * sizeof(IDirect3DVertexBuffer9 *));
-#elif defined _XBOX
-            data->bufs = (D3DVertexBuffer **)realloc(data->bufs, (buf + 2) * sizeof(D3DVertexBuffer *));
-#else
-            data->bufs = (uint32_t *)realloc(data->bufs, (buf + 2) * sizeof(uint32_t));
-            glGenBuffers(buf + 2 - data->nbufs, data->bufs + data->nbufs);
-#endif
+            data->bufs = (VertexBuffer **)realloc(data->bufs, (buf + 2) * sizeof(VertexBuffer *));
             data->nbufs = buf + 2;
         }
-#if defined USE_D3D9 || defined _XBOX
         else
         {
-            data->bufs[buf]->Release();
-            data->bufs[buf + 1]->Release();
+            delete data->bufs[buf];
+            delete data->bufs[buf + 1];
         }
-#endif
 
         /* Count how many quads will be needed */
         for (n = i + 1; n < data->ntiles; n++)
@@ -404,20 +367,10 @@ void Scene::Render() // XXX: rename to Blit()
                 break;
 
         /* Create a vertex array object */
-        float *vertex, *texture;
-#if defined USE_D3D9 || defined _XBOX
-        if (FAILED(g_d3ddevice->CreateVertexBuffer(6 * 3 * (n - i) * sizeof(float), D3DUSAGE_WRITEONLY, NULL, D3DPOOL_MANAGED, &data->bufs[buf], NULL)))
-            exit(0);
-        if (FAILED(data->bufs[buf]->Lock(0, 0, (void **)&vertex, 0)))
-            exit(0);
-        if (FAILED(g_d3ddevice->CreateVertexBuffer(6 * 2 * (n - i) * sizeof(float), D3DUSAGE_WRITEONLY, NULL, D3DPOOL_MANAGED, &data->bufs[buf + 1], NULL)))
-            exit(0);
-        if (FAILED(data->bufs[buf + 1]->Lock(0, 0, (void **)&texture, 0)))
-            exit(0);
-#else
-        vertex = (float *)malloc(6 * 3 * (n - i) * sizeof(float));
-        texture = (float *)malloc(6 * 2 * (n - i) * sizeof(float));
-#endif
+        data->bufs[buf] = new VertexBuffer(6 * 3 * (n - i) * sizeof(float));
+        float *vertex = (float *)data->bufs[buf]->Lock(0, 0);
+        data->bufs[buf + 1] = new VertexBuffer(6 * 2 * (n - i) * sizeof(float));
+        float *texture = (float *)data->bufs[buf + 1]->Lock(0, 0);
 
         for (int j = i; j < n; j++)
         {
@@ -427,62 +380,29 @@ void Scene::Render() // XXX: rename to Blit()
                             vertex + 18 * (j - i), texture + 12 * (j - i));
         }
 
-#if defined USE_D3D9 || defined _XBOX
-        data->bufs[buf]->Unlock();
-        data->bufs[buf + 1]->Unlock();
-#endif
-
         stdshader->Bind();
 
         /* Bind texture */
         data->tiles[i].tileset->Bind();
 
-        /* Bind vertex, color and texture coordinate buffers */
+        /* Bind vertex and texture coordinate buffers */
+        data->m_vdecl->SetStream(data->bufs[buf], attr_pos);
+        data->m_vdecl->SetStream(data->bufs[buf + 1], attr_tex);
+
+        /* Draw arrays */
 #if defined USE_D3D9 || defined _XBOX
-        g_d3ddevice->SetStreamSource(0, data->bufs[data->nbufs - 2], 0, 6 * 3 * (n - i) * sizeof(float));
-        g_d3ddevice->SetStreamSource(1, data->bufs[data->nbufs - 1], 0, 6 * 2 * (n - i) * sizeof(float));
         g_d3ddevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, (n - i) * 6);
 #else
-#   if defined HAVE_GL_2X && !defined __APPLE__
-        glBindVertexArray(data->vao);
-#   endif
-#   if !defined __CELLOS_LV2__ // Use cgGLEnableClientState etc.
-        glEnableVertexAttribArray(attr_pos);
-        glEnableVertexAttribArray(attr_tex);
-
-        glBindBuffer(GL_ARRAY_BUFFER, data->bufs[buf]);
-        glBufferData(GL_ARRAY_BUFFER, 18 * (n - i) * sizeof(GLfloat),
-                     vertex, GL_STATIC_DRAW);
-        glVertexAttribPointer(attr_pos, 3, GL_FLOAT, GL_FALSE, 0, 0);
-
-        glBindBuffer(GL_ARRAY_BUFFER, data->bufs[buf + 1]);
-        glBufferData(GL_ARRAY_BUFFER, 12 * (n - i) * sizeof(GLfloat),
-                     texture, GL_STATIC_DRAW);
-        glVertexAttribPointer(attr_tex, 2, GL_FLOAT, GL_FALSE, 0, 0);
-#   else
-        glEnableClientState(GL_VERTEX_ARRAY);
-        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-
-        glVertexPointer(3, GL_FLOAT, 0, vertex);
-        glTexCoordPointer(2, GL_FLOAT, 0, texture);
-#   endif
-
-        /* Draw arrays */
         glDrawArrays(GL_TRIANGLES, 0, (n - i) * 6);
 
 #   if defined HAVE_GL_2X && !defined __APPLE__
         glBindVertexArray(0);
 #   endif
 #   if !defined __CELLOS_LV2__ // Use cgGLEnableClientState etc.
-        glDisableVertexAttribArray(attr_pos);
-        glDisableVertexAttribArray(attr_tex);
 #   else
         glDisableClientState(GL_VERTEX_ARRAY);
         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 #   endif
-
-        free(vertex);
-        free(texture);
 #endif
     }
 
diff --git a/test/debug/quad.cpp b/test/debug/quad.cpp
index 7792120f..360bbde5 100644
--- a/test/debug/quad.cpp
+++ b/test/debug/quad.cpp
@@ -33,7 +33,7 @@ int main(int argc, char **argv)
 
     /* Register some debug stuff */
     new DebugFps(5, 5);
-    new DebugQuad();
+    //new DebugQuad();
 
     app.Run();
 
diff --git a/test/tutorial/tut01.cpp b/test/tutorial/tut01.cpp
index 373c8976..4d5a4145 100644
--- a/test/tutorial/tut01.cpp
+++ b/test/tutorial/tut01.cpp
@@ -126,11 +126,12 @@ public:
         glDrawArrays(GL_TRIANGLES, 0, 3);
 #endif
 
+        m_vdecl->Unbind();
 #if defined _XBOX || defined USE_D3D9
         /* FIXME: do we need to unset anything here? */
 #elif !defined __CELLOS_LV2__ && !defined __ANDROID__ && !defined __APPLE__
-        glDisableVertexAttribArray(m_attrib);
-        glBindBuffer(GL_ARRAY_BUFFER, 0);
+        //glDisableVertexAttribArray(m_attrib);
+        //glBindBuffer(GL_ARRAY_BUFFER, 0);
 #elif !defined __CELLOS_LV2__ && !defined __ANDROID__ && !defined __APPLE__
         /* Never used for now */
         glDisableVertexAttribArray(m_attrib);
diff --git a/test/tutorial/tut02.cpp b/test/tutorial/tut02.cpp
index 2a2c9886..10b29c94 100644
--- a/test/tutorial/tut02.cpp
+++ b/test/tutorial/tut02.cpp
@@ -191,14 +191,6 @@ public:
         g_d3ddevice->SetIndices(m_ibo);
         g_d3ddevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 0, 0, sizeof(m_indices) / sizeof(*m_indices));
 #elif !defined __CELLOS_LV2__ && !defined __ANDROID__ && !defined __APPLE__
-        glEnableVertexAttribArray(m_coord);
-        glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-        glVertexAttribPointer(m_coord, 3, GL_FLOAT, GL_FALSE, 0, 0);
-
-        glEnableVertexAttribArray(m_color);
-        glBindBuffer(GL_ARRAY_BUFFER, m_cbo);
-        glVertexAttribPointer(m_color, 3, GL_FLOAT, GL_FALSE, 0, 0);
-
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo);
         int size;
         glGetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
@@ -206,8 +198,6 @@ public:
 
         glDrawElements(GL_TRIANGLES, size / sizeof(uint16_t), GL_UNSIGNED_SHORT, 0);
 
-        glDisableVertexAttribArray(m_coord);
-        glDisableVertexAttribArray(m_color);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
 #else
         glEnableClientState(GL_VERTEX_ARRAY);
diff --git a/test/tutorial/tut03.cpp b/test/tutorial/tut03.cpp
index 8b2d1b5b..79cd155c 100644
--- a/test/tutorial/tut03.cpp
+++ b/test/tutorial/tut03.cpp
@@ -427,6 +427,7 @@ public:
 
     virtual void TickDraw(float deltams)
     {
+Log::Error("Tick Fractal\n");
         WorldEntity::TickDraw(deltams);
 
         static float const vertices[] =
@@ -666,50 +667,28 @@ public:
                 "}"
 #endif
             );
-#if !defined _XBOX && !defined USE_D3D9
-            m_vertexattrib = m_shader->GetAttribLocation("a_Vertex");
-            m_texattrib = m_shader->GetAttribLocation("a_TexCoord");
-#endif
+            m_vertexattrib = m_shader->GetAttribLocation("a_Vertex", VertexUsage::Position, 0);
+            m_texattrib = m_shader->GetAttribLocation("a_TexCoord", VertexUsage::TexCoord, 0);
             m_texeluni = m_shader->GetUniformLocation("u_TexelSize");
             m_screenuni = m_shader->GetUniformLocation("u_ScreenSize");
             m_zoomuni = m_shader->GetUniformLocation("u_ZoomSettings");
-            m_ready = true;
 
             m_vdecl =
               new VertexDeclaration(VertexStream<vec2>(VertexUsage::Position),
                                     VertexStream<vec2>(VertexUsage::TexCoord));
-#if !defined __CELLOS_LV2__ && !defined __ANDROID__ && !defined _XBOX && !defined USE_D3D9
-            /* Method 1: store vertex buffer on the GPU memory */
-            glGenBuffers(1, &m_vbo);
-            glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-            glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices,
-                         GL_STATIC_DRAW);
-            glGenBuffers(1, &m_tbo);
-            glBindBuffer(GL_ARRAY_BUFFER, m_tbo);
-            glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords,
-                         GL_STATIC_DRAW);
-#elif !defined __CELLOS_LV2__ && !defined __ANDROID__ && !defined _XBOX && !defined USE_D3D9
-            /* Method 2: upload vertex information at each frame */
-#elif defined _XBOX || defined USE_D3D9
-            if (FAILED(g_d3ddevice->CreateVertexBuffer(sizeof(vertices), D3DUSAGE_WRITEONLY, NULL, D3DPOOL_MANAGED, &m_vbo, NULL)))
-                exit(0);
-            vec2 *tmp1;
-            if (FAILED(m_vbo->Lock(0, 0, (void **)&tmp1, 0)))
-                exit(0);
-            memcpy(tmp1, vertices, sizeof(vertices));
+            m_vbo = new VertexBuffer(sizeof(vertices));
+            m_tbo = new VertexBuffer(sizeof(texcoords));
+
+            void *tmp = m_vbo->Lock(0, 0);
+            memcpy(tmp, vertices, sizeof(vertices));
             m_vbo->Unlock();
 
-            if (FAILED(g_d3ddevice->CreateVertexBuffer(sizeof(texcoords), D3DUSAGE_WRITEONLY, NULL, D3DPOOL_MANAGED, &m_tbo, NULL)))
-                exit(0);
-            vec2 *tmp2;
-            if (FAILED(m_tbo->Lock(0, 0, (void **)&tmp2, 0)))
-                exit(0);
-            memcpy(tmp2, texcoords, sizeof(texcoords));
+            tmp = m_tbo->Lock(0, 0);
+            memcpy(tmp, texcoords, sizeof(texcoords));
             m_tbo->Unlock();
-#else
-#endif
 
             /* FIXME: this object never cleans up */
+            m_ready = true;
         }
 
 #if defined _XBOX || defined USE_D3D9
@@ -762,29 +741,18 @@ public:
         m_shader->SetUniform(m_screenuni, m_screen_settings);
         m_shader->SetUniform(m_zoomuni, m_zoom_settings);
         m_vdecl->Bind();
+        m_vdecl->SetStream(m_vbo, m_vertexattrib);
+        m_vdecl->SetStream(m_tbo, m_texattrib);
 #if defined _XBOX || defined USE_D3D9
         g_d3ddevice->SetTexture(0, m_tex);
         //g_d3ddevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
         g_d3ddevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
-        g_d3ddevice->SetStreamSource(0, m_vbo, 0, sizeof(*vertices));
-        g_d3ddevice->SetStreamSource(1, m_tbo, 0, sizeof(*texcoords));
-#elif !defined __CELLOS_LV2__ && !defined __ANDROID__
-        glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-        glEnableVertexAttribArray(m_vertexattrib);
-        glVertexAttribPointer(m_vertexattrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
-
-        glBindBuffer(GL_ARRAY_BUFFER, m_tbo);
-        glEnableVertexAttribArray(m_texattrib);
-        glVertexAttribPointer(m_texattrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
 #elif !defined __CELLOS_LV2__ && !defined __ANDROID__
-        /* Never used for now */
-        //glEnableVertexAttribArray(m_vertexattrib);
-        //glVertexAttribPointer(m_vertexattrib, 2, GL_FLOAT, GL_FALSE, 0, vertices);
 #else
-        glEnableClientState(GL_VERTEX_ARRAY);
-        glVertexPointer(2, GL_FLOAT, 0, vertices);
-        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-        glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
+        //glEnableClientState(GL_VERTEX_ARRAY);
+        //glVertexPointer(2, GL_FLOAT, 0, vertices);
+        //glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        //glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
 #endif
 
 #if defined _XBOX || defined USE_D3D9
@@ -796,18 +764,20 @@ public:
 
 #if defined _XBOX || defined USE_D3D9
 
+        m_vdecl->Unbind();
 #elif !defined __CELLOS_LV2__ && !defined __ANDROID__
-        glDisableVertexAttribArray(m_vertexattrib);
-        glDisableVertexAttribArray(m_texattrib);
-        glBindBuffer(GL_ARRAY_BUFFER, 0);
+        //glDisableVertexAttribArray(m_vertexattrib);
+        //glDisableVertexAttribArray(m_texattrib);
+        //glBindBuffer(GL_ARRAY_BUFFER, 0);
 #elif !defined __CELLOS_LV2__ && !defined __ANDROID__
         /* Never used for now */
         //glDisableVertexAttribArray(m_vertexattrib);
         //glDisableVertexAttribArray(m_texattrib);
 #else
-        glDisableClientState(GL_VERTEX_ARRAY);
-        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+        //glDisableClientState(GL_VERTEX_ARRAY);
+        //glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 #endif
+Log::Error("~Tick Fractal\n");
     }
 
 private:
@@ -820,23 +790,20 @@ private:
     double m_window2world;
     f64vec2 m_texel2world;
     u8vec4 *m_pixels, *m_tmppixels, *m_palette;
+
     Shader *m_shader;
+    ShaderAttrib m_vertexattrib, m_texattrib;
+    ShaderUniform m_texeluni, m_screenuni, m_zoomuni;
+
     VertexDeclaration *m_vdecl;
+    VertexBuffer *m_vbo, *m_tbo;
 #if defined USE_D3D9
     IDirect3DTexture9 *m_tex;
-    IDirect3DVertexBuffer9 *m_vbo, *m_tbo;
 #elif defined _XBOX
     D3DTexture *m_tex;
-    D3DVertexBuffer *m_vbo, *m_tbo;
 #else
     GLuint m_texid;
-#   if !defined __CELLOS_LV2__ && !defined __ANDROID__
-    GLuint m_vbo, m_tbo;
-    GLuint m_tco;
-#   endif
 #endif
-    int m_vertexattrib, m_texattrib;
-    ShaderUniform m_texeluni, m_screenuni, m_zoomuni;
     int m_frame, m_slices, m_dirty[4];
     bool m_ready, m_drag;