diff --git a/Polyhedron/demo/Polyhedron/Edge_container.cpp b/Polyhedron/demo/Polyhedron/Edge_container.cpp
index 9b9739a4fa7..1703ca7fadd 100644
--- a/Polyhedron/demo/Polyhedron/Edge_container.cpp
+++ b/Polyhedron/demo/Polyhedron/Edge_container.cpp
@@ -16,6 +16,9 @@ struct Edge_d{
 
   QVector4D plane;
   QMatrix4x4 f_matrix;
+  GLfloat width;
+  QVector2D viewport;
+  bool is_surface;
 };
 
 Edge_container::Edge_container(int program, bool indexed)
@@ -85,13 +88,13 @@ void Edge_container::initGL(Viewer_interface *viewer)
                          QOpenGLBuffer::VertexBuffer, GL_FLOAT, 0, 1));
         getVao(viewer)->addVbo(getVbo(Radius));
       }
-      if(viewer->getShaderProgram(getProgram())->property("hasBarycenter").toBool())
+      if(viewer->getShaderProgram(getProgram())->property("hasCenter").toBool())
       {
-        if(!getVbo(Barycenters))
-          setVbo(Barycenters,
-                 new Vbo("barycenter",
+        if(!getVbo(Centers))
+          setVbo(Centers,
+                 new Vbo("Center",
                          Vbo::GEOMETRY));
-        getVao(viewer)->addVbo(getVbo(Barycenters));
+        getVao(viewer)->addVbo(getVbo(Centers));
       }
       
     }
@@ -105,8 +108,8 @@ void Edge_container::initializeBuffers(Viewer_interface *viewer)
   if(viewer->getShaderProgram(getProgram())->property("isInstanced").toBool())
   {
     getVao(viewer)->bind();
-    if(viewer->getShaderProgram(getProgram())->property("hasBarycenter").toBool())
-      viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("barycenter"), 1);
+    if(viewer->getShaderProgram(getProgram())->property("hasCenter").toBool())
+      viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("center"), 1);
     if(viewer->getShaderProgram(getProgram())->property("hasRadius").toBool())
       viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("radius"), 1);
     viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("colors"), 1);
@@ -141,15 +144,25 @@ void Edge_container::draw(Viewer_interface *viewer,
       getVao(viewer)->program->setUniformValue("cutplane", d->plane);
     if(getVao(viewer)->program->property("hasFMatrix").toBool())
       getVao(viewer)->program->setUniformValue("f_matrix", getFrameMatrix());
+    
+    if(getVao(viewer)->program->property("hasViewport").toBool())
+    {
+      getVao(viewer)->program->setUniformValue("viewport", getViewport());
+      getVao(viewer)->program->setUniformValue("near",(GLfloat)viewer->camera()->zNear());
+      getVao(viewer)->program->setUniformValue("far",(GLfloat)viewer->camera()->zFar());
+    }
+    if(getVao(viewer)->program->property("hasWidth").toBool())
+      getVao(viewer)->program->setUniformValue("width", getWidth());
+    
     if(viewer->getShaderProgram(getProgram())->property("isInstanced").toBool())
     {
       viewer->glDrawArraysInstanced(GL_LINES, 0,
-                                    static_cast<GLsizei>(getFlatDataSize()/3),
+                                    static_cast<GLsizei>(getFlatDataSize()/getTupleSize()),
                                     static_cast<GLsizei>(getCenterSize()/3));
     }
     else
     {
-      viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(getFlatDataSize()/3));
+      viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(getFlatDataSize()/getTupleSize()));
     }
     getVao(viewer)->release();
 
@@ -158,6 +171,11 @@ void Edge_container::draw(Viewer_interface *viewer,
 
 QVector4D Edge_container::getPlane() const { return d->plane; }
 QMatrix4x4 Edge_container::getFrameMatrix() const { return d->f_matrix; }
+GLfloat Edge_container::getWidth() const { return d->width; }
+QVector2D Edge_container::getViewport() const { return d->viewport; }
 
 void Edge_container::setPlane(const QVector4D& p) { d->plane = p; }
 void Edge_container::setFrameMatrix(const QMatrix4x4& m) { d->f_matrix = m; }
+void Edge_container::setWidth(const GLfloat & w) { d->width = w; }
+void Edge_container::setViewport(const QVector2D & v) { d-> viewport = v; }
+void Edge_container::setIsSurface  (const bool b) { d->is_surface = b; }
diff --git a/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/C3t3_io_plugin.cpp b/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/C3t3_io_plugin.cpp
index f71a15aff64..549493144a1 100644
--- a/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/C3t3_io_plugin.cpp
+++ b/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/C3t3_io_plugin.cpp
@@ -69,7 +69,6 @@ Polyhedron_demo_c3t3_binary_io_plugin::load(QFileInfo fileinfo) {
     if(fileinfo.suffix().toLower() == "cgal")
     {
         item->setName(fileinfo.baseName());
-        item->setScene(scene);
 
 
         if(item->load_binary(in)) {
@@ -102,7 +101,6 @@ Polyhedron_demo_c3t3_binary_io_plugin::load(QFileInfo fileinfo) {
 
       Scene_c3t3_item* item = new Scene_c3t3_item();
       item->setName(fileinfo.baseName());
-      item->setScene(scene);
       item->set_valid(false);
 
       if(CGAL::build_triangulation_from_file<C3t3::Triangulation, true>(in, item->c3t3().triangulation()))
diff --git a/Polyhedron/demo/Polyhedron/Point_container.cpp b/Polyhedron/demo/Polyhedron/Point_container.cpp
index 28cf636a5d8..f0dbe34f3be 100755
--- a/Polyhedron/demo/Polyhedron/Point_container.cpp
+++ b/Polyhedron/demo/Polyhedron/Point_container.cpp
@@ -15,6 +15,7 @@ struct Point_d{
 
   QVector4D plane;
   QMatrix4x4 f_matrix;
+  bool is_surface;
 };
 
 Point_container::Point_container(int program, bool indexed)
@@ -105,7 +106,7 @@ void Point_container::draw(Viewer_interface *viewer,
       getVao(viewer)->program->setAttributeValue("colors", getColor());
     if(getVao(viewer)->program->property("hasFMatrix").toBool())
       getVao(viewer)->program->setUniformValue("f_matrix", getFrameMatrix());
-    viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(getFlatDataSize()/3));
+    viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(getFlatDataSize()/getTupleSize()));
     getVao(viewer)->release();
 
   }
@@ -115,3 +116,5 @@ QVector4D Point_container::getPlane() const { return d->plane; }
 QMatrix4x4 Point_container::getFrameMatrix() const { return d->f_matrix; }
 
 void Point_container::setFrameMatrix(const QMatrix4x4& m) { d->f_matrix = m; }
+void Point_container::setPlane(const QVector4D& p) { d->plane = p; }
+void Point_container::setIsSurface  (const bool b) { d->is_surface = b; }
diff --git a/Polyhedron/demo/Polyhedron/Primitive_container.cpp b/Polyhedron/demo/Polyhedron/Primitive_container.cpp
index 1c8aabecade..8593447f967 100755
--- a/Polyhedron/demo/Polyhedron/Primitive_container.cpp
+++ b/Polyhedron/demo/Polyhedron/Primitive_container.cpp
@@ -9,6 +9,7 @@ struct D
       is_selected(false),
       flat_size(0),
       idx_size(0),
+      tuple_size(3),
       color(QColor())
   {}
   QMap<CGAL::Three::Viewer_interface*, Vao*> VAOs;
@@ -21,6 +22,7 @@ struct D
   std::size_t flat_size;
   std::size_t center_size;
   std::size_t idx_size;
+  int tuple_size;
   QColor color;
 };
 
@@ -179,6 +181,7 @@ void Primitive_container::setOffset(std::size_t id, int offset) {
   d->VBOs[id]->offset = offset;
 }
 
+void Primitive_container::setTupleSize(int ts) { d->tuple_size = ts; }
 int Primitive_container::getProgram() const  { return d->program_id; }
 
 bool Primitive_container::isDataIndexed()  { return d->indexed; }
@@ -201,3 +204,4 @@ std::size_t Primitive_container::getIdxSize() const  { return d->idx_size; }
 
 QColor Primitive_container::getColor()const  { return d->color; }
 
+int Primitive_container::getTupleSize() const { return d->tuple_size; }
diff --git a/Polyhedron/demo/Polyhedron/Scene.cpp b/Polyhedron/demo/Polyhedron/Scene.cpp
index 793bed0af2a..03d538657f6 100755
--- a/Polyhedron/demo/Polyhedron/Scene.cpp
+++ b/Polyhedron/demo/Polyhedron/Scene.cpp
@@ -1593,7 +1593,6 @@ void Scene::addGroup(Scene_group_item* group)
     connect(this, SIGNAL(drawFinished()), group, SLOT(resetDraw()));
     connect(this, SIGNAL(indexErased(Scene_interface::Item_id)),
                 group, SLOT(adjustIds(Scene_interface::Item_id)));
-    group->setScene(this);
 }
 
 namespace scene { namespace details {
diff --git a/Polyhedron/demo/Polyhedron/Scene_c3t3_item.cpp b/Polyhedron/demo/Polyhedron/Scene_c3t3_item.cpp
index c2842b84760..88e80636eb5 100644
--- a/Polyhedron/demo/Polyhedron/Scene_c3t3_item.cpp
+++ b/Polyhedron/demo/Polyhedron/Scene_c3t3_item.cpp
@@ -13,11 +13,16 @@
 #include <QSlider>
 #include <QWidgetAction>
 #include <QKeyEvent>
-#include <QOpenGLFramebufferObject>
 
 #include <map>
 #include <vector>
+
 #include <CGAL/Three/Scene_interface.h>
+#include <CGAL/Three/Triangle_container.h>
+#include <CGAL/Three/Edge_container.h>
+#include <CGAL/Three/Point_container.h>
+#include <CGAL/Three/Three.h>
+
 #include <CGAL/Real_timer.h>
 
 #include <CGAL/Qt/manipulatedFrame.h>
@@ -38,26 +43,50 @@ typedef CGAL::AABB_triangulation_3_triangle_primitive<EPICK,C3t3> Primitive;
 typedef CGAL::AABB_traits<EPICK, Primitive> Traits;
 typedef CGAL::AABB_tree<Traits> Tree;
 typedef Tree::Point_and_primitive_id Point_and_primitive_id;
+using namespace CGAL::Three;
+typedef Triangle_container Tc;
+typedef Edge_container Ec;
+typedef Point_container Pc;
+typedef Viewer_interface Vi;
 
 // The special Scene_item only for triangles
-class Scene_intersection_item : public CGAL::Three::Scene_item
+class Scene_intersection_item : public CGAL::Three::Scene_item_rendering_helper
 {
   Q_OBJECT
 public :
   Scene_intersection_item(Scene_c3t3_item* parent)
-  :CGAL::Three::Scene_item(NumberOfBuffers,NumberOfVaos),
-    is_fast(false)
+  :is_fast(false)
   {
     setParent(parent);
     alphaSlider = NULL;
     m_alpha = 1.0f;
+    setTriangleContainer(0, new Tc(Vi::PROGRAM_C3T3, false));
+    setEdgeContainer(0, new Ec(Vi::PROGRAM_NO_SELECTION, false));
   }
-  bool isFinite() const { return false; }
+  bool isFinite() const Q_DECL_OVERRIDE{ return false; }
   ~Scene_intersection_item()
   {
     if(alphaSlider)
          delete alphaSlider;
   }
+  void compute_bbox() const Q_DECL_OVERRIDE{}
+  
+  void gl_initialization(Vi* viewer)
+  {
+    if(!isInit())
+      initGL();
+    if ( getBuffersFilled() &&
+         ! getBuffersInit(viewer))
+    {
+      initializeBuffers(viewer);
+      setBuffersInit(viewer, true);
+    }
+    if(!getBuffersFilled())
+    {
+      computeElements();
+      initializeBuffers(viewer);
+    }
+  }
   void init_vectors(
       std::vector<float> *p_vertices,
       std::vector<float> *p_normals,
@@ -70,77 +99,49 @@ public :
     edges = p_edges;
     colors = p_colors;
     barycenters = p_bary;
-
   }
-  void setColor(QColor c)
+  void setColor(QColor c) Q_DECL_OVERRIDE
   {
     qobject_cast<Scene_c3t3_item*>(this->parent())->setColor(c);
     Scene_item::setColor(c);
   }
   // Indicates if rendering mode is supported
-  bool supportsRenderingMode(RenderingMode m) const {
+  bool supportsRenderingMode(RenderingMode m) const Q_DECL_OVERRIDE{
     return (m != Gouraud && m != PointsPlusNormals && m != Points && m != ShadedPoints);
   }
-  void initialize_buffers(CGAL::Three::Viewer_interface *viewer)
+  void computeElements() const Q_DECL_OVERRIDE
   {
-   //vao containing the data for the facets
+    return;
+    getTriangleContainer(0)->allocate(Tc::Flat_vertices,
+          vertices->data(), static_cast<int>(vertices->size()*sizeof(float)));
+    getTriangleContainer(0)->allocate(Tc::Flat_normals, normals->data(),
+                              static_cast<int>(normals->size()*sizeof(float)));
+    getTriangleContainer(0)->allocate(Tc::FColors, colors->data(),
+                             static_cast<int>(colors->size()*sizeof(float)));
+    getTriangleContainer(0)->allocate(Tc::Facet_centers, barycenters->data(),
+                                  static_cast<int>(barycenters->size()*sizeof(float)));
+    getEdgeContainer(0)->allocate(Ec::Vertices, edges->data(),
+                            static_cast<int>(edges->size()*sizeof(float)));
+    setBuffersFilled(true);
+  }
+  void initializeBuffers(CGAL::Three::Viewer_interface *viewer)const Q_DECL_OVERRIDE
+  {
+    return;
+    //vao containing the data for the facets
     {
-      program = getShaderProgram(PROGRAM_C3T3, viewer);
-      program->bind();
-
-      vaos[Facets]->bind();
-      buffers[Vertices].bind();
-      buffers[Vertices].allocate(vertices->data(),
-        static_cast<int>(vertices->size()*sizeof(float)));
-      program->enableAttributeArray("vertex");
-      program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
-      buffers[Vertices].release();
-
-      buffers[Normals].bind();
-      buffers[Normals].allocate(normals->data(),
-        static_cast<int>(normals->size()*sizeof(float)));
-      program->enableAttributeArray("normals");
-      program->setAttributeBuffer("normals", GL_FLOAT, 0, 3);
-      buffers[Normals].release();
-
-      buffers[Colors].bind();
-      buffers[Colors].allocate(colors->data(),
-        static_cast<int>(colors->size()*sizeof(float)));
-      program->enableAttributeArray("colors");
-      program->setAttributeBuffer("colors", GL_FLOAT, 0, 3);
-      buffers[Colors].release();
-
-      buffers[Barycenters].bind();
-      buffers[Barycenters].allocate(barycenters->data(),
-        static_cast<int>(barycenters->size()*sizeof(float)));
-      program->enableAttributeArray("barycenter");
-      program->setAttributeBuffer("barycenter", GL_FLOAT, 0, 3);
-      buffers[Barycenters].release();
-
-      vaos[Facets]->release();
-      program->release();
-
+      getTriangleContainer(0)->initializeBuffers(viewer);
+      getTriangleContainer(0)->setFlatDataSize(vertices->size());
+    }
+    //vao containing the data for the lines
+    {
+      getEdgeContainer(0)->initializeBuffers(viewer);
+      getEdgeContainer(0)->setFlatDataSize(edges->size());
     }
-      //vao containing the data for the lines
-      {
-          program = getShaderProgram(PROGRAM_NO_SELECTION, viewer);
-          program->bind();
-
-          vaos[Lines]->bind();
-          buffers[Edges].bind();
-          buffers[Edges].allocate(edges->data(),
-                                           static_cast<int>(edges->size()*sizeof(float)));
-          program->enableAttributeArray("vertex");
-          program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
-          buffers[Edges].release();
-
-          vaos[Lines]->release();
-          program->release();
-      }
   }
   //Displays the item
-  void draw(CGAL::Three::Viewer_interface* viewer) const
+  void draw(CGAL::Three::Viewer_interface* viewer) const Q_DECL_OVERRIDE
   {
+    return;
     if(is_fast)
       return;
     if(!alphaSlider)
@@ -150,47 +151,28 @@ public :
        alphaSlider->setMaximum(255);
        alphaSlider->setValue(255);
      }
-    QOpenGLFramebufferObject* fbo = viewer->depthPeelingFbo();
     const EPICK::Plane_3& plane = qobject_cast<Scene_c3t3_item*>(this->parent())->plane();
-    vaos[Facets]->bind();
-    program = getShaderProgram(PROGRAM_C3T3);
-    attribBuffers(viewer, PROGRAM_C3T3);
-    program->bind();
+    
     float shrink_factor = qobject_cast<Scene_c3t3_item*>(this->parent())->getShrinkFactor();
     QVector4D cp(-plane.a(), -plane.b(), -plane.c(), -plane.d());
-    program->setUniformValue("cutplane", cp);
-    program->setUniformValue("shrink_factor", shrink_factor);
+    getTriangleContainer(0)->setPlane(cp);
+    getTriangleContainer(0)->setShrinkFactor(shrink_factor);
     // positions_poly is also used for the faces in the cut plane
     // and changes when the cut plane is moved
-    program->setUniformValue("comparing", viewer->currentPass() > 0);;
-    program->setUniformValue("width", viewer->width()*1.0f);         
-    program->setUniformValue("height", viewer->height()*1.0f);       
-    program->setUniformValue("near", (float)viewer->camera()->zNear());     
-    program->setUniformValue("far", (float)viewer->camera()->zFar());       
-    program->setUniformValue("writing", viewer->isDepthWriting());   
-    program->setUniformValue("alpha", alpha());                     
-    if( fbo)
-      viewer->glBindTexture(GL_TEXTURE_2D, fbo->texture());
-    viewer->glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vertices->size() / 3));
-    program->release();
-    vaos[Facets]->release();
+    getTriangleContainer(0)->setAlpha(alpha());
+    getTriangleContainer(0)->draw(viewer, false);
   }
-  void drawEdges(CGAL::Three::Viewer_interface* viewer) const
+  void drawEdges(CGAL::Three::Viewer_interface* viewer) const Q_DECL_OVERRIDE
   {
+    return;
     if(is_fast)
       return;
-    
-    vaos[Lines]->bind();
-    program = getShaderProgram(PROGRAM_C3T3_EDGES);
-    attribBuffers(viewer, PROGRAM_C3T3_EDGES);
-    program->bind();
     const EPICK::Plane_3& plane = qobject_cast<Scene_c3t3_item*>(this->parent())->plane();
     QVector4D cp(-plane.a(), -plane.b(), -plane.c(), -plane.d());
-    program->setUniformValue("cutplane", cp);
-    program->setAttributeValue("colors", QColor(Qt::black));
-    viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(edges->size() / 3));
-    program->release();
-    vaos[Lines]->release();
+    getEdgeContainer(0)->setPlane(cp);
+    getEdgeContainer(0)->setColor(QColor(Qt::black));
+    getEdgeContainer(0)->draw(viewer, true);
+    
   }
 
   void setFast(bool b)
@@ -260,9 +242,9 @@ public :
     }
   }
 
-  Scene_item* clone() const {return 0;}
-  QString toolTip() const {return QString();}
-  QMenu* contextMenu()
+  Scene_item* clone() const Q_DECL_OVERRIDE{return 0;}
+  QString toolTip() const Q_DECL_OVERRIDE{return QString();}
+  QMenu* contextMenu() Q_DECL_OVERRIDE
   {
     QMenu* menu = Scene_item::contextMenu();
   
@@ -288,32 +270,17 @@ public :
     }
     return menu;
   }
-  float alpha() const
+  float alpha() const Q_DECL_OVERRIDE
   {
     return m_alpha ;
   }
   
-  void setAlpha(int a)
+  void setAlpha(int a) Q_DECL_OVERRIDE
   {
     m_alpha = a / 255.0f;    
     redraw();
   }
 private:
-  enum Buffer
-  {
-      Vertices =0,
-      Normals,
-      Colors,
-      Edges,
-      Barycenters,
-      NumberOfBuffers
-  };
-  enum Vao
-  {
-      Facets=0,
-      Lines,
-      NumberOfVaos
-  };
 
   //contains the data
   mutable std::vector<float> *vertices;
@@ -460,33 +427,6 @@ struct Scene_c3t3_item_priv {
     computed_stats = false;
   }
 
-
-  enum Buffer
-  {
-      Facet_vertices =0,
-      Facet_normals,
-      Facet_colors,
-      Facet_barycenters,
-      Edges_vertices,
-      Edges_CNC,
-      Grid_vertices,
-      iEdges_vertices,
-      iFacet_vertices,
-      iFacet_normals,
-      iFacet_colors,
-      NumberOfBuffers
-  };
-  enum Vao
-  {
-      Facets=0,
-      Edges,
-      Grid,
-      CNC,
-      iEdges,
-      iFacets,
-      NumberOfVaos
-  };
-
   enum STATS {
     MIN_EDGES_LENGTH = 0,
     MAX_EDGES_LENGTH,
@@ -583,36 +523,38 @@ struct Set_show_tetrahedra {
   }
 };
 
-Scene_c3t3_item::Scene_c3t3_item(bool is_surface)
-  : Scene_group_item("unnamed", Scene_c3t3_item_priv::NumberOfBuffers, Scene_c3t3_item_priv::NumberOfVaos)
-  , d(new Scene_c3t3_item_priv(this))
-
+void Scene_c3t3_item::common_constructor(bool is_surface)
 {
-
   compute_bbox();
   connect(d->frame, SIGNAL(modified()), this, SLOT(changed()));
   c3t3_changed();
   setRenderingMode(FlatPlusEdges);
   create_flat_and_wire_sphere(1.0f,d->s_vertex,d->s_normals, d->ws_vertex);
+  
   d->is_surface = is_surface;
   d->is_grid_shown = !is_surface;
-  d->show_tetrahedra = !is_surface;
+  d->show_tetrahedra = is_surface;
+  
+  setTriangleContainer(C3t3_faces, new Tc(Vi::PROGRAM_C3T3, false));
+  
+  setEdgeContainer(CNC, new Ec(Vi::PROGRAM_NO_SELECTION, false));
+  setEdgeContainer(Grid_edges, new Ec(Vi::PROGRAM_NO_SELECTION, false));
+  setEdgeContainer(C3t3_edges, new Ec(Vi::PROGRAM_C3T3_EDGES, false));
+  setPointContainer(C3t3_points, new Pc(Vi::PROGRAM_C3T3_EDGES, false));
+}
+Scene_c3t3_item::Scene_c3t3_item(bool is_surface)
+  : Scene_group_item("unnamed")
+  , d(new Scene_c3t3_item_priv(this))
+{
+  common_constructor(is_surface);
 }
 
 Scene_c3t3_item::Scene_c3t3_item(const C3t3& c3t3, bool is_surface)
-  : Scene_group_item("unnamed", Scene_c3t3_item_priv::NumberOfBuffers, Scene_c3t3_item_priv::NumberOfVaos)
+  : Scene_group_item("unnamed")
   , d(new Scene_c3t3_item_priv(c3t3, this))
 {
-
-  compute_bbox();
-  connect(d->frame, SIGNAL(modified()), this, SLOT(changed()));
-  d->reset_cut_plane();
-  d->is_surface = is_surface;
-  d->is_grid_shown = !is_surface;
-  d->show_tetrahedra = !is_surface;
-  c3t3_changed();
-  setRenderingMode(FlatPlusEdges);
-  create_flat_and_wire_sphere(1.0f,d->s_vertex,d->s_normals, d->ws_vertex);
+  d->reset_cut_plane();  
+  common_constructor(is_surface);
 }
 
 Scene_c3t3_item::~Scene_c3t3_item()
@@ -971,41 +913,36 @@ QString Scene_c3t3_item::toolTip() const {
 }
 
 void Scene_c3t3_item::draw(CGAL::Three::Viewer_interface* viewer) const {
-  Scene_c3t3_item* ncthis = const_cast<Scene_c3t3_item*>(this);
   if(!visible())
     return;
-  if (!are_buffers_filled)
+  Scene_c3t3_item* ncthis = const_cast<Scene_c3t3_item*>(this);
+  if(!isInit())
+    initGL();
+  if ( getBuffersFilled() &&
+       ! getBuffersInit(viewer))
   {
-    ncthis->d->computeElements();
-    ncthis->d->initializeBuffers(viewer);
+    initializeBuffers(viewer);
+    setBuffersInit(viewer, true);
   }
+  if(!getBuffersFilled())
+  {
+    computeElements();
+    initializeBuffers(viewer);
+  }
+  
   if(renderingMode() == Flat ||
      renderingMode() == FlatPlusEdges)
   {
-    QOpenGLFramebufferObject* fbo = viewer->depthPeelingFbo();
-    vaos[Scene_c3t3_item_priv::Facets]->bind();
-    d->program = getShaderProgram(PROGRAM_C3T3);
-    attribBuffers(viewer, PROGRAM_C3T3);
-    d->program->bind();
     QVector4D cp(this->plane().a(),this->plane().b(),this->plane().c(),this->plane().d());
-    d->program->setUniformValue("cutplane", cp);
+    getTriangleContainer(C3t3_faces)->setPlane(cp);
     float shrink_factor = getShrinkFactor();
-    d->program->setUniformValue("shrink_factor", shrink_factor);
+    getTriangleContainer(C3t3_faces)->setShrinkFactor(shrink_factor);
     // positions_poly_size is the number of total facets in the C3T3
     // it is only computed once and positions_poly is emptied at the end
-    d->program->setUniformValue("comparing", viewer->currentPass() > 0);;
-    d->program->setUniformValue("width", viewer->width()*1.0f);         
-    d->program->setUniformValue("height", viewer->height()*1.0f);       
-    d->program->setUniformValue("near", (float)viewer->camera()->zNear());     
-    d->program->setUniformValue("far", (float)viewer->camera()->zFar());       
-    d->program->setUniformValue("writing", viewer->isDepthWriting());   
-    d->program->setUniformValue("alpha", alpha());                     
-    d->program->setUniformValue("is_surface", d->is_surface);
-    if( fbo)
-      viewer->glBindTexture(GL_TEXTURE_2D, fbo->texture());
-    viewer->glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(d->positions_poly_size / 3));
-    d->program->release();
-    vaos[Scene_c3t3_item_priv::Facets]->release();
+    getTriangleContainer(C3t3_faces)->setAlpha(alpha());
+    
+    getTriangleContainer(C3t3_faces)->setIsSurface(d->is_surface);
+    getTriangleContainer(C3t3_faces)->draw(viewer, false);
     
     if(d->show_tetrahedra){
       ncthis->show_intersection(true);
@@ -1016,8 +953,11 @@ void Scene_c3t3_item::draw(CGAL::Three::Viewer_interface* viewer) const {
       
       if(!d->frame->isManipulated() && !d->are_intersection_buffers_filled)
       {
+        //initGL
+        d->intersection->gl_initialization(viewer);
         ncthis->d->computeIntersections();
-        d->intersection->initialize_buffers(viewer);
+        
+        d->intersection->initializeBuffers(viewer);
         d->are_intersection_buffers_filled = true;
         ncthis->show_intersection(true);
       }
@@ -1030,18 +970,12 @@ void Scene_c3t3_item::draw(CGAL::Three::Viewer_interface* viewer) const {
   }
   if(d->is_grid_shown)
   {
-    vaos[Scene_c3t3_item_priv::Grid]->bind();
-    d->program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);
-    attribBuffers(viewer, PROGRAM_WITHOUT_LIGHT);
-    d->program->bind();
-    d->program->setAttributeValue("colors", QColor(Qt::black));
+    getEdgeContainer(Grid_edges)->setColor(QColor(Qt::black));
     QMatrix4x4 f_mat;
     for (int i = 0; i<16; i++)
       f_mat.data()[i] = d->frame->matrix()[i];
-    d->program->setUniformValue("f_matrix", f_mat);
-    viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_grid.size() / 3));
-    d->program->release();
-    vaos[Scene_c3t3_item_priv::Grid]->release();
+    getEdgeContainer(Grid_edges)->setFrameMatrix(f_mat);
+    getEdgeContainer(Grid_edges)->draw(viewer, true);
   }
 }
 
@@ -1058,39 +992,34 @@ void Scene_c3t3_item::drawEdges(CGAL::Three::Viewer_interface* viewer) const {
       if(renderMode == GL_SELECT) return;
     }
     Scene_c3t3_item* ncthis = const_cast<Scene_c3t3_item*>(this);
-    if (!are_buffers_filled)
+    if(!isInit())
+      initGL();
+    if ( getBuffersFilled() &&
+         ! getBuffersInit(viewer))
     {
-      ncthis->d->computeElements();
-      ncthis->d->initializeBuffers(viewer);
+      initializeBuffers(viewer);
+      setBuffersInit(viewer, true);
+    }
+    if(!getBuffersFilled())
+    {
+      computeElements();
+      initializeBuffers(viewer);
     }
-    
     if(renderingMode() == Wireframe && d->is_grid_shown)
     {
-      vaos[Scene_c3t3_item_priv::Grid]->bind();
-      
-      d->program = getShaderProgram(PROGRAM_NO_SELECTION);
-      attribBuffers(viewer, PROGRAM_NO_SELECTION);
-      d->program->bind();
-      d->program->setAttributeValue("colors", QColor(Qt::black));
+     getEdgeContainer(Grid_edges)->setColor(QColor(Qt::black));
       QMatrix4x4 f_mat;
       for (int i = 0; i<16; i++)
         f_mat.data()[i] = d->frame->matrix()[i];
-      d->program->setUniformValue("f_matrix", f_mat);
-      viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_grid.size() / 3));
-      d->program->release();
-      vaos[Scene_c3t3_item_priv::Grid]->release();
+      getEdgeContainer(Grid_edges)->setFrameMatrix(f_mat);
+      getEdgeContainer(Grid_edges)->draw(viewer, true);
     }
-    vaos[Scene_c3t3_item_priv::Edges]->bind();
-    d->program = getShaderProgram(PROGRAM_C3T3_EDGES);
-    attribBuffers(viewer, PROGRAM_C3T3_EDGES);
-    d->program->bind();
+    
     QVector4D cp(this->plane().a(),this->plane().b(),this->plane().c(),this->plane().d());
-    d->program->setUniformValue("cutplane", cp);
-    d->program->setUniformValue("is_surface", d->is_surface);
-    d->program->setAttributeValue("colors", QColor(Qt::black));
-    viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_lines_size / 3));
-    d->program->release();
-    vaos[Scene_c3t3_item_priv::Edges]->release();
+    getEdgeContainer(C3t3_edges)->setPlane(cp);
+    getEdgeContainer(C3t3_edges)->setIsSurface(d->is_surface);
+    getEdgeContainer(C3t3_edges)->setColor(QColor(Qt::black));
+    getEdgeContainer(C3t3_edges)->draw(viewer, true);
     
     if(d->show_tetrahedra){
       if(!d->frame->isManipulated())
@@ -1099,8 +1028,9 @@ void Scene_c3t3_item::drawEdges(CGAL::Three::Viewer_interface* viewer) const {
         d->intersection->setFast(true);
       if(!d->frame->isManipulated() && !d->are_intersection_buffers_filled)
       {
+        d->intersection->gl_initialization(viewer);
         ncthis->d->computeIntersections();
-        d->intersection->initialize_buffers(viewer);
+        d->intersection->initializeBuffers(viewer);
         d->are_intersection_buffers_filled = true;
       }
     }
@@ -1111,14 +1041,8 @@ void Scene_c3t3_item::drawEdges(CGAL::Three::Viewer_interface* viewer) const {
   }
   if(d->cnc_are_shown)
   {
-    vaos[Scene_c3t3_item_priv::CNC]->bind();
-    d->program = getShaderProgram(PROGRAM_NO_SELECTION);
-    attribBuffers(viewer, PROGRAM_NO_SELECTION);
-    d->program->bind();
-    d->program->setAttributeValue("colors", QColor(Qt::black));
-    viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_lines_not_in_complex_size / 3));
-    d->program->release();
-    vaos[Scene_c3t3_item_priv::CNC]->release();
+    getEdgeContainer(CNC)->setColor(QColor(Qt::black));
+    getEdgeContainer(CNC)->draw(viewer, true);
   }
 }
 
@@ -1129,37 +1053,35 @@ void Scene_c3t3_item::drawPoints(CGAL::Three::Viewer_interface * viewer) const
   if(renderingMode() == Points)
   {
     Scene_c3t3_item* ncthis = const_cast<Scene_c3t3_item*>(this);
-    if (!are_buffers_filled)
+    if(!isInit())
+      initGL();
+    if ( getBuffersFilled() &&
+         ! getBuffersInit(viewer))
     {
-      ncthis->d->computeElements();
-      ncthis->d->initializeBuffers(viewer);
+      initializeBuffers(viewer);
+      setBuffersInit(viewer, true);
     }
-    vaos[Scene_c3t3_item_priv::Edges]->bind();
-    d->program = getShaderProgram(PROGRAM_C3T3_EDGES);
-    attribBuffers(viewer, PROGRAM_C3T3_EDGES);
-    d->program->bind();
+    if(!getBuffersFilled())
+    {
+      computeElements();
+      initializeBuffers(viewer);
+    }
+    
+    
     QVector4D cp(this->plane().a(),this->plane().b(),this->plane().c(),this->plane().d());
-    d->program->setUniformValue("cutplane", cp);
-    d->program->setUniformValue("is_surface", d->is_surface);
-    d->program->setAttributeValue("colors", this->color());
-    viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(d->positions_lines.size() / 3));
-    vaos[Scene_c3t3_item_priv::Edges]->release();
-    d->program->release();
+    getPointContainer(C3t3_points)->setPlane(cp);
+    getPointContainer(C3t3_points)->setIsSurface(d->is_surface);
+    getPointContainer(C3t3_points)->setColor(this->color());
+    getPointContainer(C3t3_points)->draw(viewer, true);
     
     if(d->is_grid_shown)
     {
-      vaos[Scene_c3t3_item_priv::Grid]->bind();
-      d->program = getShaderProgram(PROGRAM_NO_SELECTION);
-      attribBuffers(viewer, PROGRAM_NO_SELECTION);
-      d->program->bind();
-      d->program->setAttributeValue("colors", this->color());
+      getEdgeContainer(Grid_edges)->setColor(QColor(Qt::black));
       QMatrix4x4 f_mat;
       for (int i = 0; i<16; i++)
         f_mat.data()[i] = d->frame->matrix()[i];
-      d->program->setUniformValue("f_matrix", f_mat);
-      viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->positions_grid.size() / 3));
-      d->program->release();
-      vaos[Scene_c3t3_item_priv::Grid]->release();
+      getEdgeContainer(Grid_edges)->setFrameMatrix(f_mat);
+      getEdgeContainer(Grid_edges)->draw(viewer, true);
     }
     if(d->spheres_are_shown)
     {
@@ -1370,113 +1292,54 @@ void Scene_c3t3_item_priv::initializeBuffers(CGAL::Three::Viewer_interface *view
 {
   //vao containing the data for the facets
   {
-    program = item->getShaderProgram(Scene_c3t3_item::PROGRAM_C3T3, viewer);
-    program->bind();
-
-    item->vaos[Facets]->bind();
-    item->buffers[Facet_vertices].bind();
-    item->buffers[Facet_vertices].allocate(positions_poly.data(),
-      static_cast<int>(positions_poly.size()*sizeof(float)));
-    program->enableAttributeArray("vertex");
-    program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
-    item->buffers[Facet_vertices].release();
-
-    item->buffers[Facet_normals].bind();
-    item->buffers[Facet_normals].allocate(normals.data(),
-      static_cast<int>(normals.size()*sizeof(float)));
-    program->enableAttributeArray("normals");
-    program->setAttributeBuffer("normals", GL_FLOAT, 0, 3);
-    item->buffers[Facet_normals].release();
-
-    item->buffers[Facet_colors].bind();
-    item->buffers[Facet_colors].allocate(f_colors.data(),
-      static_cast<int>(f_colors.size()*sizeof(float)));
-    program->enableAttributeArray("colors");
-    program->setAttributeBuffer("colors", GL_FLOAT, 0, 3);
-    item->buffers[Facet_colors].release();
-
-    item->buffers[Facet_barycenters].bind();
-    item->buffers[Facet_barycenters].allocate(positions_barycenter.data(),
-      static_cast<int>(positions_barycenter.size()*sizeof(float)));
-    program->enableAttributeArray("barycenter");
-    program->setAttributeBuffer("barycenter", GL_FLOAT, 0, 3);
-    item->buffers[Facet_barycenters].release();
-
-    item->vaos[Facets]->release();
-    program->release();
-    positions_poly_size = positions_poly.size();
+    item->getTriangleContainer(Scene_c3t3_item::C3t3_faces)->initializeBuffers(viewer);
+    item->getTriangleContainer(Scene_c3t3_item::C3t3_faces)->setFlatDataSize(
+          positions_poly_size);
+    
+    
     positions_poly.clear();
-    positions_poly.swap(positions_poly);
+    positions_poly.shrink_to_fit();
     normals.clear();
-    normals.swap(normals);
+    normals.shrink_to_fit();
     f_colors.clear();
-    f_colors.swap(f_colors);
+    f_colors.shrink_to_fit();
     positions_barycenter.clear();
-    positions_barycenter.swap(positions_barycenter);
+    positions_barycenter.shrink_to_fit();
   }
 
   //vao containing the data for the lines
   {
-    program = item->getShaderProgram(Scene_c3t3_item::PROGRAM_C3T3_EDGES, viewer);
-    program->bind();
-
-    item->vaos[Edges]->bind();
-    item->buffers[Edges_vertices].bind();
-    item->buffers[Edges_vertices].allocate(positions_lines.data(),
-                                     static_cast<int>(positions_lines.size()*sizeof(float)));
-    program->enableAttributeArray("vertex");
-    program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
-    item->buffers[Edges_vertices].release();
-
-    item->vaos[Edges]->release();
-    program->release();
-
-    positions_lines_size = positions_lines.size();
+    item->getEdgeContainer(Scene_c3t3_item::C3t3_edges)->initializeBuffers(viewer);
+    item->getEdgeContainer(Scene_c3t3_item::C3t3_edges)->setFlatDataSize(
+          positions_lines_size);
+    
     positions_lines.clear();
-    positions_lines.swap(positions_lines);
-
+    positions_lines.shrink_to_fit();
+  }
+  //vao containing the data for the points
+  {
+    item->getPointContainer(Scene_c3t3_item::C3t3_points)->initializeBuffers(viewer);
+    item->getPointContainer(Scene_c3t3_item::C3t3_points)->setFlatDataSize(
+          positions_lines_size);
+    
+    positions_lines.clear();
+    positions_lines.shrink_to_fit();
   }
-
   // vao containing the data for the cnc
   {
-    program = item->getShaderProgram(Scene_c3t3_item::PROGRAM_NO_SELECTION, viewer);
-    program->bind();
-
-    item->vaos[CNC]->bind();
-    item->buffers[Edges_CNC].bind();
-    item->buffers[Edges_CNC].allocate(positions_lines_not_in_complex.data(),
-                                     static_cast<int>(positions_lines_not_in_complex.size()*sizeof(float)));
-    program->enableAttributeArray("vertex");
-    program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
-    item->buffers[Edges_CNC].release();
-
-    item->vaos[CNC]->release();
-    program->release();
-
-    positions_lines_not_in_complex_size = positions_lines_not_in_complex.size();
+    item->getEdgeContainer(Scene_c3t3_item::CNC)->initializeBuffers(viewer);
+    item->getEdgeContainer(Scene_c3t3_item::CNC)->setFlatDataSize(
+          positions_lines_not_in_complex_size);
     positions_lines_not_in_complex.clear();
-    positions_lines_not_in_complex.swap(positions_lines_not_in_complex);
-
+    positions_lines_not_in_complex.shrink_to_fit();
   }
 
   //vao containing the data for the grid
   {
-    program = item->getShaderProgram(Scene_c3t3_item::PROGRAM_NO_SELECTION, viewer);
-    program->bind();
-
-    item->vaos[Grid]->bind();
-    item->buffers[Grid_vertices].bind();
-    item->buffers[Grid_vertices].allocate(positions_grid.data(),
-                                    static_cast<int>(positions_grid.size()*sizeof(float)));
-    program->enableAttributeArray("vertex");
-    program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
-    item->buffers[Grid_vertices].release();
-    item->vaos[Grid]->release();
-    program->release();
+    item->getEdgeContainer(Scene_c3t3_item::Grid_edges)->initializeBuffers(viewer);
+    item->getEdgeContainer(Scene_c3t3_item::Grid_edges)->setFlatDataSize(
+          positions_grid.size());
   }
-
-    program->release();
-    item->are_buffers_filled = true;
 }
 
 
@@ -1556,6 +1419,7 @@ void Scene_c3t3_item_priv::computeIntersections()
   tree.all_intersected_primitives(plane,
         boost::make_function_output_iterator(ComputeIntersection(*this)));
   intersected_cells.clear();
+  intersection->computeElements();
 }
 
 void Scene_c3t3_item_priv::computeSpheres()
@@ -1618,9 +1482,7 @@ void Scene_c3t3_item_priv::computeSpheres()
 }
 
 void Scene_c3t3_item_priv::computeElements()
-{
-  QApplication::setOverrideCursor(Qt::WaitCursor);
-  
+{  
   if(!alphaSlider)
    {
      alphaSlider = new QSlider(::Qt::Horizontal);
@@ -1722,7 +1584,6 @@ void Scene_c3t3_item_priv::computeElements()
       }
     }
   }
-  QApplication::restoreOverrideCursor();
 }
 
 bool Scene_c3t3_item::load_binary(std::istream& is)
@@ -2125,7 +1986,13 @@ CGAL::Three::Scene_item::Header_data Scene_c3t3_item::header() const
 
 void Scene_c3t3_item::invalidateOpenGLBuffers()
 {
-  are_buffers_filled = false;
+  setBuffersFilled(false);
+  getTriangleContainer(C3t3_faces)->reset_vbos(ALL);
+  getEdgeContainer(C3t3_edges)->reset_vbos(ALL);
+  getEdgeContainer(CNC)->reset_vbos(ALL);
+  getEdgeContainer(Grid_edges)->reset_vbos(ALL);
+  getPointContainer(C3t3_points)->reset_vbos(ALL);
+  
   resetCutPlane();
   compute_bbox();
   d->invalidate_stats();
@@ -2184,4 +2051,63 @@ void Scene_c3t3_item::setAlpha(int alpha)
 
 QSlider* Scene_c3t3_item::alphaSlider() { return d->alphaSlider; }
 
+void Scene_c3t3_item::initializeBuffers(Viewer_interface *v) const
+{
+  d->initializeBuffers(v);
+}
+
+void Scene_c3t3_item::computeElements()const
+{
+  QApplication::setOverrideCursor(Qt::WaitCursor);
+  d->computeElements();
+  
+  getTriangleContainer(C3t3_faces)->allocate(
+        Tc::Flat_vertices, d->positions_poly.data(),
+        static_cast<int>(d->positions_poly.size()*sizeof(float)));
+  
+  getTriangleContainer(C3t3_faces)->allocate(
+        Tc::Flat_normals,
+        d->normals.data(),
+        static_cast<int>(d->normals.size()*sizeof(float)));
+  
+  
+  getTriangleContainer(C3t3_faces)->allocate(
+        Tc::FColors,
+        d->f_colors.data(),
+        static_cast<int>(d->f_colors.size()*sizeof(float)));
+  
+  getTriangleContainer(C3t3_faces)->allocate(
+        Tc::Facet_centers,
+        d->positions_barycenter.data(),
+        static_cast<int>(d->positions_barycenter.size()*sizeof(float)));
+  
+  d->positions_poly_size = d->positions_poly.size();
+  
+  getEdgeContainer(C3t3_edges)->allocate(
+        Ec::Vertices,
+        d->positions_lines.data(),
+        static_cast<int>(d->positions_lines.size()*sizeof(float)));
+  d->positions_lines_size = d->positions_lines.size();
+  
+  getEdgeContainer(CNC)->allocate(
+        Ec::Vertices,
+        d->positions_lines_not_in_complex.data(),
+        static_cast<int>(d->positions_lines_not_in_complex.size()*sizeof(float)));
+  
+  d->positions_lines_not_in_complex_size = d->positions_lines_not_in_complex.size();
+  
+  getEdgeContainer(Grid_edges)->allocate(
+        Ec::Vertices,
+        d->positions_grid.data(),
+        static_cast<int>(d->positions_grid.size()*sizeof(float)));
+  
+  getPointContainer(C3t3_points)->allocate(
+        Pc::Vertices,
+        d->positions_lines.data(),
+        static_cast<int>(d->positions_lines.size()*sizeof(float)));
+  
+  setBuffersFilled(true);
+  QApplication::restoreOverrideCursor();
+}
 #include "Scene_c3t3_item.moc"
+
diff --git a/Polyhedron/demo/Polyhedron/Scene_c3t3_item.h b/Polyhedron/demo/Polyhedron/Scene_c3t3_item.h
index 5a6e41eb2cd..b2cd94d111b 100644
--- a/Polyhedron/demo/Polyhedron/Scene_c3t3_item.h
+++ b/Polyhedron/demo/Polyhedron/Scene_c3t3_item.h
@@ -38,6 +38,7 @@ public:
   Scene_c3t3_item(const C3t3& c3t3, bool is_surface = false);
   ~Scene_c3t3_item();
 
+  void common_constructor(bool is_surface);
   bool has_stats()const  Q_DECL_OVERRIDE {return true;}
   QString computeStats(int type)  Q_DECL_OVERRIDE;
   CGAL::Three::Scene_item::Header_data header() const Q_DECL_OVERRIDE;
@@ -156,9 +157,23 @@ public:
 
   void itemAboutToBeDestroyed(Scene_item *) Q_DECL_OVERRIDE;
 
+  void initializeBuffers(Viewer_interface *) const Q_DECL_OVERRIDE;
+  void computeElements() const Q_DECL_OVERRIDE;
+  
   protected:
     friend struct Scene_c3t3_item_priv;
     Scene_c3t3_item_priv* d;
+    enum Face_Containers{
+      C3t3_faces = 0
+    };
+    enum Edge_Containers{
+      C3t3_edges = 0,
+      Grid_edges,
+      CNC
+    };
+    enum Point_Container{
+      C3t3_points = 0
+    };
 
 };
 
diff --git a/Polyhedron/demo/Polyhedron/Scene_group_item.cpp b/Polyhedron/demo/Polyhedron/Scene_group_item.cpp
index 34be29ac0fc..c35335b93f4 100644
--- a/Polyhedron/demo/Polyhedron/Scene_group_item.cpp
+++ b/Polyhedron/demo/Polyhedron/Scene_group_item.cpp
@@ -1,15 +1,15 @@
 #include <CGAL/Three/Scene_group_item.h>
 #include <CGAL/Three/Viewer_interface.h>
+#include <CGAL/Three/Three.h>
 #include <QDebug>
 
 using namespace CGAL::Three;
-Scene_group_item::Scene_group_item(QString name, int nb_vbos, int nb_vaos )
-    :  Scene_item(nb_vbos, nb_vaos)
-    , scene(NULL)
+Scene_group_item::Scene_group_item(QString name)
 {
     this->name_ = name;
     expanded = true;
     already_drawn = false;
+    scene = Three::scene();
 }
 
 bool Scene_group_item::isFinite() const
@@ -244,6 +244,3 @@ void Scene_group_item::setAlpha(int )
     scene->item(id)->setAlpha(static_cast<int>(alpha()*255));
   }
 }
-
-void Scene_group_item::removeViewer(CGAL::Three::Viewer_interface*)
-{}
diff --git a/Polyhedron/demo/Polyhedron/Scene_plane_item.cpp b/Polyhedron/demo/Polyhedron/Scene_plane_item.cpp
index b3210b21e5c..afc06fabfe0 100644
--- a/Polyhedron/demo/Polyhedron/Scene_plane_item.cpp
+++ b/Polyhedron/demo/Polyhedron/Scene_plane_item.cpp
@@ -102,6 +102,7 @@ void Scene_plane_item::computeElements() const
                                           static_cast<int>(positions_lines.size() 
                                                            * sizeof(float)));
     }
+    setBuffersFilled(true);
     QApplication::restoreOverrideCursor();
 }
 
diff --git a/Polyhedron/demo/Polyhedron/Scene_polylines_item.cpp b/Polyhedron/demo/Polyhedron/Scene_polylines_item.cpp
index 2055f3f75d6..60f15c23f4a 100644
--- a/Polyhedron/demo/Polyhedron/Scene_polylines_item.cpp
+++ b/Polyhedron/demo/Polyhedron/Scene_polylines_item.cpp
@@ -8,6 +8,14 @@
 #include <QAction>
 #include <QInputDialog>
 #include <QApplication>
+#include <CGAL/Three/Edge_container.h>
+#include <CGAL/Three/Point_container.h>
+#include <CGAL/Three/Three.h>
+
+using namespace CGAL::Three;
+typedef Edge_container Ec;
+typedef Point_container Pc;
+typedef Viewer_interface Vi;
 
 struct Scene_polylines_item_private {
     typedef Scene_polylines_item::K K;
@@ -66,7 +74,7 @@ struct Scene_polylines_item_private {
 
 
 void
-Scene_polylines_item_private::initializeBuffers(CGAL::Three::Viewer_interface *viewer = 0) const
+Scene_polylines_item_private::initializeBuffers(CGAL::Three::Viewer_interface *viewer) const
 {
   float lineWidth[2];
   if(!viewer->isOpenGL_4_3())
@@ -77,35 +85,18 @@ Scene_polylines_item_private::initializeBuffers(CGAL::Three::Viewer_interface *v
     lineWidth[1] = 10;
   }
   line_Slider->setMaximum(lineWidth[1]);
-    QOpenGLShaderProgram *program;
-   //vao for the lines
-    {
-      if(viewer->isOpenGL_4_3())
-        program = item->getShaderProgram(Scene_polylines_item::PROGRAM_SOLID_WIREFRAME, viewer);
-      else
-        program = item->getShaderProgram(Scene_polylines_item::PROGRAM_NO_SELECTION, viewer);
-      program->bind();
-      
-      item->vaos[Edges]->bind();
-      item->buffers[Edges_Vertices].bind();
-      item->buffers[Edges_Vertices].allocate(positions_lines.data(),
-                                             static_cast<int>(positions_lines.size()*sizeof(float)));
-      program->enableAttributeArray("vertex");
-      program->setAttributeBuffer("vertex",GL_FLOAT,0,4);
-      item->buffers[Edges_Vertices].release();
-      item->vaos[Edges]->release();
-      program->release();
-      
-      nb_lines = positions_lines.size();
-      positions_lines.clear();
-      positions_lines.swap(positions_lines);
-    }
-    item->are_buffers_filled = true;
+  
+  item->getEdgeContainer(0)->initializeBuffers(viewer);
+  item->getEdgeContainer(0)->setFlatDataSize(nb_lines);
+  item->getPointContainer(0)->initializeBuffers(viewer);
+  item->getPointContainer(0)->setFlatDataSize(nb_lines);  
 }
+
 void
 Scene_polylines_item_private::computeElements() const
 {
-    const CGAL::qglviewer::Vec offset = static_cast<CGAL::Three::Viewer_interface*>(CGAL::QGLViewer::QGLViewerPool().first())->offset();
+    const CGAL::qglviewer::Vec offset = static_cast<CGAL::Three::Viewer_interface*>(
+          CGAL::QGLViewer::QGLViewerPool().first())->offset();
     QApplication::setOverrideCursor(Qt::WaitCursor);
     positions_lines.resize(0);
     double mean = 0;
@@ -138,18 +129,28 @@ Scene_polylines_item_private::computeElements() const
             positions_lines.push_back(a.x()+offset.x);
             positions_lines.push_back(a.y()+offset.y);
             positions_lines.push_back(a.z()+offset.z);
-            positions_lines.push_back(1.0);
 
             positions_lines.push_back(b.x()+offset.x);
             positions_lines.push_back(b.y()+offset.y);
             positions_lines.push_back(b.z()+offset.z);
-            positions_lines.push_back(1.0);
         }
 
     }
     if(!computed_stats)
       mean_length = mean/double(nb_edges);
     computed_stats = true;
+    
+    item->getEdgeContainer(0)->allocate(
+          Ec::Vertices, positions_lines.data(),
+          static_cast<int>(positions_lines.size()*sizeof(float)));
+    item->getPointContainer(0)->allocate(
+          Pc::Vertices, positions_lines.data(),
+          static_cast<int>(positions_lines.size()*sizeof(float)));
+    
+    item->setBuffersFilled(true);
+    nb_lines = positions_lines.size();
+    positions_lines.clear();
+    positions_lines.shrink_to_fit();
     QApplication::restoreOverrideCursor();
 }
 
@@ -265,14 +266,19 @@ Scene_polylines_item_private::computeSpheres()
 }
 
 Scene_polylines_item::Scene_polylines_item() 
-    :CGAL::Three::Scene_group_item("unnamed",Scene_polylines_item_private::NbOfVbos,Scene_polylines_item_private::NbOfVaos)
+    :CGAL::Three::Scene_group_item("unnamed")
     ,d(new Scene_polylines_item_private(this))
 {
     setRenderingMode(FlatPlusEdges);
     d->nb_lines = 0;
     d->spheres = NULL;
-    invalidateOpenGLBuffers();
-
+    setEdgeContainer(0, 
+                     new Ec(Three::mainViewer()->isOpenGL_4_3() ? Vi::PROGRAM_SOLID_WIREFRAME
+                                                                : Vi::PROGRAM_NO_SELECTION
+                                                                  , false));
+    setPointContainer(0, 
+                      new Pc(Vi::PROGRAM_NO_SELECTION, false));
+    
 }
 
 Scene_polylines_item::~Scene_polylines_item()
@@ -317,13 +323,13 @@ Scene_polylines_item::compute_bbox() const {
                 bbox.xmax(),
                 bbox.ymax(),
                 bbox.zmax());
+    is_bbox_computed = true;
 }
 
 Scene_item::Bbox Scene_polylines_item::bbox() const
 {
   if(!is_bbox_computed)
-      compute_bbox();
-  is_bbox_computed = true;
+    compute_bbox();
   return _bbox;
 }
 Scene_polylines_item* 
@@ -378,10 +384,18 @@ void
 Scene_polylines_item::draw(CGAL::Three::Viewer_interface* viewer) const {
   if(!visible())
     return;
-  if(!are_buffers_filled)
+  if(!isInit())
+    initGL();
+  if ( getBuffersFilled() &&
+       ! getBuffersInit(viewer))
   {
-    d->computeElements();
-    d->initializeBuffers(viewer);
+    initializeBuffers(viewer);
+    setBuffersInit(viewer, true);
+  }
+  if(!getBuffersFilled())
+  {
+    computeElements();
+    initializeBuffers(viewer);
   }
   if(d->draw_extremities)
   {
@@ -394,39 +408,32 @@ void
 Scene_polylines_item::drawEdges(CGAL::Three::Viewer_interface* viewer) const {
   if(!visible())
     return;
+  
   if(renderingMode() == Wireframe
      || renderingMode() == FlatPlusEdges)
   {
-    if(!are_buffers_filled)
+    if(!isInit())
+      initGL();
+    if ( getBuffersFilled() &&
+         ! getBuffersInit(viewer))
     {
-      d->computeElements();
-      d->initializeBuffers(viewer);
+      initializeBuffers(viewer);
+      setBuffersInit(viewer, true);
     }
-    
-    vaos[Scene_polylines_item_private::Edges]->bind();
-    if(!viewer->isOpenGL_4_3())
+    if(!getBuffersFilled())
     {
-      attribBuffers(viewer, PROGRAM_NO_SELECTION);
+      computeElements();
+      initializeBuffers(viewer);
     }
-    else
-    {
-      attribBuffers(viewer, PROGRAM_SOLID_WIREFRAME);
-    }
-    QOpenGLShaderProgram *program = viewer->isOpenGL_4_3() ? getShaderProgram(PROGRAM_SOLID_WIREFRAME)
-                                                           : getShaderProgram(PROGRAM_NO_SELECTION);
-    program->bind();
     if(viewer->isOpenGL_4_3())
     {
       QVector2D vp(viewer->width(), viewer->height());
-      program->setUniformValue("viewport", vp);
-      program->setUniformValue("near",(GLfloat)viewer->camera()->zNear());
-      program->setUniformValue("far",(GLfloat)viewer->camera()->zFar());
-      program->setUniformValue("width", GLfloat(d->line_Slider->value()));
+      
+      getEdgeContainer(0)->setViewport(vp);
+      getEdgeContainer(0)->setWidth(GLfloat(d->line_Slider->value()));
     }
-    program->setAttributeValue("colors", this->color());
-    viewer->glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(d->nb_lines/4));
-    program->release();
-    vaos[Scene_polylines_item_private::Edges]->release();
+    getEdgeContainer(0)->setColor(this->color());
+    getEdgeContainer(0)->draw(viewer, true);
   }
     if(d->draw_extremities)
     {
@@ -440,22 +447,23 @@ Scene_polylines_item::drawPoints(CGAL::Three::Viewer_interface* viewer) const {
     return;
   if(renderingMode() == Points)
   {
-    if(!are_buffers_filled)
+    if(!isInit())
+      initGL();
+    if ( getBuffersFilled() &&
+         ! getBuffersInit(viewer))
     {
-      d->computeElements();
-      d->initializeBuffers(viewer);
+      initializeBuffers(viewer);
+      setBuffersInit(viewer, true);
+    }
+    if(!getBuffersFilled())
+    {
+      computeElements();
+      initializeBuffers(viewer);
     }
     
-    vaos[Scene_polylines_item_private::Edges]->bind();
-    attribBuffers(viewer, PROGRAM_NO_SELECTION);
-    QOpenGLShaderProgram *program = getShaderProgram(PROGRAM_NO_SELECTION);
-    program->bind();
-    QColor temp = this->color();
-    program->setAttributeValue("colors", temp);
-    viewer->glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(d->nb_lines/4));
-    // Clean-up
-    vaos[Scene_polylines_item_private::Edges]->release();
-    program->release();
+    getPointContainer(0)->setColor(this->color());
+    getPointContainer(0)->draw(viewer, true);
+    
   }
    if(d->draw_extremities)
    {
@@ -501,7 +509,9 @@ QMenu* Scene_polylines_item::contextMenu()
 
 void Scene_polylines_item::invalidateOpenGLBuffers()
 {
-    are_buffers_filled = false;
+    setBuffersFilled(false);
+    getEdgeContainer(0)->reset_vbos(ALL);
+    getPointContainer(0)->reset_vbos(ALL);
     d->invalidate_stats();
     compute_bbox();
 
@@ -736,3 +746,13 @@ void Scene_polylines_item::setWidth( int i)
   d->line_Slider->setValue(i);
   redraw();
 }
+
+void Scene_polylines_item::initializeBuffers(Viewer_interface *v) const
+{
+  d->initializeBuffers(v);
+}
+
+void Scene_polylines_item::computeElements() const
+{
+  d->computeElements();
+}
diff --git a/Polyhedron/demo/Polyhedron/Scene_polylines_item.h b/Polyhedron/demo/Polyhedron/Scene_polylines_item.h
index b2d14f780da..c1ed7b99fa0 100644
--- a/Polyhedron/demo/Polyhedron/Scene_polylines_item.h
+++ b/Polyhedron/demo/Polyhedron/Scene_polylines_item.h
@@ -14,7 +14,8 @@
 struct Scene_polylines_item_private;
 class Scene_spheres_item;
 
-class SCENE_POLYLINES_ITEM_EXPORT Scene_polylines_item : public CGAL::Three::Scene_group_item
+class SCENE_POLYLINES_ITEM_EXPORT Scene_polylines_item 
+    : public CGAL::Three::Scene_group_item
 {
     Q_OBJECT
 public:
@@ -32,43 +33,41 @@ public:
       MAX_LENGTH,
       MEAN_LENGTH
     };
-    bool has_stats()const {return true;}
-    QString computeStats(int type);
-    CGAL::Three::Scene_item::Header_data header() const;
+    bool has_stats()const Q_DECL_OVERRIDE {return true;}
+    QString computeStats(int type)Q_DECL_OVERRIDE ;
+    CGAL::Three::Scene_item::Header_data header() const Q_DECL_OVERRIDE ;
 
-    bool isFinite() const { return true; }
-    bool isEmpty() const;
-    void compute_bbox() const;
-    Bbox bbox() const;
+    bool isFinite() const Q_DECL_OVERRIDE { return true; }
+    bool isEmpty() const Q_DECL_OVERRIDE ;
+    void compute_bbox() const Q_DECL_OVERRIDE ;
+    Bbox bbox() const Q_DECL_OVERRIDE ;
 
-    Scene_polylines_item* clone() const;
+    Scene_polylines_item* clone() const Q_DECL_OVERRIDE ;
 
-    QString toolTip() const;
+    QString toolTip() const Q_DECL_OVERRIDE ;
 
     // Indicate if rendering mode is supported
-    bool supportsRenderingMode(RenderingMode m) const;
+    bool supportsRenderingMode(RenderingMode m) const Q_DECL_OVERRIDE ;
 
-    QMenu* contextMenu();
+    QMenu* contextMenu() Q_DECL_OVERRIDE ;
 
-    // Flat/Gouraud OpenGL drawing
-    void draw() const {}
-    void draw(CGAL::Three::Viewer_interface*) const;
-
-    // Wireframe OpenGL drawing
-    void drawEdges() const{}
-    void drawEdges(CGAL::Three::Viewer_interface*) const;
-
-    void drawPoints() const{}
-    void drawPoints(CGAL::Three::Viewer_interface*) const;
+    void draw(CGAL::Three::Viewer_interface*) const Q_DECL_OVERRIDE ;
+    void drawEdges(CGAL::Three::Viewer_interface*) const Q_DECL_OVERRIDE ;
+    void drawPoints(CGAL::Three::Viewer_interface*) const Q_DECL_OVERRIDE ;
 
 
     void smooth(std::vector<Point_3>& polyline);
-    //When selecting a polylineitem, we don't want to select its children, so we can still apply Operations to it
-    QList<Scene_interface::Item_id> getChildrenForSelection() const { return QList<Scene_interface::Item_id>(); }
+    //When selecting a polylineitem, we don't want to select its children, so 
+    //we can still apply Operations to it
+    QList<Scene_interface::Item_id> getChildrenForSelection() const Q_DECL_OVERRIDE {
+      return QList<Scene_interface::Item_id>(); 
+    }
     void setWidth(int i);
+    void computeElements() const Q_DECL_OVERRIDE;
+    void initializeBuffers(Viewer_interface *) const Q_DECL_OVERRIDE;
 
 public Q_SLOTS:
-    virtual void invalidateOpenGLBuffers();
+    void invalidateOpenGLBuffers() Q_DECL_OVERRIDE;
     void change_corner_radii(double);
     void change_corner_radii();
     void split_at_sharp_angles();
diff --git a/Polyhedron/demo/Polyhedron/Scene_spheres_item.cpp b/Polyhedron/demo/Polyhedron/Scene_spheres_item.cpp
index 17016304a59..91cf07c46d7 100644
--- a/Polyhedron/demo/Polyhedron/Scene_spheres_item.cpp
+++ b/Polyhedron/demo/Polyhedron/Scene_spheres_item.cpp
@@ -1,6 +1,14 @@
 #include "Scene_spheres_item.h"
+#include <CGAL/Three/Triangle_container.h>
+#include <CGAL/Three/Edge_container.h>
 #include <QApplication>
 
+using namespace CGAL::Three;
+
+typedef Viewer_interface Vi;
+typedef Triangle_container Tc;
+typedef Edge_container Ec;
+
 struct Scene_spheres_item_priv
 {
   typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
@@ -59,11 +67,17 @@ struct Scene_spheres_item_priv
 
 };
 Scene_spheres_item::Scene_spheres_item(Scene_group_item* parent, bool planed)
-  :CGAL::Three::Scene_item(Scene_spheres_item_priv::NbOfVbos,Scene_spheres_item_priv::NbOfVaos)
-
 {
   setParent(parent);
   d = new Scene_spheres_item_priv(planed, this);
+  setTriangleContainer(0, 
+                       new Tc(planed ? Vi::PROGRAM_SPHERES
+                                     : Vi::PROGRAM_CUTPLANE_SPHERES
+                                       ,false));
+  setEdgeContainer(0, 
+                   new Ec(planed ? Vi::PROGRAM_SPHERES
+                                 : Vi::PROGRAM_CUTPLANE_SPHERES
+                                   ,false));
 }
 
 Scene_spheres_item::~Scene_spheres_item()
@@ -73,164 +87,75 @@ Scene_spheres_item::~Scene_spheres_item()
 
 void Scene_spheres_item_priv::initializeBuffers(CGAL::Three::Viewer_interface *viewer) const
 {
-  if(has_plane)
-  {
-    program = item->getShaderProgram(Scene_spheres_item::PROGRAM_CUTPLANE_SPHERES, viewer);
-    item->attribBuffers(viewer, Scene_spheres_item::PROGRAM_CUTPLANE_SPHERES);
-  }
-  else
-  {
-    program = item->getShaderProgram(Scene_spheres_item::PROGRAM_SPHERES, viewer);
-    item->attribBuffers(viewer, Scene_spheres_item::PROGRAM_SPHERES);
-  }
+  item->getTriangleContainer(0)->initializeBuffers(viewer);
+  item->getTriangleContainer(0)->setFlatDataSize(vertices.size());
+  item->getTriangleContainer(0)->setCenterSize(static_cast<int>(centers.size()));
+  //vertices.clear();
+  //vertices.shrink_to_fit();
+  item->getEdgeContainer(0)->initializeBuffers(viewer);
+  item->getEdgeContainer(0)->setFlatDataSize(edges.size());
+  item->getEdgeContainer(0)->setCenterSize(static_cast<int>(centers.size()));
+ // edges.clear();
+ // edges.shrink_to_fit();
 
-  program->bind();
-  item->vaos[Facets]->bind();
-  item->buffers[Vertices].bind();
-  item->buffers[Vertices].allocate(vertices.data(),
-                             static_cast<int>(vertices.size()*sizeof(float)));
-  program->enableAttributeArray("vertex");
-  program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
-  item->buffers[Vertices].release();
-
-  item->buffers[Normals].bind();
-  item->buffers[Normals].allocate(normals.data(),
-                            static_cast<int>(normals.size()*sizeof(float)));
-  program->enableAttributeArray("normals");
-  program->setAttributeBuffer("normals", GL_FLOAT, 0, 3);
-  item->buffers[Normals].release();
-
-  item->buffers[Color].bind();
-  item->buffers[Color].allocate(colors.data(),
-                          static_cast<int>(colors.size()*sizeof(float)));
-  program->enableAttributeArray("colors");
-  program->setAttributeBuffer("colors", GL_FLOAT, 0, 3);
-  item->buffers[Color].release();
-
-  item->buffers[Radius].bind();
-  item->buffers[Radius].allocate(radius.data(),
-                           static_cast<int>(radius.size()*sizeof(float)));
-  program->enableAttributeArray("radius");
-  program->setAttributeBuffer("radius", GL_FLOAT, 0, 1);
-  item->buffers[Radius].release();
-
-  item->buffers[Center].bind();
-  item->buffers[Center].allocate(centers.data(),
-                           static_cast<int>(centers.size()*sizeof(float)));
-  program->enableAttributeArray("center");
-  program->setAttributeBuffer("center", GL_FLOAT, 0, 3);
-  item->buffers[Center].release();
-
-  viewer->glVertexAttribDivisor(program->attributeLocation("center"), 1);
-  viewer->glVertexAttribDivisor(program->attributeLocation("radius"), 1);
-  viewer->glVertexAttribDivisor(program->attributeLocation("colors"), 1);
-  item->vaos[Facets]->release();
-
-
-  item->vaos[Edges]->bind();
-  item->buffers[Edge_vertices].bind();
-  item->buffers[Edge_vertices].allocate(edges.data(),
-                                  static_cast<int>(edges.size()*sizeof(float)));
-  program->enableAttributeArray("vertex");
-  program->setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
-  item->buffers[Edge_vertices].release();
-
-  item->buffers[Normals].bind();
-  program->enableAttributeArray("normals");
-  program->setAttributeBuffer("normals", GL_FLOAT, 0, 3);
-  item->buffers[Normals].release();
-
-  item->buffers[Edge_color].bind();
-  item->buffers[Edge_color].allocate(edges_colors.data(),
-                               static_cast<int>(edges_colors.size()*sizeof(float)));
-  program->enableAttributeArray("colors");
-  program->setAttributeBuffer("colors", GL_FLOAT, 0, 3);
-  item->buffers[Edge_color].release();
-
-  item->buffers[Radius].bind();
-  program->enableAttributeArray("radius");
-  program->setAttributeBuffer("radius", GL_FLOAT, 0, 1);
-  item->buffers[Radius].release();
-
-  item->buffers[Center].bind();
-  program->enableAttributeArray("center");
-  program->setAttributeBuffer("center", GL_FLOAT, 0, 3);
-  item->buffers[Center].release();
-
-  viewer->glVertexAttribDivisor(program->attributeLocation("center"), 1);
-  viewer->glVertexAttribDivisor(program->attributeLocation("radius"), 1);
-  viewer->glVertexAttribDivisor(program->attributeLocation("colors"), 1);
-  item->vaos[Edges]->release();
-
-  program->release();
-
-  nb_centers = static_cast<int>(centers.size());
-  centers.clear();
-  centers.swap(centers);
-  colors.clear();
-  colors.swap(colors);
-  radius.clear();
-  radius.swap(radius);
-  edges_colors.clear();
-  edges_colors.swap(edges_colors);
-
-  item->are_buffers_filled = true;
+  //centers.clear();
+  //centers.swap(centers);
+  //colors.clear();
+  //colors.swap(colors);
+  //radius.clear();
+  //radius.swap(radius);
+  //edges_colors.clear();
+  //edges_colors.swap(edges_colors);
 }
 
 void Scene_spheres_item::draw(Viewer_interface *viewer) const
 {
-  if (!are_buffers_filled)
+  if(!isInit())
+    initGL();
+  if ( getBuffersFilled() &&
+       ! getBuffersInit(viewer))
   {
-    d->initializeBuffers(viewer);
+    initializeBuffers(viewer);
+    setBuffersInit(viewer, true);
+  }
+  if(!getBuffersFilled())
+  {
+    computeElements();
+    initializeBuffers(viewer);
   }
-  vaos[Scene_spheres_item_priv::Facets]->bind();
   if(d->has_plane)
   {
-    d->program = getShaderProgram(PROGRAM_CUTPLANE_SPHERES, viewer);
-    attribBuffers(viewer, PROGRAM_CUTPLANE_SPHERES);
-    d->program->bind();
     QVector4D cp(d->plane.a(),d->plane.b(),d->plane.c(),d->plane.d());
-    d->program->setUniformValue("cutplane", cp);
-
+    getTriangleContainer(0)->setPlane(cp);
   }
-  else
-  {
-    d->program = getShaderProgram(PROGRAM_SPHERES, viewer);
-    attribBuffers(viewer, PROGRAM_SPHERES);
-    d->program->bind();
-  }
-  viewer->glDrawArraysInstanced(GL_TRIANGLES, 0,
-                                static_cast<GLsizei>(d->vertices.size()/3),
-                                static_cast<GLsizei>(d->nb_centers));
-  d->program->release();
-  vaos[Scene_spheres_item_priv::Facets]->release();
+  qDebug()<<"flat data size = "<<getTriangleContainer(0)->getFlatDataSize();
+  qDebug()<<"centers size = "<<getTriangleContainer(0)->getCenterSize();
+  getTriangleContainer(0)->draw(viewer, false);
 }
+
 void Scene_spheres_item::drawEdges(Viewer_interface *viewer) const
 {
-  if (!are_buffers_filled)
+  if(!isInit())
+    initGL();
+  if ( getBuffersFilled() &&
+       ! getBuffersInit(viewer))
   {
-    d->initializeBuffers(viewer);
+    initializeBuffers(viewer);
+    setBuffersInit(viewer, true);
   }
-  vaos[Scene_spheres_item_priv::Edges]->bind();
+  if(!getBuffersFilled())
+  {
+    computeElements();
+    initializeBuffers(viewer);
+  }
+  
   if(d->has_plane)
   {
-    d->program = getShaderProgram(PROGRAM_CUTPLANE_SPHERES, viewer);
-    attribBuffers(viewer, PROGRAM_CUTPLANE_SPHERES);
-    d->program->bind();
     QVector4D cp(d->plane.a(),d->plane.b(),d->plane.c(),d->plane.d());
-    d->program->setUniformValue("cutplane", cp);
+    getEdgeContainer(0)->setPlane(cp);
   }
-  else
-  {
-    d->program = getShaderProgram(PROGRAM_SPHERES, viewer);
-    attribBuffers(viewer, PROGRAM_SPHERES);
-    d->program->bind();
-  }
-  viewer->glDrawArraysInstanced(GL_LINES, 0,
-                                static_cast<GLsizei>(d->edges.size()/3),
-                                static_cast<GLsizei>(d->nb_centers));
-  d->program->release();
-  vaos[Scene_spheres_item_priv::Edges]->release();
+  getEdgeContainer(0)->draw(viewer, false);
+  
 }
 void Scene_spheres_item::add_sphere(const CGAL::Sphere_3<Kernel>& sphere, CGAL::Color color)
 {
@@ -258,7 +183,12 @@ void Scene_spheres_item::clear_spheres()
 }
 void Scene_spheres_item::setPrecision(int prec) { d->precision = prec; }
 void Scene_spheres_item::setPlane(Kernel::Plane_3 p_plane) { d->plane = p_plane; }
-void Scene_spheres_item::invalidateOpenGLBuffers(){are_buffers_filled = false;}
+void Scene_spheres_item::invalidateOpenGLBuffers()
+{
+  setBuffersFilled(false);
+  getTriangleContainer(0)->reset_vbos(ALL);
+  getEdgeContainer(0)->reset_vbos(ALL);
+}
 
 QString
 Scene_spheres_item::toolTip() const {
@@ -275,3 +205,42 @@ void Scene_spheres_item::setColor(QColor c)
   CGAL::Three::Scene_item::setColor(c);
   this->on_color_changed();
 }
+
+void Scene_spheres_item::initializeBuffers(Viewer_interface * v) const
+{
+  d->initializeBuffers(v);
+}
+
+void Scene_spheres_item::computeElements() const
+{
+  getTriangleContainer(0)->allocate(Tc::Flat_vertices, d->vertices.data(),
+                                    static_cast<int>(d->vertices.size()*sizeof(float)));
+  
+  getTriangleContainer(0)->allocate(Tc::Flat_normals, d->normals.data(),
+                                    static_cast<int>(d->normals.size()*sizeof(float)));
+  
+  getTriangleContainer(0)->allocate(Tc::FColors, d->colors.data(),
+                                    static_cast<int>(d->colors.size()*sizeof(float)));
+  
+  getTriangleContainer(0)->allocate(Tc::Radius, d->radius.data(),
+                                    static_cast<int>(d->radius.size()*sizeof(float)));
+  
+  getTriangleContainer(0)->allocate(Tc::Facet_centers, d->centers.data(),
+                                    static_cast<int>(d->centers.size()*sizeof(float)));
+  
+  getEdgeContainer(0)->allocate(Ec::Vertices, d->edges.data(),
+                                static_cast<int>(d->edges.size()*sizeof(float)));
+  
+  getEdgeContainer(0)->allocate(Ec::Normals, d->normals.data(), 
+                                static_cast<int>(d->normals.size()*sizeof(float)));
+  
+  getEdgeContainer(0)->allocate(Ec::Colors, d->edges_colors.data(),
+                                static_cast<int>(d->edges_colors.size()*sizeof(float)));
+  
+  getEdgeContainer(0)->allocate(Ec::Radius, d->radius.data(),
+                                static_cast<int>(d->radius.size()*sizeof(float)));
+  
+  getEdgeContainer(0)->allocate(Ec::Centers, d->centers.data(),
+                                static_cast<int>(d->centers.size()*sizeof(float)));
+  setBuffersFilled(true);
+}
diff --git a/Polyhedron/demo/Polyhedron/Scene_spheres_item.h b/Polyhedron/demo/Polyhedron/Scene_spheres_item.h
index 5167175bec3..652e9b538a7 100755
--- a/Polyhedron/demo/Polyhedron/Scene_spheres_item.h
+++ b/Polyhedron/demo/Polyhedron/Scene_spheres_item.h
@@ -4,7 +4,7 @@
 #include "create_sphere.h"
 
 #include <CGAL/Three/Scene_group_item.h>
-#include <CGAL/Three/Scene_item.h>
+#include <CGAL/Three/Scene_item_rendering_helper.h>
 #include <CGAL/Three/Scene_interface.h>
 #include <CGAL/Three/Viewer_interface.h>
 #include <CGAL/Sphere_3.h>
@@ -16,7 +16,7 @@
 #include <vector>
 struct Scene_spheres_item_priv;
 class SCENE_BASIC_OBJECTS_EXPORT Scene_spheres_item
-    : public CGAL::Three::Scene_item
+    : public CGAL::Three::Scene_item_rendering_helper
 {
   Q_OBJECT
 public:
@@ -42,12 +42,11 @@ public:
   void draw(CGAL::Three::Viewer_interface* viewer) const Q_DECL_OVERRIDE;
   void drawEdges(CGAL::Three::Viewer_interface* viewer) const Q_DECL_OVERRIDE;
   void invalidateOpenGLBuffers() Q_DECL_OVERRIDE;
-  void computeElements() const ;
   void setPlane(Kernel::Plane_3 p_plane);
   void setToolTip(QString s);
   void setColor(QColor c) Q_DECL_OVERRIDE;
-  void newViewer(Viewer_interface *viewer) Q_DECL_OVERRIDE{}
-  void removeViewer(Viewer_interface *viewer) Q_DECL_OVERRIDE{}
+  void initializeBuffers(Viewer_interface *) const Q_DECL_OVERRIDE;
+  void computeElements() const Q_DECL_OVERRIDE;
 Q_SIGNALS:
   void on_color_changed();
 protected:
diff --git a/Polyhedron/demo/Polyhedron/Triangle_container.cpp b/Polyhedron/demo/Polyhedron/Triangle_container.cpp
index 5233b74a8bc..c4f13900b2f 100644
--- a/Polyhedron/demo/Polyhedron/Triangle_container.cpp
+++ b/Polyhedron/demo/Polyhedron/Triangle_container.cpp
@@ -16,6 +16,7 @@ struct Tri_d{
   Triangle_container* container;
   float shrink_factor;
   QVector4D plane;
+  bool is_surface;
   float alpha;
   QMatrix4x4 f_matrix;
 };
@@ -93,13 +94,13 @@ void Triangle_container::initGL( Viewer_interface* viewer)
                        QOpenGLBuffer::VertexBuffer, GL_FLOAT, 0, 3));
       getVao(viewer)->addVbo(getVbo(FColors));
       
-      if(viewer->getShaderProgram(getProgram())->property("hasBarycenter").toBool())
+      if(viewer->getShaderProgram(getProgram())->property("hasCenter").toBool())
       {
-        if(!getVbo(Facet_barycenters))
-          setVbo(Facet_barycenters,
-                 new Vbo("barycenter",
+        if(!getVbo(Facet_centers))
+          setVbo(Facet_centers,
+                 new Vbo("center",
                          Vbo::GEOMETRY));
-        getVao(viewer)->addVbo(getVbo(Facet_barycenters));
+        getVao(viewer)->addVbo(getVbo(Facet_centers));
       }
       
       if(viewer->getShaderProgram(getProgram())->property("hasRadius").toBool())
@@ -153,6 +154,8 @@ void Triangle_container::draw(Viewer_interface* viewer,
     getVao(viewer)->bind();
     if(getVao(viewer)->program->property("hasCutPlane").toBool())
       getVao(viewer)->program->setUniformValue("cutplane", d->plane);
+    if(getVao(viewer)->program->property("hasSurfaceMode").toBool())
+      getVao(viewer)->program->setUniformValue("is_surface", d->is_surface);
     if(is_color_uniform)
       getVao(viewer)->program->setAttributeValue("colors", getColor());
     if(getVao(viewer)->program->property("hasFMatrix").toBool())
@@ -172,13 +175,13 @@ void Triangle_container::draw(Viewer_interface* viewer,
     if(getVao(viewer)->program->property("isInstanced").toBool())
     {
       viewer->glDrawArraysInstanced(GL_TRIANGLES, 0,
-                                    static_cast<GLsizei>(getFlatDataSize()/3),
+                                    static_cast<GLsizei>(getFlatDataSize()/getTupleSize()),
                                     static_cast<GLsizei>(getCenterSize()/3));
     }
     else
     {
 
-      viewer->glDrawArrays(GL_TRIANGLES,0,static_cast<GLsizei>(getFlatDataSize()/3));
+      viewer->glDrawArrays(GL_TRIANGLES,0,static_cast<GLsizei>(getFlatDataSize()/getTupleSize()));
     }
 
     getVao(viewer)->release();
@@ -192,8 +195,9 @@ void Triangle_container::initializeBuffers(Viewer_interface *viewer)
   if(getVao(viewer)->program->property("isInstanced").toBool())
   {
     getVao(viewer)->bind();
-    if(getVao(viewer)->program->property("hasBarycenter").toBool())
-      viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("barycenter"), 1);
+    if(getVao(viewer)->program->property("isInstanced").toBool() &&
+       getVao(viewer)->program->property("hasCenter").toBool())
+      viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("center"), 1);
     if(getVao(viewer)->program->property("hasRadius").toBool())
       viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("radius"), 1);
     viewer->glVertexAttribDivisor(getVao(viewer)->program->attributeLocation("colors"), 1);
@@ -209,3 +213,5 @@ QMatrix4x4 Triangle_container::getFrameMatrix() const { return d->f_matrix; }
 void Triangle_container::setShrinkFactor(const float& f) { d->shrink_factor = f; }
 void Triangle_container::setAlpha       (const float& f)        { d->alpha = f ; }
 void Triangle_container::setFrameMatrix(const QMatrix4x4& m) { d->f_matrix = m; }
+void Triangle_container::setPlane(const QVector4D& p) { d->plane = p; }
+void Triangle_container::setIsSurface  (const bool b) { d->is_surface = b; }
diff --git a/Polyhedron/demo/Polyhedron/Viewer.cpp b/Polyhedron/demo/Polyhedron/Viewer.cpp
index 6ef37374ceb..3d9fc9f123d 100755
--- a/Polyhedron/demo/Polyhedron/Viewer.cpp
+++ b/Polyhedron/demo/Polyhedron/Viewer.cpp
@@ -1084,6 +1084,7 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
     program->setProperty("hasNormals", true);
     program->setProperty("hasCutPlane", true);
     program->setProperty("hasTransparency", true);
+    program->setProperty("hasCenter", true);
     return program;
   }
   case PROGRAM_C3T3_EDGES:
@@ -1176,7 +1177,7 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
                           ":/cgal/Polyhedron_3/resources/compatibility_shaders/shader_without_light.f");
     program->setProperty("hasLight", true);
     program->setProperty("hasNormals", true);
-    program->setProperty("hasBarycenter", true);
+    program->setProperty("hasCenter", true);
     program->setProperty("isInstanced", true);
     return program;
   }
@@ -1188,7 +1189,7 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
                           ":/cgal/Polyhedron_3/resources/compatibility_shaders/shader_c3t3.f");
     program->setProperty("hasLight", true);
     program->setProperty("hasNormals", true);
-    program->setProperty("hasBarycenter", true);
+    program->setProperty("hasCenter", true);
     program->setProperty("hasRadius", true);
     program->setProperty("isInstanced", true);
     return program;
@@ -1201,7 +1202,7 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
                          ":/cgal/Polyhedron_3/resources/compatibility_shaders/shader_with_light.f");
     program->setProperty("hasLight", true);
     program->setProperty("hasNormals", true);
-    program->setProperty("hasBarycenter", true);
+    program->setProperty("hasCenter", true);
     program->setProperty("hasRadius", true);
     program->setProperty("hasTransparency", true);
     program->setProperty("isInstanced", true);
@@ -1231,15 +1232,19 @@ QOpenGLShaderProgram* Viewer::getShaderProgram(int name) const
     return program;
   }
   case PROGRAM_SOLID_WIREFRAME:
+  {
     if(!isOpenGL_4_3())
     {
       std::cerr<<"An OpenGL context of version 4.3 is required for the program ("<<name<<")."<<std::endl;
       return 0;
     }
-    return declare_program(name,
-                           ":/cgal/Polyhedron_3/resources/solid_wireframe_shader.v", 
-                           ":/cgal/Polyhedron_3/resources/solid_wireframe_shader.f");
-    break; 
+    QOpenGLShaderProgram* program = declare_program(name,
+                                                    ":/cgal/Polyhedron_3/resources/solid_wireframe_shader.v", 
+                                                    ":/cgal/Polyhedron_3/resources/solid_wireframe_shader.f");
+    program->setProperty("hasViewport", true);
+    program->setProperty("hasWidth", true);
+    return program;
+  }
   default:
     std::cerr<<"ERROR : Program not found."<<std::endl;
     return 0;
diff --git a/Polyhedron/demo/Polyhedron/resources/shader_c3t3.v b/Polyhedron/demo/Polyhedron/resources/shader_c3t3.v
index 80084533689..2c3b6bd0114 100644
--- a/Polyhedron/demo/Polyhedron/resources/shader_c3t3.v
+++ b/Polyhedron/demo/Polyhedron/resources/shader_c3t3.v
@@ -2,7 +2,7 @@
 in vec4 vertex;
 in vec3 normals;
 in vec3 colors;
-in vec3 barycenter;
+in vec3 center;
 uniform  mat4 mvp_matrix;
 uniform  mat4 mv_matrix;
 uniform  vec4 cutplane;
@@ -26,11 +26,11 @@ void main(void)
    mat4 transOB = mat4(1, 0, 0, 0, // first column
    0, 1, 0, 0, // second column
    0, 0, 1, 0, // third column
-   barycenter.x, barycenter.y, barycenter.z, 1); // fourth column
+   center.x, center.y, center.z, 1); // fourth column
    mat4 transBO = mat4(1, 0, 0, 0, // first column
     0, 1, 0, 0, // second column
     0, 0, 1, 0, // third column
-    -barycenter.x, -barycenter.y, -barycenter.z, 1); // fourth column
+    -center.x, -center.y, -center.z, 1); // fourth column
     mat4 scaling = mat4(shrink_factor, 0, 0, 0,
     0, shrink_factor, 0, 0,
     0, 0, shrink_factor, 0,
diff --git a/Three/include/CGAL/Three/Edge_container.h b/Three/include/CGAL/Three/Edge_container.h
index b59e51f577d..5c7bc6c391d 100644
--- a/Three/include/CGAL/Three/Edge_container.h
+++ b/Three/include/CGAL/Three/Edge_container.h
@@ -55,7 +55,7 @@ struct DEMO_FRAMEWORK_EXPORT Edge_container :public Primitive_container
     Normals,      //!< Designates the buffer that contains the normal coordinates.
     Colors,       //!< Designates the buffer that contains the color components.
     Radius,       //!< Designates the buffer that contains the radius of wire spheres.
-    Barycenters,  //!< Designates the buffer that contains the barycenter of c3t3 facets or the center of wire spheres, for example.
+    Centers,  //!< Designates the buffer that contains the center of c3t3 facets or the center of wire spheres, for example.
     NbOfVbos      //!< Designates the size of the VBOs vector for `Edge_container`s
   };
 
@@ -97,11 +97,21 @@ struct DEMO_FRAMEWORK_EXPORT Edge_container :public Primitive_container
   QVector4D getPlane()const;
   //! getter for the "f_matrix" parameter
   QMatrix4x4 getFrameMatrix()const;
+  //! getter for the "viewport" parameter
+  QVector2D getViewport()const;
+  //! getter for the "width" parameter
+  GLfloat getWidth()const;
 
   //! setter for the "plane" parameter
   void setPlane(const QVector4D&);
   //! setter for the "f_matrix" parameter
   void setFrameMatrix(const QMatrix4x4&);
+  //! setter for the "viewport" parameter
+  void setViewport(const QVector2D&);
+  //! setter for the "width" parameter
+  void setWidth(const GLfloat&);
+  //! setter for the "is_surface" attribute. Used in PROGRAM_C3T3_EDGES
+  void setIsSurface  (const bool);
   ///@}
 
 private:
diff --git a/Three/include/CGAL/Three/Point_container.h b/Three/include/CGAL/Three/Point_container.h
index 34c141baf02..8efc9eb5998 100755
--- a/Three/include/CGAL/Three/Point_container.h
+++ b/Three/include/CGAL/Three/Point_container.h
@@ -95,6 +95,10 @@ struct DEMO_FRAMEWORK_EXPORT Point_container :public Primitive_container
   QMatrix4x4 getFrameMatrix()const;
 //! setter for the "f_matrix" parameter
   void setFrameMatrix(const QMatrix4x4&);
+  //! setter for the "plane" parameter
+  void setPlane(const QVector4D&);
+  //! setter for the "is_surface" attribute. Used in PROGRAM_C3T3_EDGES
+  void setIsSurface  (const bool);
   ///@}
 
 private:
diff --git a/Three/include/CGAL/Three/Primitive_container.h b/Three/include/CGAL/Three/Primitive_container.h
index 61a5e79970a..fefa1f75c5b 100755
--- a/Three/include/CGAL/Three/Primitive_container.h
+++ b/Three/include/CGAL/Three/Primitive_container.h
@@ -150,6 +150,8 @@ public:
   void setStride(std::size_t id, int stride);
   //!Setter for the "offset" parameter.
   void setOffset(std::size_t id, int offset);
+  //!setter for the tuple size: the number of coordinates of one vertex.
+  void setTupleSize(int ts);
   //!@}
 
   //!
@@ -202,9 +204,13 @@ public:
   //! \brief getIdxSize returns the number of indexed
   //! vertices.
   std::size_t getIdxSize()const;
+  //! \brief getTupleSize returns the number of coordinates in one vertex.
+  //! Default is 3.
+  int getTupleSize()const;
   //! \brief getCenterSize returns the number of instances of
   //! the item in this container.
   std::size_t getCenterSize()const;
+  
   //! \name Getters for the shaders parameters.
   //!@{
   
diff --git a/Three/include/CGAL/Three/Scene_group_item.h b/Three/include/CGAL/Three/Scene_group_item.h
index a69fdfbfbc6..bd61e3fc01b 100644
--- a/Three/include/CGAL/Three/Scene_group_item.h
+++ b/Three/include/CGAL/Three/Scene_group_item.h
@@ -26,7 +26,7 @@
 #include <CGAL/license/Three.h>
 
 
-#include <CGAL/Three/Scene_item.h>
+#include <CGAL/Three/Scene_item_rendering_helper.h>
 #include <CGAL/Three/Scene_interface.h>
 using namespace CGAL::Three;
 
@@ -43,14 +43,12 @@ namespace Three {
 //! user to apply several actions to multiple items at the same time.
 //! A custom Scene_item can derive from it to have children. They appear
 //! hierarchically in the Geometric Objects list.
-class DEMO_FRAMEWORK_EXPORT Scene_group_item : public Scene_item
+class DEMO_FRAMEWORK_EXPORT Scene_group_item : public Scene_item_rendering_helper
 {
     Q_OBJECT
 public :
-    Scene_group_item(QString name = QString("New group"), int nb_vbos = 0, int nb_vaos = 0);
+    Scene_group_item(QString name = QString("New group"));
     ~Scene_group_item() {}
-    //!Sets the scene;
-    void setScene(Scene_interface* s) { scene = s; }
     //!Returns false to avoid disturbing the BBox of the scene.
     bool isFinite() const Q_DECL_OVERRIDE;
     //!Returns true to avoid disturbing the BBox of the scene.
@@ -237,8 +235,8 @@ public :
     void moveUp(int);
     //!Moves a child down in the list.
     void moveDown(int);
-    void removeViewer(CGAL::Three::Viewer_interface* )Q_DECL_OVERRIDE;
-    void newViewer(CGAL::Three::Viewer_interface* )Q_DECL_OVERRIDE{};
+    
+    void compute_bbox() const Q_DECL_OVERRIDE{};
 public Q_SLOTS:
     //!\brief Redraws children.
     //!
diff --git a/Three/include/CGAL/Three/Triangle_container.h b/Three/include/CGAL/Three/Triangle_container.h
index cdb0c091114..e6da1d57b26 100644
--- a/Three/include/CGAL/Three/Triangle_container.h
+++ b/Three/include/CGAL/Three/Triangle_container.h
@@ -52,7 +52,7 @@ struct DEMO_FRAMEWORK_EXPORT Triangle_container :public Primitive_container
     Vertex_indices,     //!< Designates the buffer that contains the indices for the smooth vertices.
     Flat_normals,       //!< Designates the buffer that contains the normals for the flat vertices.
     Smooth_normals,     //!< Designates the buffer that contains the normals for the smooth vertices.
-    Facet_barycenters,  //!< Designates the buffer that contains the barycenters of the c3t3 facets or the center of the spheres.
+    Facet_centers,  //!< Designates the buffer that contains the barycenters of the c3t3 facets or the center of the spheres.
     Radius,             //!< Designates the buffer that contains the radius of the spheres.
     VColors,            //!< Designates the buffer that contains the colors of the smooth vertices.
     FColors,            //!< Designates the buffer that contains the colors of the flat vertices.
@@ -105,6 +105,8 @@ struct DEMO_FRAMEWORK_EXPORT Triangle_container :public Primitive_container
   void setAlpha       (const float&);
   //! setter for the "f_matrix" parameter
   void setFrameMatrix(const QMatrix4x4&);
+  //! setter for the "is_surface" attribute. Used in PROGRAM_C3T3
+  void setIsSurface  (const bool);
   ///@}
 
   //drawing variables