diff --git a/basegraph.cpp b/basegraph.cpp
index dddf1038..26390ae0 100644
--- a/basegraph.cpp
+++ b/basegraph.cpp
@@ -263,8 +263,8 @@ void setGLProjection(int col) {
 
   GLERR("setGLProjection #1");
 
-#ifndef GLES_ONLY  
   glEnable(GL_BLEND);
+#ifndef GLES_ONLY  
   if(vid.antialias & AA_LINES) {
     glEnable(GL_LINE_SMOOTH);
     glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
@@ -443,8 +443,6 @@ void init_glfont(int size) {
   GLERR("initfont");
   }
 
-GLfloat tver[24];
-
 int gl_width(int size, const char *s) {
   int gsiz = size;
   if(size > vid.fsize || size > 72) gsiz = 72;
@@ -467,8 +465,27 @@ int gl_width(int size, const char *s) {
   return x;
   }
 
-bool gl_print(int x, int y, int shift, int size, const char *s, int color, int align) {
+namespace glhr { void texture_vertices(GLfloat *f, int qty, int stride = 2) {
+  #if CAP_SHADER
+  glVertexAttribPointer(aTexture, stride, GL_FLOAT, GL_FALSE, stride * sizeof(GLfloat), f);
+  #else
+  glTexCoordPointer(stride, GL_FLOAT, 0, f);
+  #endif
+  } 
+ void oldvertices(GLfloat *f, int qty) {
+  #if CAP_SHADER
+  glVertexAttribPointer(aPosition, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), f);
+  #else
+  glVertexPointer(3, GL_FLOAT, 0, f);
+  #endif
+  // #endif
+  }
+ }
 
+GLfloat otver[24];
+vector<glhr::textured_vertex> tver(4);
+
+bool gl_print(int x, int y, int shift, int size, const char *s, int color, int align) {
   int gsiz = size;
   if(size > vid.fsize || size > 72) gsiz = 72;
 
@@ -512,12 +529,16 @@ bool gl_print(int x, int y, int shift, int size, const char *s, int color, int a
       stereo::set_mask(ed);
       glBindTexture(GL_TEXTURE_2D, f.textures[tabid]);
 
-      tver[1] = tver[10] = -hi;
-      tver[6] = tver[9] = wi;
-      tver[12+3] = tver[12+5] = fy;
-      tver[12+4] = tver[12+6] = fx;
-      glhr::vertices(tver, 4);
-      glhr::texture_vertices(tver+12, 4);
+      tver[0].coords[1] = -hi;
+      tver[3].coords[1] = -hi;
+      tver[2].coords[0] = wi;
+      tver[3].coords[0] = wi;
+      tver[1].texture[1] = fy;
+      tver[2].texture[1] = fy;
+      tver[2].texture[0] = fx;
+      tver[3].texture[0] = fx;
+      
+      glhr::prepare(tver);
       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
       }
     
@@ -530,6 +551,7 @@ bool gl_print(int x, int y, int shift, int size, const char *s, int color, int a
  
   return clicked;
   }
+
 #endif
 
 purehookset hooks_resetGL;
@@ -872,7 +894,7 @@ void drawCircle(int x, int y, int size, int color) {
   if(vid.usingGL) {
     glhr::be_nontextured();
     glhr::set_modelview(glhr::id());
-    qglcoords = 0;
+    glcoords.clear();
     glhr::color2(color);
     x -= vid.xcenter; y -= vid.ycenter;
     int pts = size * 4;
@@ -880,13 +902,9 @@ void drawCircle(int x, int y, int size, int color) {
     if(ISMOBILE && pts > 72) pts = 72;
     for(int r=0; r<pts; r++) {
       float rr = (M_PI * 2 * r) / pts;
-      glcoords[r][0] = x + size * sin(rr);
-      glcoords[r][1] = y + size * cos(rr);
-      glcoords[r][2] = stereo::scrdist;
+      glcoords.push_back(make_array<GLfloat>(x + size * sin(rr), y + size * cos(rr), stereo::scrdist));
       }
-
-    qglcoords = pts; 
-    activateGlcoords();
+    glhr::vertices(glcoords);
     glDrawArrays(GL_LINE_LOOP, 0, pts);
     return;
     }
@@ -1057,12 +1075,12 @@ void setvideomode() {
   if(vid.usingGL) {
     flags = SDL_OPENGL | SDL_HWSURFACE | SDL_GL_DOUBLEBUFFER;
     SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 1);
-
+#if !ISWEB
     if(vid.antialias & AA_MULTI) {
       SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
       SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, (vid.antialias & AA_MULTI16) ? 16 : 4);
       }
-
+#endif
     }
 #endif
 
@@ -1088,10 +1106,12 @@ void setvideomode() {
 
 #if CAP_GL
   if(vid.usingGL) {
+#if !ISWEB
     if(vid.antialias & AA_MULTI) 
       glEnable(GL_MULTISAMPLE);
     else
       glDisable(GL_MULTISAMPLE);
+#endif
   
     glViewport(0, 0, vid.xres, vid.yres);
     glhr::init();
diff --git a/graph.cpp b/graph.cpp
index e6da68e9..fe7f9aa6 100644
--- a/graph.cpp
+++ b/graph.cpp
@@ -2206,8 +2206,8 @@ void sumaura(int v) {
     }  
   aurac[AURA][v] = aurac[0][v];
   }
-  
-float coltab[4][4];
+
+vector<glhr::colored_vertex> auravertices;
 
 void drawaura() {
   if(!haveaura()) return;
@@ -2270,13 +2270,8 @@ void drawaura() {
 #endif
 
 #if CAP_GL
-  glhr::switch_mode(glhr::gmVarColored);
-  glhr::set_modelview(glhr::id());
   setcameraangle(true);
   
-  glhr::color_vertices(coltab[0], 4);
-  activateGlcoords();
-  
   float cx[AURA+1][11][5];
 
   double facs[11] = {1, 1.01, 1.02, 1.04, 1.08, 1.70, 1.95, 1.5, 2, 6, 10};
@@ -2301,22 +2296,21 @@ void drawaura() {
       cx[r][z][u+2] = bak[u] + (aurac[rm][u] / (aurac[rm][3]+.1) - bak[u]) * cmul[z];
     }
   
-  for(int u=0; u<4; u++) glcoords[u][2] = stereo::scrdist;
-  for(int u=0; u<4; u++) coltab[u][3] = 1;
-
+  auravertices.clear();
   for(int r=0; r<AURA; r++) for(int z=0;z<10;z++) {
-    for(int c=0; c<4; c++) {
-      int br = (c == 1 || c == 2) ? r+1 : r;
-      int bz = (c == 3 || c == 2) ? z+1 : z;
-      glcoords[c][0] = cx[br][bz][0]; 
-      glcoords[c][1] = cx[br][bz][1];   
-      coltab[c][0] = min<float>(cx[br][bz][2], 1);
-      coltab[c][1] = min<float>(cx[br][bz][3], 1); 
-      coltab[c][2] = min<float>(cx[br][bz][4], 1); 
+    for(int c=0; c<6; c++) {
+      int br = (c == 1 || c == 3 || c == 5) ? r+1 : r;
+      int bz = (c == 2 || c == 4 || c == 5) ? z+1 : z;
+      auravertices.emplace_back(
+        cx[br][bz][0], cx[br][bz][1], cx[br][bz][2], cx[br][bz][3], cx[br][bz][4]
+        );
       }
-      
-    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
     }
+  glhr::switch_mode(glhr::gmVarColored);
+  glhr::set_modelview(glhr::id());
+  glhr::prepare(auravertices);
+  glDrawArrays(GL_TRIANGLES, 0, size(auravertices));    
+
 
   setcameraangle(false);
 #endif
@@ -3118,7 +3112,7 @@ void warpfloor(cell *c, const transmatrix& V, int col, int prio, bool warp) {
   if(shmup::on || nonbitrunc) warp = false;
 #if CAP_TEXTURE
   if(qfi.tinf) {
-    queuetable(V*qfi.spin, &qfi.tinf->vertices[0], size(qfi.tinf->vertices) / 3, 0, texture::recolor(col), prio);
+    queuetable(V*qfi.spin, qfi.tinf->vertices, size(qfi.tinf->vertices), 0, texture::recolor(col), prio);
     lastptd().u.poly.tinf = qfi.tinf;
     }
   else 
diff --git a/hyper.h b/hyper.h
index e502d366..b9b1fa30 100644
--- a/hyper.h
+++ b/hyper.h
@@ -2020,12 +2020,16 @@ void drawqueue();
 typedef float GLfloat;
 #endif
 
+typedef array<GLfloat, 3> glvec3;
+typedef array<GLfloat, 4> glvec4;
+typedef glvec3 glvertex;
+
 struct textureinfo {
   transmatrix M;
   int texture_id;
   vector<array<hyperpoint, 3>> triangles;
-  vector<GLfloat> vertices;
-  vector<GLfloat> tvertices; 
+  vector<glvertex> vertices;
+  vector<glvertex> tvertices; 
   cell *c;
   vector<transmatrix> matrices;
   
@@ -2035,9 +2039,8 @@ struct textureinfo {
 
 struct qpoly {
       transmatrix V;
-      GLfloat *tab;
-      int curveindex;
-      int cnt;
+      const vector<glvertex> *tab;
+      int offset, cnt;
       int outline;
       double minwidth;
       int flags;
@@ -2668,3 +2671,6 @@ string helptitle(string s, int col);
 pair<int, int> cell_to_pair(cell *c);
 extern bool nohud, nofps;
 
+template<class T> array<T, 3> make_array(T a, T b, T c) { array<T,3> x; x[0] = a; x[1] = b; x[2] = c; return x; }
+template<class T> array<T, 2> make_array(T a, T b) { array<T,2> x; x[0] = a; x[1] = b; return x; }
+
diff --git a/hyperweb.cpp b/hyperweb.cpp
index c67bb39b..b95ebec4 100644
--- a/hyperweb.cpp
+++ b/hyperweb.cpp
@@ -11,6 +11,7 @@
 #define CAP_SDLTTF 0
 #define CAP_SHMUP 0
 #define CAP_RUG 1
+#define GLES_ONLY
 
 #ifdef FAKEWEB
 void mainloopiter();
@@ -62,7 +63,7 @@ void showDemo() {
   dialog::addItem(XLAT("play"), 'f');
   dialog::addItem(XLAT("tutorial"), 'T');
   dialog::addItem(XLAT("help"), 'h'); dialog::lastItem().keycaption += " / F1";
-  dialog::addItem(XLAT("toggle high detail"), 'a');
+  // dialog::addItem(XLAT("toggle high detail"), 'a');
   dialog::addBreak(100);
 
   dialog::addTitle("highlights", 0xC00000, 120);
@@ -110,7 +111,8 @@ void showDemo() {
   }
 
 void initweb() {
-  toggleanim(false);
-  // pushScreen(showDemo);
+  rug::renderonce = true;
+  // toggleanim(false);
+  pushScreen(showDemo);
   }
 
diff --git a/init.cpp b/init.cpp
index 0f8e5941..f3e1f89f 100644
--- a/init.cpp
+++ b/init.cpp
@@ -315,12 +315,12 @@ typedef unsigned int Uint32;
 #endif
 
 #if ISWEB
-inline Uint8 *SDL_GetKeyState(void *v) { static Uint8 tab[1024]; return tab; }
+extern "C" {
+  Uint8 *SDL_GetKeyState(void*);
+}
+// inline Uint8 *SDL_GetKeyState(void *v) { static Uint8 tab[1024]; return tab; }
 #endif
 
-/* extern "C" {
-  Uint8 *SDL_GetKeyState(void*);
-} */
 
 #ifndef CAP_GLEW
 #define CAP_GLEW (CAP_GL && !ISMOBILE && !ISMAC && !ISLINUX && !ISWEB)
@@ -645,8 +645,6 @@ int getticks();
 void shareScore(MOBPAR_FORMAL);
 #endif
 
-int mobile_xres, mobile_yres;
-
 void mobile_draw(MOBPAR_FORMAL) {
 
   optimizeview();
diff --git a/mapeditor.cpp b/mapeditor.cpp
index 53174c29..2f6d3780 100644
--- a/mapeditor.cpp
+++ b/mapeditor.cpp
@@ -1128,7 +1128,7 @@ namespace mapeditor {
       dsCur->rots = 1;
       
       for(auto& v: symmetriesAt)
-        if(p.tab == &ourshape[v[0]*3]) {
+        if(v[0] == p.offset) {
           dsCur->rots = v[1];
           dsCur->sym = v[2] == 2;
           }
@@ -1136,7 +1136,7 @@ namespace mapeditor {
       int d = dsCur->rots * (dsCur->sym ? 2 : 1);
       
       for(int i=0; i < cnt/d; i++)
-        dsCur->list.push_back(p.V * hpxyz(p.tab[3*i], p.tab[3*i+1], p.tab[3*i+2]));
+        dsCur->list.push_back(p.V * glhr::gltopoint((*p.tab)[i+p.offset]));
       
       layer++;      
       if(layer == USERLAYERS) break;
diff --git a/polygons.cpp b/polygons.cpp
index 3b2f3183..691cdb6f 100644
--- a/polygons.cpp
+++ b/polygons.cpp
@@ -108,45 +108,16 @@ SDL_Surface *aux;
 vector<polytodraw*> ptds2;
 #define POLYMAX 60000
 
-GLfloat glcoords[POLYMAX][3];
-int qglcoords;
-
-GLfloat *ourshape = NULL;
+vector<array<GLfloat, 3>> glcoords, ourshape;
 
 void initPolyForGL() {
+
+  ourshape.clear();
   
-  if(ourshape) delete[] ourshape;
-  ourshape = new GLfloat[3 * qhpc];
+  for(int i=0; i<qhpc; i++)
+    ourshape.push_back(make_array<GLfloat>(hpc[i][0], hpc[i][1], hpc[i][2]));
   
-  // GLfloat ourshape[3*qhpc];
-  
-  int id = 0;
-  for(int i=0; i<qhpc; i++) {
-    ourshape[id++] = hpc[i][0];
-    ourshape[id++] = hpc[i][1];
-    ourshape[id++] = hpc[i][2];
-    }
-
-#if CAP_GL  
-  glhr::currentvertices = NULL;
-#endif
-  }
-#endif
-
-#if CAP_GL
-
-GLuint shapebuffer;
-
-extern GLfloat *ourshape;
-
-void activateShapes() {
-  if(glhr::currentvertices != ourshape) {
-    glhr::vertices(ourshape, qhpc);
-    }
-  }
-
-void activateGlcoords() {
-  glhr::vertices(glcoords[0], qglcoords);
+  glhr::store_in_buffer(ourshape);
   }
 #endif
 
@@ -157,21 +128,13 @@ int polyx[POLYMAX], polyxr[POLYMAX], polyy[POLYMAX];
 
 int poly_flags;
 
-hyperpoint gltopoint(GLfloat t[3]) {
-  hyperpoint h;
-  h[0] = t[0]; h[1] = t[1]; h[2] = t[2];
-  return h;
-  }
-
 void add1(const hyperpoint& H) {
-  for(int i=0; i<3; i++) glcoords[qglcoords][i] = H[i];
+  glcoords.push_back(make_array<GLfloat>(H[0], H[1], H[2])); 
   }  
 
 int spherespecial, spherephase;
 
 void addpoint(const hyperpoint& H) {
-  if(qglcoords >= POLYMAX) return;
-
   if(true) {
     hyperpoint Hscr;
     applymodel(H, Hscr);
@@ -201,11 +164,10 @@ void addpoint(const hyperpoint& H) {
     glcoords[qglcoords][2] += vid.alpha;
     // glcoords[qglcoords][2] = 1; // EUCSCALE;
     } */
-  qglcoords++;
   }
 
 void coords_to_poly() {
-  polyi = qglcoords;
+  polyi = size(glcoords);
   for(int i=0; i<polyi; i++) {
     // printf("%lf %lf\n", double(glcoords[i][0]), double(glcoords[i][1]));
 
@@ -215,11 +177,9 @@ void coords_to_poly() {
     }
   }
 
-void addpoly(const transmatrix& V, GLfloat *tab, int cnt) {
-  while(cnt--) {
-    addpoint(V*gltopoint(tab));
-    tab += 3;
-    }
+void addpoly(const transmatrix& V, const vector<glvertex> &tab, int ofs, int cnt) {
+  for(int i=ofs; i<ofs+cnt; i++)
+    addpoint(V*glhr::gltopoint(tab[i]));
   }
 
 #if CAP_SDLGFX
@@ -241,9 +201,9 @@ void filledPolygonColorI(SDL_Surface *s, int* px, int *py, int polyi, int col) {
 #endif
 
 #if CAP_TEXTURE
-void drawTexturedTriangle(SDL_Surface *s, int *px, int *py, GLfloat *tv, int col) {
+void drawTexturedTriangle(SDL_Surface *s, int *px, int *py, glvertex *tv, int col) {
   transmatrix source = {{{ld(px[0]),ld(px[1]),ld(px[2])}, {ld(py[0]),ld(py[1]),ld(py[2])}, {1,1,1}}};
-  transmatrix target = {{{tv[0],tv[3],tv[6]}, {tv[1],tv[4],tv[7]}, {1,1,1}}};
+  transmatrix target = {{{tv[0][0],tv[1][0],tv[2][0]}, {tv[0][1],tv[1][1],tv[2][1]}, {1,1,1}}};
   transmatrix isource = inverse(source);
   int minx = px[0], maxx = px[0];
   int miny = py[0], maxy = py[0];
@@ -299,36 +259,41 @@ void glapplymatrix(const transmatrix& V) {
   glhr::set_modelview(glhr::as_glmatrix(mat));
   }
 
-int tinfshift;
-
-void gldraw(int useV, const transmatrix& V, int ps, int pq, int col, int outline, int flags, textureinfo *tinf) {
+void setmatrix(int useV, const transmatrix& V) {
+  if(useV == 1) {
+    glapplymatrix(V);
+    }
+  else if(useV == 3) {
+    GLfloat mat[16] = {
+      1, 0, 0, 0,
+      0, 1, 0, 0,
+      0, 0, 0, 0,
+      0, 0, stereo::scrdist, 1
+      };
+    glhr::set_modelview(glhr::as_glmatrix(mat));
+    }
+  else
+    glhr::set_modelview(glhr::id());
+  }
+  
+void gldraw(int useV, const transmatrix& V, const vector<glvertex>& v, int ps, int pq, int col, int outline, int flags, textureinfo *tinf) {
 
   if(tinf) {
+    #if CAP_TEXTURE
     glhr::be_textured();
     glBindTexture(GL_TEXTURE_2D, tinf->texture_id);
-    glhr::texture_vertices(&tinf->tvertices[tinfshift], 0, 3);
+    glhr::vertices_texture(v, tinf->tvertices);
+    #endif
+    }
+  else { 
+    glhr::vertices(v);
+    glhr::be_nontextured();
     }
-  else glhr::be_nontextured();
   
   for(int ed = stereo::active() ? -1 : 0; ed<2; ed+=2) {
     if(ed) stereo::set_projection(ed), stereo::set_viewport(ed);
     bool draw = col;
-    again:
-    
-    if(useV == 1) {
-      glapplymatrix(V);
-      }
-    else if(useV == 3) {
-      GLfloat mat[16] = {
-        1, 0, 0, 0,
-        0, 1, 0, 0,
-        0, 0, 0, 0,
-        0, 0, stereo::scrdist, 1
-        };
-      glhr::set_modelview(glhr::as_glmatrix(mat));
-      }
-    else
-      glhr::set_modelview(glhr::id());
+    setmatrix(useV, V);
 
     if(draw) {
       glEnable(GL_STENCIL_TEST);
@@ -346,16 +311,17 @@ void gldraw(int useV, const transmatrix& V, int ps, int pq, int col, int outline
         glStencilFunc( GL_NOTEQUAL, 1, 1);
         GLfloat xx = vid.xres;
         GLfloat yy = vid.yres;
-        GLfloat scr[12] = {
-          -xx, -yy, stereo::scrdist, +xx, -yy, stereo::scrdist, 
-          +xx, +yy, stereo::scrdist, -xx, +yy, stereo::scrdist
+        vector<glvertex> scr = {
+          make_array<GLfloat>(-xx, -yy, stereo::scrdist), 
+          make_array<GLfloat>(+xx, -yy, stereo::scrdist), 
+          make_array<GLfloat>(+xx, +yy, stereo::scrdist), 
+          make_array<GLfloat>(-xx, +yy, stereo::scrdist)
           };
-        GLfloat *cur = glhr::currentvertices;
-        glhr::vertices(scr, 4);
+        glhr::vertices(scr);
         glhr::set_modelview(glhr::id());
         glDrawArrays(tinf ? GL_TRIANGLES : GL_TRIANGLE_FAN, 0, 4);
-        glhr::vertices(cur, 0);
-        draw = false; goto again;
+        glhr::vertices(v);
+        setmatrix(useV, V);
         }
       else { 
         stereo::set_mask(ed);
@@ -408,7 +374,7 @@ void fixMercator(bool tinf) {
   if(mercator_coord)
     swap(cmin, dmin), swap(cmax, dmax);
 
-  for(int i = 0; i<qglcoords; i++) {
+  for(int i = 0; i<size(glcoords); i++) {
     while(glcoords[0][mercator_coord] < hperiod) glcoords[0][mercator_coord] += period;
     while(glcoords[0][mercator_coord] > hperiod) glcoords[0][mercator_coord] -= period;
     }
@@ -418,7 +384,7 @@ void fixMercator(bool tinf) {
   
   ld mincoord = first, maxcoord = first;
 
-  for(int i = 0; i<qglcoords; i++) {
+  for(int i = 0; i<size(glcoords); i++) {
     while(glcoords[i][mercator_coord] < next - hperiod)
       glcoords[i][mercator_coord] += period;
     while(glcoords[i][mercator_coord] > next + hperiod)
@@ -449,33 +415,27 @@ void fixMercator(bool tinf) {
       mercator_loop_max--; return; 
       }
     if(last < first) {
-      reverse(glcoords, glcoords+qglcoords);
+      reverse(glcoords.begin(), glcoords.end());
       swap(first, last);
       }
     while(maxcoord > cmin) {
-      for(int i=0; i<qglcoords; i++) glcoords[i][mercator_coord] -= period;
+      for(int i=0; i<size(glcoords); i++) glcoords[i][mercator_coord] -= period;
       first -= period; last -= period;
       mincoord -= period; maxcoord -= period;
       }
-    int base = qglcoords;
+    int base = size(glcoords);
     int minto = mincoord;
     while(minto < cmax) {
       for(int i=0; i<base; i++) {
-        for(int c=0; c<3; c++) 
-          glcoords[qglcoords][c] = glcoords[qglcoords-base][c];
-        glcoords[qglcoords][mercator_coord] += period;
-        qglcoords++;
+        glcoords.push_back(glcoords[size(glcoords)-base]);
+        glcoords.back()[mercator_coord] += period;
         }
       minto += period;
       }
-    for(int r=0; r<3; r++)
-      glcoords[qglcoords][r] = glcoords[qglcoords-1][r];
-    qglcoords++;
-    for(int r=0; r<3; r++)
-      glcoords[qglcoords][r] = glcoords[0][r];
-    qglcoords++;
+    glcoords.push_back(glcoords.back());
+    glcoords.push_back(glcoords[0]);
     for(int u=1; u<=2; u++) {
-      auto& v = glcoords[qglcoords-u][1-mercator_coord];
+      auto& v = glcoords[size(glcoords)-u][1-mercator_coord];
       v = v < 0 ? dmin : dmax;
       }
     /* printf("cycling %d -> %d\n", base, qglcoords);
@@ -495,13 +455,11 @@ void drawpolyline(polytodraw& p) {
     int i = pp.cnt;
     pp.cnt = 3;
     for(int j=0; j<i; j+=3) {
+      pp.offset = j;
       drawpolyline(p);
-      pp.tab += 9;
-      tinfshift += 9;
       }
-    pp.tab -= 3*i;
-    tinfshift = 0;
     pp.cnt = i;
+    pp.offset = 0;
     return;
     }
   
@@ -514,17 +472,13 @@ void drawpolyline(polytodraw& p) {
 
 #if CAP_GL
   if(vid.usingGL && pmodel == mdDisk && !spherespecial) {
-    const int pq = pp.cnt;
-    if(glhr::currentvertices != pp.tab)
-      glhr::vertices(pp.tab, pq);
-    const int ps=0;
     glLineWidth(linewidthat(tC0(pp.V), pp.minwidth));    
-    gldraw(1, pp.V, ps, pq, p.col, pp.outline, 0, pp.tinf);    
+    gldraw(1, pp.V, *pp.tab, pp.offset, pp.cnt, p.col, pp.outline, 0, pp.tinf);    
     return;
     }
 #endif
   
-  qglcoords = 0;
+  glcoords.clear();
   poly_flags = pp.flags;
   
   double d = 0, curradius = 0;
@@ -536,7 +490,7 @@ void drawpolyline(polytodraw& p) {
   /* pp.outline = 0x80808080;
   p.col = 0; */
   
-  addpoly(pp.V, pp.tab, pp.cnt);
+  addpoly(pp.V, *pp.tab, pp.offset, pp.cnt);
   
   mercator_loop_min = mercator_loop_max = 0;
   if(sphere && pmodel == mdBand)
@@ -546,16 +500,16 @@ void drawpolyline(polytodraw& p) {
   
   if(poly_flags & POLY_BEHIND) return;
 
-  if(0) for(int i=0; i<qglcoords; i++) {
-    if(abs(glcoords[i][0]) > poly_limit || abs(glcoords[i][1]) > poly_limit)
+  if(0) for(auto& p: glcoords) {
+    if(abs(p[0]) > poly_limit || abs(p[1]) > poly_limit)
       return; // too large!
     }
 
   if((spherespecial > 0 || (sphere && mdEqui())) && !(poly_flags & POLY_ISSIDE)) {
     double rarea = 0;
-    for(int i=0; i<qglcoords-1; i++) 
+    for(int i=0; i<size(glcoords)-1; i++) 
       rarea += glcoords[i][0] * glcoords[i+1][1] - glcoords[i][1] * glcoords[i+1][0];
-    rarea += glcoords[qglcoords-1][0] * glcoords[0][1] - glcoords[qglcoords-1][1] * glcoords[0][0];
+    rarea += glcoords.back()[0] * glcoords[0][1] - glcoords.back()[1] * glcoords[0][0];
     
     if(d < 0) poly_flags ^= POLY_INVERSE;
     
@@ -577,7 +531,7 @@ void drawpolyline(polytodraw& p) {
   for(int l=mercator_loop_min; l <= mercator_loop_max; l++) {
   
     if(l || lastl) { 
-      for(int i=0; i<qglcoords; i++)
+      for(int i=0; i<size(glcoords); i++)
         glcoords[i][mercator_coord] += vid.radius * 4 * (l - lastl);
       lastl = l;
       }
@@ -586,10 +540,7 @@ void drawpolyline(polytodraw& p) {
       ld h = atan2(glcoords[0][0], glcoords[0][1]);
       for(int i=0; i<=360; i++) {
         ld a = i * M_PI / 180 + h;
-        glcoords[qglcoords][0] = vid.radius * sin(a);
-        glcoords[qglcoords][1] = vid.radius * cos(a);
-        glcoords[qglcoords][2] = stereo::scrdist;
-        qglcoords++;
+        glcoords.push_back(make_array<GLfloat>(vid.radius * sin(a), vid.radius * cos(a), stereo::scrdist));
         }
       poly_flags ^= POLY_INVERSE;
       }
@@ -600,8 +551,7 @@ void drawpolyline(polytodraw& p) {
       if(pp.tinf && (poly_flags & POLY_INVERSE)) {
         return; 
         }
-      activateGlcoords();
-      gldraw(3, Id, 0, qglcoords, p.col, pp.outline, poly_flags, pp.tinf);
+      gldraw(3, Id, glcoords, 0, size(glcoords), p.col, pp.outline, poly_flags, pp.tinf);
       continue;
       }
   #endif
@@ -627,7 +577,7 @@ void drawpolyline(polytodraw& p) {
       #if CAP_TEXTURE
       if(!(poly_flags & POLY_INVERSE))
         for(int i=0; i<polyi; i += 3)
-          drawTexturedTriangle(s, polyx+i, polyy+i, &pp.tinf->tvertices[tinfshift + i*3], p.col);
+          drawTexturedTriangle(s, polyx+i, polyy+i, &pp.tinf->tvertices[pp.offset + i], p.col);
       #endif
       }
     else if(poly_flags & POLY_INVERSE) {
@@ -665,10 +615,10 @@ void drawpolyline(polytodraw& p) {
     }
   }
 
-vector<float> prettylinepoints;
+vector<glvertex> prettylinepoints;
 
 void prettypoint(const hyperpoint& h) {
-  for(int i=0; i<3; i++) prettylinepoints.push_back(h[i]);
+  prettylinepoints.push_back(glhr::pointtogl(h));
   }
 
 void prettylinesub(const hyperpoint& h1, const hyperpoint& h2, int lev) {
@@ -687,7 +637,8 @@ void prettyline(hyperpoint h1, hyperpoint h2, int col, int lev) {
   polytodraw p;
   auto& pp = p.u.poly;
   pp.V = Id;
-  pp.tab = &prettylinepoints[0];
+  pp.tab = &prettylinepoints;
+  pp.offset = 0;
   pp.cnt = size(prettylinepoints)/3;
   pp.minwidth = minwidth_global;
   p.col = 0;
@@ -705,7 +656,8 @@ void prettypoly(const vector<hyperpoint>& t, int fillcol, int linecol, int lev)
   polytodraw p;
   auto& pp = p.u.poly;
   pp.V = Id;
-  pp.tab = &prettylinepoints[0];
+  pp.tab = &prettylinepoints;
+  pp.offset = 0;
   pp.cnt = size(prettylinepoints)/3;
   pp.minwidth = minwidth_global;
   p.col = fillcol;
@@ -715,7 +667,7 @@ void prettypoly(const vector<hyperpoint>& t, int fillcol, int linecol, int lev)
   drawpolyline(p);
   }
   
-vector<GLfloat> curvedata;
+vector<glvertex> curvedata;
 int curvestart = 0;
 bool keep_curvedata = false;
 
@@ -738,8 +690,6 @@ void drawqueueitem(polytodraw& ptd) {
       break;
     
     case pkPoly:
-      if(ptd.u.poly.curveindex >= 0)
-        ptd.u.poly.tab = &curvedata[ptd.u.poly.curveindex];
       drawpolyline(ptd);
       break;
     
@@ -2300,9 +2250,9 @@ void queuepolyat(const transmatrix& V, const hpcshape& h, int col, int prio) {
   polytodraw& ptd = nextptd();
   ptd.kind = pkPoly;
   ptd.u.poly.V = V;
+  ptd.u.poly.offset = h.s;
   ptd.u.poly.cnt = h.e-h.s;
-  ptd.u.poly.tab = &ourshape[3*h.s];
-  ptd.u.poly.curveindex = -1;
+  ptd.u.poly.tab = &ourshape;
   if(cblind) {
     // protanopia
     /* int r = (56 * part(col,3) + 43 * part(col,2)) / 100;
@@ -2336,13 +2286,13 @@ void queuereset(eModel md, int prio) {
   ptd.prio = prio << PSHIFT;
   }
 
-void queuetable(const transmatrix& V, GLfloat *f, int cnt, int linecol, int fillcol, int prio) {
+void queuetable(const transmatrix& V, const vector<glvertex>& f, int cnt, int linecol, int fillcol, int prio) {
   polytodraw& ptd = nextptd();
   ptd.kind = pkPoly;
   ptd.u.poly.V = V;
+  ptd.u.poly.tab = &f;
+  ptd.u.poly.offset = 0;
   ptd.u.poly.cnt = cnt;
-  ptd.u.poly.tab = f;
-  ptd.u.poly.curveindex = -1;
   ptd.col = fillcol;
   ptd.prio = prio << PSHIFT;
   ptd.u.poly.outline = linecol;
@@ -2419,14 +2369,12 @@ void qfloor(cell *c, const transmatrix& V, const transmatrix& Vspin, const hpcsh
   }
 
 void curvepoint(const hyperpoint& H1) {
-  curvedata.push_back(H1[0]);
-  curvedata.push_back(H1[1]);
-  curvedata.push_back(H1[2]);
+  curvedata.push_back(glhr::pointtogl(H1));
   }
 
 void queuecurve(int linecol, int fillcol, int prio) {
-  queuetable(Id, &curvedata[curvestart], (size(curvedata)-curvestart)/3, linecol, fillcol, prio);
-  lastptd().u.poly.curveindex = curvestart;
+  queuetable(Id, curvedata, size(curvedata)-curvestart, linecol, fillcol, prio);
+  lastptd().u.poly.offset = curvestart;
   curvestart = size(curvedata);
   }
 
diff --git a/renderbuffer.cpp b/renderbuffer.cpp
index 0ed67add..965d173e 100644
--- a/renderbuffer.cpp
+++ b/renderbuffer.cpp
@@ -75,8 +75,15 @@ renderbuffer::renderbuffer(int x, int y, bool gl) : x(x), y(y) {
     glBindRenderbuffer(GL_RENDERBUFFER, depth_stencil_rb);
     GLERR("BindRenderbuffer");
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, tx, ty);
+    bool has_depth = true;
+    if(glGetError() != GL_NO_ERROR) {
+      printf("Could not create: GL_DEPTH24_STENCIL8");
+      glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, tx, ty);
+      has_depth = false;
+      }
     GLERR("RbS");
-    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_stencil_rb);
+    if(has_depth)
+      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth_stencil_rb);
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, depth_stencil_rb);
     GLERR("FrRb");
     
diff --git a/rug.cpp b/rug.cpp
index fdb0fa06..4e950913 100644
--- a/rug.cpp
+++ b/rug.cpp
@@ -995,7 +995,7 @@ bool project_ods(hyperpoint azeq, hyperpoint& h1, hyperpoint& h2, bool eye) {
   }
 #endif
 
-vector<GLfloat> vertex_array, tvertex_array, color_array;
+vector<glhr::ct_vertex> ct_array;
 
 void drawTriangle(triangle& t) {
   using namespace hyperpoint_vec;  
@@ -1070,21 +1070,8 @@ void drawTriangle(triangle& t) {
   
   ld col = (2 + hc[0]/hch) / 3;
   
-  #if !CAP_SHADER
-  glNormal3f(hc[0]/hch,hc[1]/hch,hc[2]/hch);
-  #endif
-  
-  for(int i: {0,1,2}) {
-    tvertex_array.push_back(t.m[i]->x1);
-    tvertex_array.push_back(t.m[i]->y1);
-    for(int j: {0,1,2})
-      vertex_array.push_back(h[i][j]);
-    
-    #if CAP_SHADER
-    for(int a=0; a<3; a++) color_array.push_back(col);
-    color_array.push_back(1);
-    #endif
-    }
+  for(int i: {0,1,2}) 
+    ct_array.emplace_back(h[i], t.m[i]->x1, t.m[i]->y1, col);
   }
 
 renderbuffer *glbuf;
@@ -1143,9 +1130,7 @@ void drawRugScene() {
   
   for(int ed=stereo::active() && stereo::mode != stereo::sODS ? -1 : 0; ed < 2; ed += 2) {
     use_precompute = false;
-    vertex_array.clear();
-    tvertex_array.clear();
-    color_array.clear();
+    ct_array.clear();
     stereo::set_mask(ed), stereo::set_viewport(ed);
     if(ed == 1 && stereo::mode == stereo::sAnaglyph)
       glClear(GL_DEPTH_BUFFER_BIT);
@@ -1190,18 +1175,13 @@ void drawRugScene() {
       gwhere == gElliptic && rug_perspective ? 4 :
       100
       );
-  
-    glhr::set_modelview(glhr::id());
-    
+      
     for(int t=0; t<size(triangles); t++)
       drawTriangle(triangles[t]);
       
-    glhr::vertices(&vertex_array[0], 0);
-    glhr::texture_vertices(&tvertex_array[0], 0);
-#if CAP_SHADER
-    glhr::color_vertices(&color_array[0], 0);
-#endif    
-    glDrawArrays(GL_TRIANGLES, 0, size(vertex_array)/3);
+    glhr::set_modelview(glhr::id());
+    glhr::prepare(ct_array);
+    glDrawArrays(GL_TRIANGLES, 0, size(ct_array));
 
     stereo::set_mask(0);
     }
@@ -1293,6 +1273,8 @@ void move_forward(ld distance) {
   else model_distance /= exp(distance);
   }
 
+#define CAP_HOLDKEYS CAP_SDL // && !ISWEB)
+
 bool handlekeys(int sym, int uni) {
   if(uni == '4') {
 #if CAP_ODS
@@ -1321,7 +1303,7 @@ bool handlekeys(int sym, int uni) {
     apply_rotation(rotmatrix(M_PI/2, 0, 2));
     return true;
     }
-#if !CAP_SDL
+#if !CAP_HOLDKEYS
   else if(uni == SDLK_PAGEUP || uni == '[') {
     move_forward(.1);
     return true;
@@ -1330,6 +1312,12 @@ bool handlekeys(int sym, int uni) {
     move_forward(-.1);
     return true;
     }
+  else if(uni == SDLK_HOME)  { apply_rotation(rotmatrix(.1, 0, 1)); return true; }
+  else if(uni == SDLK_END)   { apply_rotation(rotmatrix(.1, 1, 0)); return true; }
+  else if(uni == SDLK_DOWN)  { apply_rotation(rotmatrix(.1, 2, 1)); return true; }
+  else if(uni == SDLK_UP)    { apply_rotation(rotmatrix(.1, 1, 2)); return true; }
+  else if(uni == SDLK_LEFT)  { apply_rotation(rotmatrix(.1, 2, 0)); return true; }
+  else if(uni == SDLK_RIGHT) { apply_rotation(rotmatrix(.1, 0, 2)); return true; }
 #endif
   else return false;
   }
@@ -1362,7 +1350,7 @@ void actDraw() {
     }        
   #endif
 
-  #if CAP_SDL
+  #if CAP_HOLDKEYS
   Uint8 *keystate = SDL_GetKeyState(NULL);
   int qm = 0;
   double alpha = (ticks - lastticks) / 1000.0;
diff --git a/shaders.cpp b/shaders.cpp
index 2fdeae6c..2ed80773 100644
--- a/shaders.cpp
+++ b/shaders.cpp
@@ -13,10 +13,18 @@ void glError(const char* GLcall, const char* file, const int line) {
     }
   }
 
+#define CAP_VERTEXBUFFER (!ISWEB)
+
 namespace glhr {
 
 bool glew   = false;
 
+typedef const void *constvoidptr;
+
+constvoidptr current_vertices, buffered_vertices;
+
+GLuint buf_current, buf_buffered;
+
 enum eMode { gmColored, gmTextured, gmVarColored, gmLightFog, gmMAX};
 
 static const flagtype GF_TEXTURE  = 1;
@@ -294,34 +302,6 @@ void set_modelview(const glmatrix& modelview) {
 
 #endif
 
-GLfloat *currentvertices;
-
-void vertices(GLfloat *f, int qty) {
-  currentvertices = f;
-  #if CAP_SHADER
-  glVertexAttribPointer(aPosition, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), f);
-  #else
-  glVertexPointer(3, GL_FLOAT, 0, f);
-  #endif
-  // #endif
-  }
-
-void texture_vertices(GLfloat *f, int qty, int stride = 2) {
-  #if CAP_SHADER
-  glVertexAttribPointer(aTexture, stride, GL_FLOAT, GL_FALSE, stride * sizeof(GLfloat), f);
-  #else
-  glTexCoordPointer(stride, GL_FLOAT, 0, f);
-  #endif
-  }
-
-void color_vertices(GLfloat *f, int qty) {
-  #if CAP_SHADER
-  glVertexAttribPointer(aColor, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), f);
-  #else
-  glColorPointer(4, GL_FLOAT, 0, f);
-  #endif
-  }
-
 void color2(int color, ld part = 1) {
   unsigned char *c = (unsigned char*) (&color);
   GLfloat cols[4];
@@ -421,6 +401,7 @@ void switch_mode(eMode m) {
     }
   mode = m;
   GLERR("after_switch_mode");
+  current_vertices = NULL;
   }
 
 void fog_max(ld fogmax) {
@@ -503,6 +484,179 @@ void init() {
   glEnableClientState(GL_VERTEX_ARRAY);
   #endif
   // #endif
+
+  #if CAP_VERTEXBUFFER
+  glGenBuffers(1, &buf_current);
+  glGenBuffers(1, &buf_buffered);
+  current_vertices = NULL;
+  buffered_vertices = (void*) &buffered_vertices; // point to nothing
+  glBindBuffer(GL_ARRAY_BUFFER, buf_current);
+  #endif
+  }
+
+hyperpoint gltopoint(const glvertex& t) {
+  hyperpoint h;
+  h[0] = t[0]; h[1] = t[1]; h[2] = t[2];
+  return h;
+  }
+
+glvertex pointtogl(const hyperpoint& t) {
+  glvertex h;
+  h[0] = t[0]; h[1] = t[1]; h[2] = t[2];
+  return h;
+  }
+
+struct colored_vertex {
+  glvec3 coords;
+  glvec4 color;
+  colored_vertex(GLfloat x, GLfloat y, GLfloat r, GLfloat g, GLfloat b) {
+    coords[0] = x;
+    coords[1] = y;
+    coords[2] = stereo::scrdist;
+    color[0] = r;
+    color[1] = g;
+    color[2] = b;
+    color[3] = 1;
+    }
+  };
+
+struct textured_vertex {
+  glvec3 coords;
+  glvec3 texture;
+  };
+
+struct ct_vertex {
+  glvec3 coords;
+  glvec4 color;
+  glvec3 texture;
+  ct_vertex(const hyperpoint& h, ld x1, ld y1, ld col) {
+    coords = pointtogl(h);
+    texture[0] = x1;
+    texture[1] = y1;
+    color[0] = color[1] = color[2] = col;
+    color[3] = 1;
+    }
+  };
+
+#if CAP_VERTEXBUFFER
+template<class T> void bindbuffer(T& v) {
+  if(current_vertices == buffered_vertices) {
+    glBindBuffer(GL_ARRAY_BUFFER, buf_current);
+    }
+  current_vertices = &v[0];
+  glBufferData(GL_ARRAY_BUFFER, size(v) * sizeof(v[0]), &v[0], GL_DYNAMIC_DRAW);    
+  }
+
+#define PTR(attrib, q, field) \
+  glVertexAttribPointer(attrib, q, GL_FLOAT, GL_FALSE, sizeof(v[0]), (void*) ((char*) &v[0].field - (char*) &v[0]));
+
+#endif
+
+void vertices(const vector<glvertex>& v) {
+  #if CAP_VERTEXBUFFER
+  if(&v[0] == buffered_vertices) {
+    if(&v[0] == current_vertices) return;
+    current_vertices = buffered_vertices;
+    glBindBuffer(GL_ARRAY_BUFFER, buf_buffered);
+    glBufferData(GL_ARRAY_BUFFER, size(v) * sizeof(v[0]), &v[0], GL_STATIC_DRAW);
+    glVertexAttribPointer(glhr::aPosition, 3, GL_FLOAT, GL_FALSE, sizeof(glvertex), 0);
+    return;
+    }
+  bindbuffer(v);
+  glVertexAttribPointer(glhr::aPosition, 3, GL_FLOAT, GL_FALSE, sizeof(glvertex), 0);
+  #else
+  if(current_vertices == &v[0]) return;
+  current_vertices = &v[0];
+  #if CAP_SHADER
+  glVertexAttribPointer(aPosition, 3, GL_FLOAT, GL_FALSE, sizeof(glvertex), &v[0]);
+  #else
+  glVertexPointer(3, GL_FLOAT, sizeof(glvertex), &v[0]);
+  #endif
+  #endif
+  }
+
+void vertices_texture(const vector<glvertex>& v, const vector<glvertex>& t) {
+  #if CAP_TEXTURE
+  vertices(v);
+  #if CAP_SHADER
+  glVertexAttribPointer(aTexture, 3, GL_FLOAT, GL_FALSE, sizeof(glvertex), &t[0]);
+  #else
+  glTexCoordPointer(stride, GL_FLOAT, 0, &v[0]);
+  #endif
+  #endif
+  }
+
+void prepare(vector<colored_vertex>& v) {
+  #if CAP_VERTEXBUFFER
+  bindbuffer(v);
+  PTR(glhr::aPosition, 3, coords);
+  PTR(glhr::aColor, 4, color);
+  #else
+  if(current_vertices == &v[0]) return;
+  current_vertices = &v[0];
+  #if CAP_SHADER
+  glVertexAttribPointer(aPosition, 3, GL_FLOAT, GL_FALSE, sizeof(colored_vertex), &v[0].coords);
+  glVertexAttribPointer(aColor, 4, GL_FLOAT, GL_FALSE, sizeof(colored_vertex), &v[0].color);
+  #else
+  glVertexPointer(3, GL_FLOAT, sizeof(colored_vertex), &v[0].coords);
+  glVertexPointer(3, GL_FLOAT, sizeof(colored_vertex), &v[0].color);
+  #endif
+  #endif
+  }
+
+void prepare(vector<textured_vertex>& v) {
+  #if CAP_VERTEXBUFFER
+  bindbuffer(v);
+  PTR(glhr::aPosition, 3, coords);
+  PTR(glhr::aTexture, 2, texture);
+  #else
+  if(current_vertices == &v[0]) return;
+  current_vertices = &v[0];
+  #if CAP_SHADER
+  glVertexAttribPointer(aPosition, 3, GL_FLOAT, GL_FALSE, sizeof(textured_vertex), &v[0].coords);
+  glVertexAttribPointer(aTexture, 3, GL_FLOAT, GL_FALSE, sizeof(textured_vertex), &v[0].texture);
+  #else
+  glVertexPointer(3, GL_FLOAT, sizeof(textured_vertex), &v[0].coords);
+  glVertexPointer(3, GL_FLOAT, sizeof(textured_vertex), &v[0].texture);
+  #endif
+  #endif
+  // color2(col);
+  }
+
+void prepare(vector<ct_vertex>& v) {
+  #if CAP_VERTEXBUFFER
+  bindbuffer(v);
+  PTR(glhr::aPosition, 3, coords);
+  PTR(glhr::aColor, 4, color);
+  PTR(glhr::aTexture, 2, texture);
+  #else
+  if(current_vertices == &v[0]) return;
+  current_vertices = &v[0];
+  #if CAP_SHADER
+  glVertexAttribPointer(aPosition, 3, GL_FLOAT, GL_FALSE, sizeof(ct_vertex), &v[0].coords);
+  glVertexAttribPointer(aColor, 4, GL_FLOAT, GL_FALSE, sizeof(ct_vertex), &v[0].color);
+  glVertexAttribPointer(aTexture, 3, GL_FLOAT, GL_FALSE, sizeof(ct_vertex), &v[0].texture);
+  #else
+  glVertexPointer(3, GL_FLOAT, sizeof(ct_vertex), &v[0].coords);
+  glVertexPointer(3, GL_FLOAT, sizeof(ct_vertex), &v[0].texture);
+  glVertexPointer(3, GL_FLOAT, sizeof(ct_vertex), &v[0].color);
+  #endif
+  #endif
+  }
+
+void store_in_buffer(vector<glvertex>& v) {
+#if CAP_VERTEXBUFFER
+  if(!buf_buffered) {
+    printf("no buffer yet\n");
+    return;
+    }
+  printf("storing %d in buffer: %p\n", size(v), &v[0]);
+  current_vertices = buffered_vertices = &v[0];
+  glBindBuffer(GL_ARRAY_BUFFER, buf_buffered);
+  glVertexAttribPointer(glhr::aPosition, 3, GL_FLOAT, GL_FALSE, sizeof(glvertex), 0);
+  glBufferData(GL_ARRAY_BUFFER, size(v) * sizeof(glvertex), &v[0], GL_STATIC_DRAW);
+  printf("Stored.\n");
+#endif
   }
 
 }
diff --git a/textures.cpp b/textures.cpp
index dab3fc3f..e60b7fee 100644
--- a/textures.cpp
+++ b/textures.cpp
@@ -243,9 +243,6 @@ int color_alpha = 128;
 
 int gsplits = 1;
 
-template<class T> array<T, 3> make_array(T a, T b, T c) { array<T,3> x; x[0] = a; x[1] = b; x[2] = c; return x; }
-template<class T> array<T, 2> make_array(T a, T b) { array<T,2> x; x[0] = a; x[1] = b; return x; }
-
 void mapTextureTriangle(textureinfo &mi, array<hyperpoint, 3> v, int splits = gsplits) {
 
   if(splits) {
@@ -258,16 +255,13 @@ void mapTextureTriangle(textureinfo &mi, array<hyperpoint, 3> v, int splits = gs
     }
     
   for(int i=0; i<3; i++) {
-    for(int j=0; j<3; j++) 
-      mi.vertices.push_back(v[i][j]);
+    mi.vertices.push_back(glhr::pointtogl(v[i]));
     hyperpoint inmodel;
     applymodel(mi.M * v[i], inmodel);
     inmodel = itt * inmodel;
     inmodel[0] *= vid.radius * 1. / vid.scrsize;
     inmodel[1] *= vid.radius * 1. / vid.scrsize;
-    mi.tvertices.push_back((inmodel[0]+1)/2);
-    mi.tvertices.push_back((inmodel[1]+1)/2);
-    mi.tvertices.push_back(0);
+    mi.tvertices.push_back(make_array<GLfloat>((inmodel[0]+1)/2, (inmodel[1]+1)/2, 0));
     }  
   }
 
@@ -325,7 +319,7 @@ bool apply(cell *c, const transmatrix &V, int col) {
     
     qfi.spin = applyPatterndir(c, si);
     
-    int n = mi.vertices.size() / 3;
+    int n = mi.vertices.size();
 
     qfi.special = false;
     qfi.shape = &shFullFloor[ctof(c)];
@@ -334,10 +328,10 @@ bool apply(cell *c, const transmatrix &V, int col) {
     if(chasmg == 2) return false;
     else if(chasmg && wmspatial) {
       if(detaillevel == 0) return false;
-      queuetable(V * qfi.spin, &mi.vertices[0], n, mesh_color, recolor(c->land == laCocytus ? 0x080808FF : 0x101010FF), PPR_LAKEBOTTOM);
+      queuetable(V * qfi.spin, mi.vertices, n, mesh_color, recolor(c->land == laCocytus ? 0x080808FF : 0x101010FF), PPR_LAKEBOTTOM);
       }
     else {
-      queuetable(V * qfi.spin, &mi.vertices[0], n, mesh_color, recolor(col), PPR_FLOOR);
+      queuetable(V * qfi.spin, mi.vertices, n, mesh_color, recolor(col), PPR_FLOOR);
       }
         
     lastptd().u.poly.tinf = &mi;
@@ -348,7 +342,7 @@ bool apply(cell *c, const transmatrix &V, int col) {
       
     if(texture::saving) {
       // create a nicer aura for saved texture
-      for(int i=0; i<size(mi.tvertices); i += 9) {
+      for(int i=0; i<size(mi.tvertices); i += 3) {
         ld p[3];
         while(true) {
           p[0] = hrandf();
@@ -358,12 +352,12 @@ bool apply(cell *c, const transmatrix &V, int col) {
           }
         ld v[2] = {0,0};
         for(int j=0; j<2; j++) for(int k=0; k<3; k++)
-          v[j] += mi.tvertices[3*k+j] * p[k];
+          v[j] += mi.tvertices[i+k][j] * p[k];
   
         int vi[2] = {int(v[0] * twidth), int(v[1] * twidth)};
   
         col = get_texture_pixel(vi[0], vi[1]);
-        hyperpoint h = hpxyz(mi.vertices[i], mi.vertices[i+1], mi.vertices[i+2]);
+        hyperpoint h = glhr::gltopoint(mi.vertices[i]);
         addaura(V*h, col, 0);
         }
       }
@@ -464,12 +458,12 @@ void saveFullTexture() {
 
 bool newmove = false;
 
+vector<glhr::textured_vertex> rtver(4);
+
 void drawRawTexture() {
   glhr::be_textured();
   glhr::color2(0xFFFFFF20);
-  glhr::set_modelview(glhr::translate(0, 0, stereo::scrdist));
   glBindTexture(GL_TEXTURE_2D, textureid);
-  vector<GLfloat> tver, sver;
   for(int i=0; i<4; i++) {
     int cx[4] = {2, -2, -2, 2};
     int cy[4] = {2, 2, -2, -2};
@@ -477,15 +471,13 @@ void drawRawTexture() {
     int y = cy[i];
     hyperpoint inmodel = hpxyz(x, y, 1);
     inmodel = itt * inmodel;
-    tver.push_back((inmodel[0]+1)/2);
-    tver.push_back((inmodel[1]+1)/2);
-    tver.push_back(0);
-    sver.push_back(x * vid.scrsize);
-    sver.push_back(y * vid.scrsize);
-    sver.push_back(0);            
+    rtver[i].texture[0] = (inmodel[0]+1)/2;
+    rtver[i].texture[1] = (inmodel[1]+1)/2;
+    rtver[i].coords[0] = x * vid.scrsize;
+    rtver[i].coords[1] = y * vid.scrsize;
     }
-  glhr::vertices(&sver[0], 4);
-  glhr::texture_vertices(&tver[0], 4, 3);
+  glhr::set_modelview(glhr::translate(0, 0, stereo::scrdist));
+  glhr::prepare(rtver);
   glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
   }
 
@@ -1263,7 +1255,7 @@ void remap(eTextureState old_tstate, eTextureState old_tstate_max) {
         auto& mi = texture_map_orig.at(oldid);  
         int ncurr = size(mi.tvertices);  
         int ntarget = ncurr * c->type / mi.current_type;
-        vector<GLfloat> new_tvertices = mi.tvertices;
+        vector<glvertex> new_tvertices = mi.tvertices;
         new_tvertices.resize(ntarget);
         for(int i=ncurr; i<ntarget; i++) {
           new_tvertices[i] = new_tvertices[i - ncurr];