diff --git a/ewol/compositing/Area.cpp b/ewol/compositing/Area.cpp
index 2f0778fc..731dd64a 100644
--- a/ewol/compositing/Area.cpp
+++ b/ewol/compositing/Area.cpp
@@ -8,9 +8,10 @@
 #include <ewol/compositing/Area.hpp>
 
 // VBO table property:
-#define EWOL_COMPOSITING_VBO_COORDINATE (0)
-#define EWOL_COMPOSITING_VBO_COLOR      (1)
-#define EWOL_COMPOSITING_VBO_TEXTURE    (2)
+const int32_t ewol::compositing::Area::m_vboIdCoord(0);
+const int32_t ewol::compositing::Area::m_vboIdCoordText(1);
+const int32_t ewol::compositing::Area::m_vboIdColor(2);
+#define NB_VBO (3)
 
 ewol::compositing::Area::Area(const ivec2& _size) :
   m_position(0.0, 0.0, 0.0),
@@ -26,7 +27,7 @@ ewol::compositing::Area::Area(const ivec2& _size) :
 	m_resource->setImageSize(_size);
 	m_resource->flush();
 	// Create the VBO:
-	m_VBO = gale::resource::VirtualBufferObject::create(3);
+	m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
 	if (m_VBO == nullptr) {
 		EWOL_ERROR("can not instanciate VBO ...");
 		return;
@@ -54,7 +55,7 @@ void ewol::compositing::Area::loadProgram() {
 }
 
 void ewol::compositing::Area::draw(bool _disableDepthTest) {
-	if (m_VBO->bufferSize(EWOL_COMPOSITING_VBO_COORDINATE) <= 0) {
+	if (m_VBO->bufferSize(m_vboIdCoord) <= 0) {
 		//EWOL_WARNING("Nothink to draw...");
 		return;
 	}
@@ -73,13 +74,13 @@ void ewol::compositing::Area::draw(bool _disableDepthTest) {
 	// TextureID
 	m_GLprogram->setTexture0(m_GLtexID, m_resource->getRendererId());
 	// position:
-	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_COMPOSITING_VBO_COORDINATE);
+	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
 	// Texture:
-	m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, EWOL_COMPOSITING_VBO_COLOR);
+	m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdColor);
 	// color:
-	m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, EWOL_COMPOSITING_VBO_TEXTURE);
+	m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdCoordText);
 	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(EWOL_COMPOSITING_VBO_COORDINATE));
+	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
 	m_GLprogram->unUse();
 }
 
@@ -97,41 +98,41 @@ void ewol::compositing::Area::print(const ivec2& _size) {
 	vec2 tex(0,1);
 	point.setX(m_position.x());
 	point.setY(m_position.y());
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
 	
 	tex.setValue(1,1);
 	point.setX(m_position.x() + _size.x());
 	point.setY(m_position.y());
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
 	
 	tex.setValue(1,0);
 	point.setX(m_position.x() + _size.x());
 	point.setY(m_position.y() + _size.y());
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
 	
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
 	
 	tex.setValue(0,0);
 	point.setX(m_position.x());
 	point.setY(m_position.y() + _size.y());
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
 	
 	tex.setValue(0,1);
 	point.setX(m_position.x());
 	point.setY(m_position.y());
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
 	
 	m_VBO->flush();
 }
diff --git a/ewol/compositing/Area.hpp b/ewol/compositing/Area.hpp
index dd054083..9b725e3b 100644
--- a/ewol/compositing/Area.hpp
+++ b/ewol/compositing/Area.hpp
@@ -28,6 +28,10 @@ namespace ewol {
 				int32_t m_GLtexID;    //!< openGL id on the element (texture ID)
 			private:
 				ememory::SharedPtr<ewol::resource::Texture> m_resource; //!< texture resources
+			protected:
+				static const int32_t m_vboIdCoord;
+				static const int32_t m_vboIdCoordText;
+				static const int32_t m_vboIdColor;
 				ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
 			private:
 				/**
diff --git a/ewol/compositing/Drawing.cpp b/ewol/compositing/Drawing.cpp
index 4a7c61bc..1f3f1ce2 100644
--- a/ewol/compositing/Drawing.cpp
+++ b/ewol/compositing/Drawing.cpp
@@ -7,6 +7,10 @@
 #include <ewol/debug.hpp>
 #include <ewol/compositing/Drawing.hpp>
 
+// VBO table property:
+const int32_t ewol::compositing::Drawing::m_vboIdCoord(0);
+const int32_t ewol::compositing::Drawing::m_vboIdColor(1);
+#define NB_VBO (2)
 
 #if 0
 
@@ -234,6 +238,14 @@ ewol::compositing::Drawing::Drawing() :
 		m_triangle[iii] = m_position;
 		m_tricolor[iii] = m_color;
 	}
+	// Create the VBO:
+	m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
+	if (m_VBO == nullptr) {
+		EWOL_ERROR("can not instanciate VBO ...");
+		return;
+	}
+	// TO facilitate some debugs we add a name of the VBO:
+	m_VBO->setName("[VBO] of ewol::compositing::Area");
 }
 
 ewol::compositing::Drawing::~Drawing() {
@@ -243,12 +255,12 @@ ewol::compositing::Drawing::~Drawing() {
 void ewol::compositing::Drawing::generateTriangle() {
 	m_triElement = 0;
 	
-	m_coord.push_back(m_triangle[0]);
-	m_coordColor.push_back(m_tricolor[0]);
-	m_coord.push_back(m_triangle[1]);
-	m_coordColor.push_back(m_tricolor[1]);
-	m_coord.push_back(m_triangle[2]);
-	m_coordColor.push_back(m_tricolor[2]);
+	m_VBO->pushOnBuffer(m_vboIdCoord, m_triangle[0]);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_tricolor[0]);
+	m_VBO->pushOnBuffer(m_vboIdCoord, m_triangle[1]);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_tricolor[1]);
+	m_VBO->pushOnBuffer(m_vboIdCoord, m_triangle[2]);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_tricolor[2]);
 }
 
 void ewol::compositing::Drawing::internalSetColor(const etk::Color<>& _color) {
@@ -269,6 +281,7 @@ void ewol::compositing::Drawing::setPoint(const vec3& _point) {
 	if (m_triElement >= 3) {
 		generateTriangle();
 	}
+	m_VBO->flush();
 }
 
 void ewol::compositing::Drawing::resetCount() {
@@ -294,8 +307,8 @@ void ewol::compositing::Drawing::loadProgram() {
 }
 
 void ewol::compositing::Drawing::draw(bool _disableDepthTest) {
-	if (m_coord.size() <= 0) {
-		// TODO : a remÚtre ...
+	if (m_VBO->bufferSize(m_vboIdCoord) <= 0) {
+		// TODO : set it back ...
 		//EWOL_WARNING("Nothink to draw...");
 		return;
 	}
@@ -309,12 +322,12 @@ void ewol::compositing::Drawing::draw(bool _disableDepthTest) {
 	m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
 	mat4 tmpMatrix2;
 	m_GLprogram->uniformMatrix(m_GLMatrixPosition, tmpMatrix2);
-	// position :
-	m_GLprogram->sendAttribute(m_GLPosition, m_coord);
-	// color :
-	m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
+	// position:
+	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
+	// color:
+	m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
 	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
+	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
 	m_GLprogram->unUse();
 }
 
@@ -322,8 +335,7 @@ void ewol::compositing::Drawing::clear() {
 	// call upper class
 	ewol::Compositing::clear();
 	// reset Buffer :
-	m_coord.clear();
-	m_coordColor.clear();
+	m_VBO->clear();
 	// reset temporal variables :
 	m_position = vec3(0.0, 0.0, 0.0);
 	
diff --git a/ewol/compositing/Drawing.hpp b/ewol/compositing/Drawing.hpp
index 25c5312f..14e3e6e5 100644
--- a/ewol/compositing/Drawing.hpp
+++ b/ewol/compositing/Drawing.hpp
@@ -29,9 +29,10 @@ namespace ewol {
 				int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix)
 				int32_t m_GLMatrixPosition; //!< position matrix
 				int32_t m_GLColor; //!< openGL id on the element (color buffer)
-			public: // Background Color (display only when needed)
-				std::vector<vec3 > m_coord; //!< internal position for the text display
-				std::vector<etk::Color<float> > m_coordColor; //!< internal color of the background
+			protected:
+				static const int32_t m_vboIdCoord;
+				static const int32_t m_vboIdColor;
+				ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
 			public:
 				/**
 				 * @brief Basic constructor
@@ -53,7 +54,7 @@ namespace ewol {
 				float m_thickness; //!< when drawing line and other things
 				int32_t m_triElement; //!< special counter of the single dot generated
 				vec3 m_triangle[3]; //!< Register every system with a combinaison of tiangle
-				etk::Color<float> m_tricolor[3]; //!< Register every the associated color foreground
+				etk::Color<float,4> m_tricolor[3]; //!< Register every the associated color foreground
 			// internal API for the generation abstraction of triangles
 				/**
 				 * @brief Lunch the generation of triangle
diff --git a/ewol/compositing/Image.cpp b/ewol/compositing/Image.cpp
index f9a24e55..53b30005 100644
--- a/ewol/compositing/Image.cpp
+++ b/ewol/compositing/Image.cpp
@@ -9,6 +9,12 @@
 
 const int32_t ewol::compositing::Image::sizeAuto(0);
 
+// VBO table property:
+const int32_t ewol::compositing::Image::m_vboIdCoord(0);
+const int32_t ewol::compositing::Image::m_vboIdCoordTex(1);
+const int32_t ewol::compositing::Image::m_vboIdColor(2);
+#define NB_VBO (3)
+
 ewol::compositing::Image::Image(const std::string& _imageName,
                                 bool _df,
                                 int32_t _size) :
@@ -29,6 +35,14 @@ ewol::compositing::Image::Image(const std::string& _imageName,
   m_distanceFieldMode(_df),
   m_resource(nullptr),
   m_resourceDF(nullptr) {
+	// Create the VBO:
+	m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
+	if (m_VBO == nullptr) {
+		EWOL_ERROR("can not instanciate VBO ...");
+		return;
+	}
+	// TO facilitate some debugs we add a name of the VBO:
+	m_VBO->setName("[VBO] of ewol::compositing::Image");
 	setSource(_imageName, _size);
 	loadProgram();
 }
@@ -56,7 +70,7 @@ void ewol::compositing::Image::loadProgram() {
 }
 
 void ewol::compositing::Image::draw(bool _disableDepthTest) {
-	if (m_coord.size() <= 0) {
+	if (m_VBO->bufferSize(m_vboIdCoord) <= 0) {
 		//EWOL_WARNING("Nothink to draw...");
 		return;
 	}
@@ -69,6 +83,7 @@ void ewol::compositing::Image::draw(bool _disableDepthTest) {
 		EWOL_ERROR("No shader ...");
 		return;
 	}
+	//EWOL_WARNING("Display image : " << m_VBO->bufferSize(m_vboIdCoord));
 	if (_disableDepthTest == true) {
 		gale::openGL::disable(gale::openGL::flag_depthTest);
 	} else {
@@ -76,7 +91,7 @@ void ewol::compositing::Image::draw(bool _disableDepthTest) {
 	}
 	// set Matrix : translation/positionMatrix
 	mat4 tmpMatrix = gale::openGL::getMatrix()*m_matrixApply;
-	m_GLprogram->use(); 
+	m_GLprogram->use();
 	m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
 	// TextureID
 	if (m_resource != nullptr) {
@@ -90,14 +105,14 @@ void ewol::compositing::Image::draw(bool _disableDepthTest) {
 		}
 		m_GLprogram->setTexture0(m_GLtexID, m_resourceDF->getRendererId());
 	}
-	// position :
-	m_GLprogram->sendAttribute(m_GLPosition, m_coord);
-	// Texture :
-	m_GLprogram->sendAttribute(m_GLtexture, m_coordTex);
-	// color :
-	m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
-	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
+	// position:
+	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
+	// Texture:
+	m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordTex);
+	// color:
+	m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
+	// Request the draw of the elements:
+	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
 	m_GLprogram->unUse();
 }
 
@@ -105,9 +120,7 @@ void ewol::compositing::Image::clear() {
 	// call upper class
 	ewol::Compositing::clear();
 	// reset Buffer :
-	m_coord.clear();
-	m_coordTex.clear();
-	m_coordColor.clear();
+	m_VBO->clear();
 	// reset temporal variables :
 	m_position = vec3(0.0, 0.0, 0.0);
 	m_clippingPosStart = vec3(0.0, 0.0, 0.0);
@@ -154,47 +167,46 @@ void ewol::compositing::Image::print(const vec2& _size) {
 void ewol::compositing::Image::printPart(const vec2& _size,
                                          const vec2& _sourcePosStart,
                                          const vec2& _sourcePosStop) {
+	//EWOL_ERROR("Debug image " << m_filename << "  ==> " << m_position << " " << _size << " " << _sourcePosStart << " " << _sourcePosStop);
 	if (m_angle == 0.0f) {
 		vec3 point = m_position;
 		vec2 tex(_sourcePosStart.x(),_sourcePosStop.y());
-		
-		m_coord.push_back(point);
-		m_coordTex.push_back(tex);
-		m_coordColor.push_back(m_color);
-		
+		m_VBO->pushOnBuffer(m_vboIdCoord, point);
+		m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+		m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 		
 		tex.setValue(_sourcePosStop.x(),_sourcePosStop.y());
 		point.setX(m_position.x() + _size.x());
 		point.setY(m_position.y());
-		m_coord.push_back(point);
-		m_coordTex.push_back(tex);
-		m_coordColor.push_back(m_color);
-		
+		m_VBO->pushOnBuffer(m_vboIdCoord, point);
+		m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+		m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 		
 		tex.setValue(_sourcePosStop.x(),_sourcePosStart.y());
 		point.setX(m_position.x() + _size.x());
 		point.setY(m_position.y() + _size.y());
-		m_coord.push_back(point);
-		m_coordTex.push_back(tex);
-		m_coordColor.push_back(m_color);
+		m_VBO->pushOnBuffer(m_vboIdCoord, point);
+		m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+		m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 		
-		m_coord.push_back(point);
-		m_coordTex.push_back(tex);
-		m_coordColor.push_back(m_color);
+		m_VBO->pushOnBuffer(m_vboIdCoord, point);
+		m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+		m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 		
 		tex.setValue(_sourcePosStart.x(),_sourcePosStart.y());
 		point.setX(m_position.x());
 		point.setY(m_position.y() + _size.y());
-		m_coord.push_back(point);
-		m_coordTex.push_back(tex);
-		m_coordColor.push_back(m_color);
+		m_VBO->pushOnBuffer(m_vboIdCoord, point);
+		m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+		m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 		
 		tex.setValue(_sourcePosStart.x(),_sourcePosStop.y());
 		point.setX(m_position.x());
 		point.setY(m_position.y());
-		m_coord.push_back(point);
-		m_coordTex.push_back(tex);
-		m_coordColor.push_back(m_color);
+		m_VBO->pushOnBuffer(m_vboIdCoord, point);
+		m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+		m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+		m_VBO->flush();
 		return;
 	}
 	vec3 center = m_position + vec3(_size.x(),_size.y(),0)/2.0f;
@@ -205,43 +217,43 @@ void ewol::compositing::Image::printPart(const vec2& _size,
 	
 	point.setValue(-limitedSize.x(), -limitedSize.y(), 0);
 	point = point.rotate(vec3(0,0,1), m_angle) + center;
-	m_coord.push_back(point);
-	m_coordTex.push_back(tex);
-	m_coordColor.push_back(m_color);
-	
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 	
 	tex.setValue(_sourcePosStop.x(),_sourcePosStop.y());
 	point.setValue(limitedSize.x(), -limitedSize.y(), 0);
 	point = point.rotate(vec3(0,0,1), m_angle) + center;
-	m_coord.push_back(point);
-	m_coordTex.push_back(tex);
-	m_coordColor.push_back(m_color);
-	
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 	
 	tex.setValue(_sourcePosStop.x(),_sourcePosStart.y());
 	point.setValue(limitedSize.x(), limitedSize.y(), 0);
 	point = point.rotate(vec3(0,0,1), m_angle) + center;
-	m_coord.push_back(point);
-	m_coordTex.push_back(tex);
-	m_coordColor.push_back(m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 	
-	m_coord.push_back(point);
-	m_coordTex.push_back(tex);
-	m_coordColor.push_back(m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 	
 	tex.setValue(_sourcePosStart.x(),_sourcePosStart.y());
 	point.setValue(-limitedSize.x(), limitedSize.y(), 0);
 	point = point.rotate(vec3(0,0,1), m_angle) + center;
-	m_coord.push_back(point);
-	m_coordTex.push_back(tex);
-	m_coordColor.push_back(m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 	
 	tex.setValue(_sourcePosStart.x(),_sourcePosStop.y());
 	point.setValue(-limitedSize.x(), -limitedSize.y(), 0);
 	point = point.rotate(vec3(0,0,1), m_angle) + center;
-	m_coord.push_back(point);
-	m_coordTex.push_back(tex);
-	m_coordColor.push_back(m_color);
+	m_VBO->pushOnBuffer(m_vboIdCoord, point);
+	m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
+	m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+	
+	m_VBO->flush();
 }
 
 void ewol::compositing::Image::setSource(const std::string& _newFile, const vec2& _size) {
diff --git a/ewol/compositing/Image.hpp b/ewol/compositing/Image.hpp
index b379ff79..d9e2eda2 100644
--- a/ewol/compositing/Image.hpp
+++ b/ewol/compositing/Image.hpp
@@ -24,7 +24,7 @@ namespace ewol {
 				vec3 m_clippingPosStop; //!< Clipping stop position
 				bool m_clippingEnable; //!< true if the clipping must be activated
 			private:
-				etk::Color<> m_color; //!< The text foreground color
+				etk::Color<float,4> m_color; //!< The text foreground color
 				float m_angle; //!< Angle to set at the axes
 			private:
 				ememory::SharedPtr<gale::resource::Program> m_GLprogram; //!< pointer on the opengl display program
@@ -37,9 +37,10 @@ namespace ewol {
 				bool m_distanceFieldMode; //!< select distance field mode
 				ememory::SharedPtr<ewol::resource::TextureFile> m_resource; //!< texture resources
 				ememory::SharedPtr<ewol::resource::ImageDF> m_resourceDF; //!< texture resources
-				std::vector<vec3 > m_coord; //!< internal coord of the object
-				std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
-				std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point
+				static const int32_t m_vboIdCoord;
+				static const int32_t m_vboIdCoordTex;
+				static const int32_t m_vboIdColor;
+				ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
 			private:
 				/**
 				 * @brief load the openGL program and get all the ID needed
diff --git a/ewol/compositing/Shaper.cpp b/ewol/compositing/Shaper.cpp
index 8830fd85..9560dc2e 100644
--- a/ewol/compositing/Shaper.cpp
+++ b/ewol/compositing/Shaper.cpp
@@ -9,8 +9,9 @@
 #include <ewol/compositing/Shaper.hpp>
 
 // VBO table property:
-#define EWOL_COMPOSITING_SHAPER_VBO_COORDINATE (0)
-#define EWOL_COMPOSITING_SHAPER_VBO_POS        (1)
+const int32_t ewol::compositing::Shaper::m_vboIdCoord(0);
+const int32_t ewol::compositing::Shaper::m_vboIdPos(1);
+#define NB_VBO (2)
 
 ewol::compositing::Shaper::Shaper(const std::string& _shaperName) :
   m_name(_shaperName),
@@ -45,7 +46,7 @@ ewol::compositing::Shaper::Shaper(const std::string& _shaperName) :
 		m_confIdPaddingIn[iii] = -1;
 	}
 	// Create the VBO:
-	m_VBO = gale::resource::VirtualBufferObject::create(3);
+	m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
 	if (m_VBO == nullptr) {
 		EWOL_ERROR("can not instanciate VBO ...");
 		return;
@@ -180,7 +181,7 @@ void ewol::compositing::Shaper::draw(bool _disableDepthTest) {
 		EWOL_ERROR("No shader ...");
 		return;
 	}
-	if (m_VBO->bufferSize(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE) <= 0) {
+	if (m_VBO->bufferSize(m_vboIdCoord) <= 0) {
 		return;
 	}
 	//glScalef(m_scaling.x, m_scaling.y, 1.0);
@@ -189,9 +190,9 @@ void ewol::compositing::Shaper::draw(bool _disableDepthTest) {
 	mat4 tmpMatrix = gale::openGL::getMatrix();
 	m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
 	// position:
-	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_COMPOSITING_SHAPER_VBO_COORDINATE);
+	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
 	// property
-	m_GLprogram->sendAttributePointer(m_GLPropertyPos, m_VBO, EWOL_COMPOSITING_SHAPER_VBO_POS);
+	m_GLprogram->sendAttributePointer(m_GLPropertyPos, m_VBO, m_vboIdPos);
 	// all entry parameters :
 	m_GLprogram->uniform1i(m_GLStateActivate,   m_stateActivate);
 	m_GLprogram->uniform1i(m_GLStateOld,        m_stateOld);
@@ -297,104 +298,104 @@ void ewol::compositing::Shaper::addVertexLine(float _yTop,
                                               bool _displayOutside) {
 	if (m_nbVertexToDisplay != 0) {
 		// change line ...
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE,
-		                    m_VBO->getOnBufferVec2(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, m_nbVertexToDisplay-1));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,
-		                    m_VBO->getOnBufferVec2(EWOL_COMPOSITING_SHAPER_VBO_POS, m_nbVertexToDisplay-1));
+		m_VBO->pushOnBuffer(m_vboIdCoord,
+		                    m_VBO->getOnBufferVec2(m_vboIdCoord, m_nbVertexToDisplay-1));
+		m_VBO->pushOnBuffer(m_vboIdPos,
+		                    m_VBO->getOnBufferVec2(m_vboIdPos, m_nbVertexToDisplay-1));
 		
 		m_nbVertexToDisplay++;
 		if (_displayOutside == true) {
-			m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yButtom));
-			m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[0],_yValButtom));
+			m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x1, _yButtom));
+			m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[0],_yValButtom));
 			m_nbVertexToDisplay++;
 		} else {
-			m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
-			m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[1],_yValButtom));
+			m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yButtom));
+			m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[1],_yValButtom));
 			m_nbVertexToDisplay++;
 		}
 	}
 	
 	if (_displayOutside == true) {
 		// A
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yButtom));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[0],_yValButtom));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x1, _yButtom));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[0],_yValButtom));
 		m_nbVertexToDisplay++;
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yTop));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[0],_yValTop));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x1, _yTop));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[0],_yValTop));
 		m_nbVertexToDisplay++;
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[1],_yValButtom));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yButtom));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[1],_yValButtom));
 		m_nbVertexToDisplay++;
 		// B
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yTop));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[1],_yValTop));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yTop));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[1],_yValTop));
 		m_nbVertexToDisplay++;
 		
 		// C
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yButtom));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[2],_yValButtom));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x3, _yButtom));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[2],_yValButtom));
 		m_nbVertexToDisplay++;
 	} else {
 		// C
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[1],_yValButtom));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yButtom));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[1],_yValButtom));
 		m_nbVertexToDisplay++;
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yTop));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[1],_yValTop));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yTop));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[1],_yValTop));
 		m_nbVertexToDisplay++;
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yButtom));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[2],_yValButtom));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x3, _yButtom));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[2],_yValButtom));
 		m_nbVertexToDisplay++;
 	}
 	// D
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yTop));
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[2],_yValTop));
+	m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x3, _yTop));
+	m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[2],_yValTop));
 	m_nbVertexToDisplay++;
 	
 	// E
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x4, _yButtom));
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[3],_yValButtom));
+	m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x4, _yButtom));
+	m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[3],_yValButtom));
 	m_nbVertexToDisplay++;
 	// F
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x4, _yTop));
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[3],_yValTop));
+	m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x4, _yTop));
+	m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[3],_yValTop));
 	m_nbVertexToDisplay++;
 	
 	// G
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x5, _yButtom));
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[4],_yValButtom));
+	m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x5, _yButtom));
+	m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[4],_yValButtom));
 	m_nbVertexToDisplay++;
 	// H
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x5, _yTop));
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[4],_yValTop));
+	m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x5, _yTop));
+	m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[4],_yValTop));
 	m_nbVertexToDisplay++;
 	
 	// I
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x6, _yButtom));
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[5],_yValButtom));
+	m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x6, _yButtom));
+	m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[5],_yValButtom));
 	m_nbVertexToDisplay++;
 	// J
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x6, _yTop));
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[5],_yValTop));
+	m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x6, _yTop));
+	m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[5],_yValTop));
 	m_nbVertexToDisplay++;
 	
 	// K
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x7, _yButtom));
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[6],_yValButtom));
+	m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x7, _yButtom));
+	m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[6],_yValButtom));
 	m_nbVertexToDisplay++;
 	// L
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x7, _yTop));
-	m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[6],_yValTop));
+	m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x7, _yTop));
+	m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[6],_yValTop));
 	m_nbVertexToDisplay++;
 	
 	if (_displayOutside == true) {
 		// M
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x8, _yButtom));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[7],_yValButtom));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x8, _yButtom));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[7],_yValButtom));
 		m_nbVertexToDisplay++;
 		// N
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x8, _yTop));
-		m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,        vec2(_table[7],_yValTop));
+		m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x8, _yTop));
+		m_VBO->pushOnBuffer(m_vboIdPos,        vec2(_table[7],_yValTop));
 		m_nbVertexToDisplay++;
 	}
 }
@@ -446,6 +447,7 @@ const float modeDisplay[][8] = {
 };
 
 void ewol::compositing::Shaper::setShape(const vec2& _origin, const vec2& _size, const vec2& _insidePos, const vec2& _insideSize) {
+	m_VBO->clear();
 	ewol::Padding borderTmp = getBorder();
 	ewol::Padding paddingIn = getPaddingIn();
 	ewol::Padding paddingOut = getPaddingOut();
diff --git a/ewol/compositing/Shaper.hpp b/ewol/compositing/Shaper.hpp
index 99ca07ae..b76b04fc 100644
--- a/ewol/compositing/Shaper.hpp
+++ b/ewol/compositing/Shaper.hpp
@@ -76,6 +76,9 @@ namespace ewol {
 				// color management theme:
 				ememory::SharedPtr<ewol::resource::ColorFile> m_colorProperty; //!< input resource for color management
 				std::vector<ivec2> m_listAssiciatedId; //!< Corellation ID between ColorProperty (Y) and OpenGL Program (X)
+			protected:
+				static const int32_t m_vboIdCoord;
+				static const int32_t m_vboIdPos;
 				ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
 			private:
 				/**
diff --git a/ewol/compositing/Text.cpp b/ewol/compositing/Text.cpp
index d7ce7c2d..9d163dd8 100644
--- a/ewol/compositing/Text.cpp
+++ b/ewol/compositing/Text.cpp
@@ -23,8 +23,9 @@ void ewol::compositing::Text::drawMT(const mat4& _transformationMatrix, bool _en
 	// draw BG in any case:
 	m_vectorialDraw.draw();
 	
-	if (m_coord.size() <= 0 || m_font == nullptr) {
-		// TODO : a remÃtre ...
+	if (    m_VBO->bufferSize(m_vboIdCoord) <= 0
+	     || m_font == nullptr) {
+		// TODO : set it back ...
 		//EWOL_WARNING("Nothink to draw...");
 		return;
 	}
@@ -45,18 +46,18 @@ void ewol::compositing::Text::drawMT(const mat4& _transformationMatrix, bool _en
 	mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
 	m_GLprogram->use(); 
 	m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
-	// Texture :
+	// Texture:
 	m_GLprogram->setTexture0(m_GLtexID, m_font->getRendererId());
 	m_GLprogram->uniform1i(m_GLtextWidth, m_font->getOpenGlSize().x());
 	m_GLprogram->uniform1i(m_GLtextHeight, m_font->getOpenGlSize().x());
-	// position :
-	m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z*/, &m_coord[0]);
-	// Texture :
-	m_GLprogram->sendAttribute(m_GLtexture, 2/*u,v*/, &m_coordTex[0]);
-	// color :
-	m_GLprogram->sendAttribute(m_GLColor, 4/*r,g,b,a*/, &m_coordColor[0]);
-	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
+	// position:
+	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
+	// Texture:
+	m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordText);
+	// color:
+	m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
+	// Request the draw od the elements:
+	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
 	m_GLprogram->unUse();
 	if (_enableDepthTest == true) {
 		gale::openGL::disable(gale::openGL::flag_depthTest);
@@ -67,7 +68,8 @@ void ewol::compositing::Text::drawD(bool _disableDepthTest) {
 	// draw BG in any case:
 	m_vectorialDraw.draw(_disableDepthTest);
 	
-	if (m_coord.size() <= 0 || m_font == nullptr) {
+	if (    m_VBO->bufferSize(m_vboIdCoord) <= 0
+	     || m_font == nullptr) {
 		//EWOL_WARNING("Nothink to draw...");
 		return;
 	}
@@ -87,14 +89,14 @@ void ewol::compositing::Text::drawD(bool _disableDepthTest) {
 	m_GLprogram->setTexture0(m_GLtexID, m_font->getRendererId());
 	m_GLprogram->uniform1i(m_GLtextWidth, m_font->getOpenGlSize().x());
 	m_GLprogram->uniform1i(m_GLtextHeight, m_font->getOpenGlSize().x());
-	// position :
-	m_GLprogram->sendAttribute(m_GLPosition, m_coord);
-	// Texture :
-	m_GLprogram->sendAttribute(m_GLtexture, m_coordTex);
-	// color :
-	m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
+	// position:
+	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
+	// Texture:
+	m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordText);
+	// color:
+	m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
 	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
+	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
 	m_GLprogram->unUse();
 }
 
@@ -180,7 +182,7 @@ void ewol::compositing::Text::printChar(const char32_t& _charcode) {
 	
 	// get the kerning ofset :
 	float kerningOffset = 0;
-	if (true == m_kerning) {
+	if (m_kerning == true) {
 		kerningOffset = myGlyph->kerningGet(m_previousCharcode);
 		if (kerningOffset != 0) {
 			//EWOL_DEBUG("Kerning between : '" << m_previousCharcode << "'&'" << myGlyph->m_UVal << "' value : " << kerningOffset);
@@ -292,17 +294,17 @@ void ewol::compositing::Text::printChar(const char32_t& _charcode) {
 					 *                
 					 */
 					// set texture coordonates :
-					m_coordTex.push_back(texturePos[0]);
-					m_coordTex.push_back(texturePos[1]);
-					m_coordTex.push_back(texturePos[2]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[0]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[1]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[2]);
 					// set display positions :
-					m_coord.push_back(bitmapDrawPos[0]);
-					m_coord.push_back(bitmapDrawPos[1]);
-					m_coord.push_back(bitmapDrawPos[2]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[0]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[1]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[2]);
 					// set the color
-					m_coordColor.push_back(m_color);
-					m_coordColor.push_back(m_color);
-					m_coordColor.push_back(m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 					/* Step 2 : 
 					 *              
 					 *   **         
@@ -311,17 +313,17 @@ void ewol::compositing::Text::printChar(const char32_t& _charcode) {
 					 *   ********   
 					 */
 					// set texture coordonates :
-					m_coordTex.push_back(texturePos[0]);
-					m_coordTex.push_back(texturePos[2]);
-					m_coordTex.push_back(texturePos[3]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[0]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[2]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[3]);
 					// set display positions :
-					m_coord.push_back(bitmapDrawPos[0]);
-					m_coord.push_back(bitmapDrawPos[2]);
-					m_coord.push_back(bitmapDrawPos[3]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[0]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[2]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[3]);
 					// set the color
-					m_coordColor.push_back(m_color);
-					m_coordColor.push_back(m_color);
-					m_coordColor.push_back(m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
 				}
 			}
 		}
@@ -332,6 +334,7 @@ void ewol::compositing::Text::printChar(const char32_t& _charcode) {
 	//EWOL_DEBUG(" 6 print '" << charcode << "' : start=" << m_sizeDisplayStart << " stop=" << m_sizeDisplayStop << " pos=" << m_position);
 	// Register the previous character
 	m_previousCharcode = _charcode;
+	m_VBO->flush();
 	return;
 }
 
diff --git a/ewol/compositing/TextBase.cpp b/ewol/compositing/TextBase.cpp
index 3d0d48ca..3f175f63 100644
--- a/ewol/compositing/TextBase.cpp
+++ b/ewol/compositing/TextBase.cpp
@@ -9,6 +9,13 @@
 #include <ewol/context/Context.hpp>
 #include <etk/types.hpp>
 
+
+const int32_t ewol::compositing::TextBase::m_vboIdCoord(0);
+const int32_t ewol::compositing::TextBase::m_vboIdCoordText(1);
+const int32_t ewol::compositing::TextBase::m_vboIdColor(2);
+const int32_t ewol::compositing::TextBase::m_vboIdGlyphLevel(3);
+#define NB_VBO (4)
+
 ewol::compositing::TextBase::TextBase(const std::string& _shaderName, bool _loadProgram) :
   m_position(0.0, 0.0, 0.0),
   m_clippingPosStart(0.0, 0.0, 0.0),
@@ -37,6 +44,14 @@ ewol::compositing::TextBase::TextBase(const std::string& _shaderName, bool _load
 	if (_loadProgram == true) {
 		loadProgram(_shaderName);
 	}
+	// Create the VBO:
+	m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
+	if (m_VBO == nullptr) {
+		EWOL_ERROR("can not instanciate VBO ...");
+		return;
+	}
+	// TO facilitate some debugs we add a name of the VBO:
+	m_VBO->setName("[VBO] of ewol::compositing::TextBase");
 }
 
 
@@ -45,7 +60,7 @@ ewol::compositing::TextBase::~TextBase() {
 }
 
 void ewol::compositing::TextBase::loadProgram(const std::string& _shaderName) {
-	// get the shader resource :
+	// get the shader resource:
 	m_GLPosition = 0;
 	ememory::SharedPtr<gale::resource::Program> old = m_GLprogram;
 	m_GLprogram = gale::resource::Program::create(_shaderName);
@@ -84,11 +99,9 @@ void ewol::compositing::TextBase::clear() {
 	ewol::Compositing::clear();
 	// remove sub draw system
 	m_vectorialDraw.clear();
-	// reset Buffer :
-	m_coord.clear();
-	m_coordTex.clear();
-	m_coordColor.clear();
-	// reset temporal variables :
+	// reset Buffer:
+	m_VBO->clear();
+	// reset temporal variables:
 	reset();
 }
 
diff --git a/ewol/compositing/TextBase.hpp b/ewol/compositing/TextBase.hpp
index 65300204..1528cef7 100644
--- a/ewol/compositing/TextBase.hpp
+++ b/ewol/compositing/TextBase.hpp
@@ -22,8 +22,8 @@ namespace ewol {
 		 */
 		class TextDecoration {
 			public:
-				etk::Color<> m_colorBg; //!< display background color
-				etk::Color<> m_colorFg; //!< display foreground color
+				etk::Color<float,4> m_colorBg; //!< display background color
+				etk::Color<float,4> m_colorFg; //!< display foreground color
 				enum ewol::font::mode m_mode; //!< display mode Regular/Bold/Italic/BoldItalic
 				TextDecoration() {
 					m_colorBg = etk::color::blue;
@@ -57,13 +57,13 @@ namespace ewol {
 				vec3 m_clippingPosStop; //!< Clipping stop position
 				bool m_clippingEnable; //!< true if the clipping must be activated
 			protected:
-				etk::Color<> m_defaultColorFg; //!< The text foreground color
-				etk::Color<> m_defaultColorBg; //!< The text background color
+				etk::Color<float,4> m_defaultColorFg; //!< The text foreground color
+				etk::Color<float,4> m_defaultColorBg; //!< The text background color
 			protected:
-				etk::Color<> m_color; //!< The text foreground color
-				etk::Color<> m_colorBg; //!< The text background color
-				etk::Color<> m_colorCursor; //!< The text cursor color
-				etk::Color<> m_colorSelection; //!< The text Selection color
+				etk::Color<float,4> m_color; //!< The text foreground color
+				etk::Color<float,4> m_colorBg; //!< The text background color
+				etk::Color<float,4> m_colorCursor; //!< The text cursor color
+				etk::Color<float,4> m_colorSelection; //!< The text Selection color
 			protected:
 				enum ewol::font::mode m_mode; //!< font display property : Regular/Bold/Italic/BoldItalic
 				bool m_kerning; //!< Kerning enable or disable on the next elements displayed
@@ -85,9 +85,11 @@ namespace ewol {
 				int32_t m_selectionStartPos; //!< start position of the Selection (if == m_cursorPos ==> no selection)
 				int32_t m_cursorPos; //!< Cursor position (default no cursor  == > -100)
 			protected: // Text
-				std::vector<vec3 > m_coord; //!< internal coord of the object
-				std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
-				std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point
+				static const int32_t m_vboIdCoord;
+				static const int32_t m_vboIdCoordText;
+				static const int32_t m_vboIdColor;
+				static const int32_t m_vboIdGlyphLevel;
+				ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
 			public:
 				/**
 				 * @brief load the openGL program and get all the ID needed
diff --git a/ewol/compositing/TextDF.cpp b/ewol/compositing/TextDF.cpp
index 3a574c63..c657c329 100644
--- a/ewol/compositing/TextDF.cpp
+++ b/ewol/compositing/TextDF.cpp
@@ -30,11 +30,10 @@ void ewol::compositing::TextDF::updateSizeToRender(const vec2& _size) {
 }
 
 void ewol::compositing::TextDF::drawMT(const mat4& _transformationMatrix, bool _enableDepthTest) {
-	
 	// draw BG in any case:
 	m_vectorialDraw.draw();
-	
-	if (m_coord.size() <= 0 || m_fontDF == nullptr) {
+	if (    m_VBO->bufferSize(m_vboIdCoord) <= 0
+	     || m_fontDF == nullptr) {
 		//EWOL_WARNING("Nothink to draw...");
 		return;
 	}
@@ -49,22 +48,22 @@ void ewol::compositing::TextDF::drawMT(const mat4& _transformationMatrix, bool _
 	if (_enableDepthTest == true) {
 		gale::openGL::enable(gale::openGL::flag_depthTest);
 	}
-	// set Matrix : translation/positionMatrix
+	// set Matrix: translation/positionMatrix
 	mat4 projMatrix = gale::openGL::getMatrix();
 	mat4 camMatrix = gale::openGL::getCameraMatrix();
 	mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
 	m_GLprogram->use(); 
 	m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
-	// Texture :
+	// Texture:
 	m_GLprogram->setTexture0(m_GLtexID, m_fontDF->getRendererId());
 	m_GLprogram->uniform1i(m_GLtextWidth, m_fontDF->getOpenGlSize().x());
 	m_GLprogram->uniform1i(m_GLtextHeight, m_fontDF->getOpenGlSize().x());
-	m_GLprogram->sendAttribute(m_GLPosition, m_coord);
-	m_GLprogram->sendAttribute(m_GLtexture, m_coordTex);
-	m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
-	m_GLprogram->sendAttribute(m_GLglyphLevel, m_glyphLevel);
-	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
+	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
+	m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordText);
+	m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
+	m_GLprogram->sendAttributePointer(m_GLglyphLevel, m_VBO, m_vboIdGlyphLevel);
+	// Request the draw od the elements:
+	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
 	m_GLprogram->unUse();
 	if (_enableDepthTest == true) {
 		gale::openGL::disable(gale::openGL::flag_depthTest);
@@ -76,8 +75,9 @@ void ewol::compositing::TextDF::drawD(bool _disableDepthTest) {
 	// draw BG in any case:
 	m_vectorialDraw.draw();
 	
-	if (m_coord.size() <= 0 || m_fontDF == nullptr) {
-		// TODO : a remètre ...
+	if (    m_VBO->bufferSize(m_vboIdCoord) <= 0
+	     || m_fontDF == nullptr) {
+		// TODO : Set it back
 		//EWOL_WARNING("Nothink to draw...");
 		return;
 	}
@@ -89,27 +89,23 @@ void ewol::compositing::TextDF::drawD(bool _disableDepthTest) {
 		EWOL_ERROR("No shader ...");
 		return;
 	}
-	// set Matrix : translation/positionMatrix
+	// set Matrix: translation/positionMatrix
 	mat4 tmpMatrix = gale::openGL::getMatrix()*m_matrixApply;
 	m_GLprogram->use(); 
 	m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
-	// Texture :
+	// Texture:
 	m_GLprogram->setTexture0(m_GLtexID, m_fontDF->getRendererId());
 	m_GLprogram->uniform1i(m_GLtextWidth, m_fontDF->getOpenGlSize().x());
 	m_GLprogram->uniform1i(m_GLtextHeight, m_fontDF->getOpenGlSize().x());
-	m_GLprogram->sendAttribute(m_GLPosition, m_coord);
-	m_GLprogram->sendAttribute(m_GLtexture, m_coordTex);
-	m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
-	m_GLprogram->sendAttribute(m_GLglyphLevel, m_glyphLevel);
-	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
+	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
+	m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordText);
+	m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
+	m_GLprogram->sendAttributePointer(m_GLglyphLevel, m_VBO, m_vboIdGlyphLevel);
+	// Request the draw od the elements:
+	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
 	m_GLprogram->unUse();
 }
 
-void ewol::compositing::TextDF::clear() {
-	ewol::compositing::TextBase::clear();
-	m_glyphLevel.clear();
-}
 void ewol::compositing::TextDF::loadProgram(const std::string& _shaderName) {
 	ewol::compositing::TextBase::loadProgram(_shaderName);
 	if (m_GLprogram != nullptr) {
@@ -334,20 +330,21 @@ void ewol::compositing::TextDF::printChar(const char32_t& _charcode) {
 					 *                
 					 */
 					// set texture coordonates :
-					m_coordTex.push_back(texturePos[0]);
-					m_coordTex.push_back(texturePos[1]);
-					m_coordTex.push_back(texturePos[2]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[0]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[1]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[2]);
 					// set display positions :
-					m_coord.push_back(bitmapDrawPos[0]);
-					m_coord.push_back(bitmapDrawPos[1]);
-					m_coord.push_back(bitmapDrawPos[2]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[0]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[1]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[2]);
 					// set the color
-					m_coordColor.push_back(m_color);
-					m_coordColor.push_back(m_color);
-					m_coordColor.push_back(m_color);
-					m_glyphLevel.push_back(glyphLevel);
-					m_glyphLevel.push_back(glyphLevel);
-					m_glyphLevel.push_back(glyphLevel);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					// set the bliph level
+					m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
+					m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
+					m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
 					/* Step 2 : 
 					 *              
 					 *   **         
@@ -356,20 +353,21 @@ void ewol::compositing::TextDF::printChar(const char32_t& _charcode) {
 					 *   ********   
 					 */
 					// set texture coordonates :
-					m_coordTex.push_back(texturePos[0]);
-					m_coordTex.push_back(texturePos[2]);
-					m_coordTex.push_back(texturePos[3]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[0]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[2]);
+					m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[3]);
 					// set display positions :
-					m_coord.push_back(bitmapDrawPos[0]);
-					m_coord.push_back(bitmapDrawPos[2]);
-					m_coord.push_back(bitmapDrawPos[3]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[0]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[2]);
+					m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[3]);
 					// set the color
-					m_coordColor.push_back(m_color);
-					m_coordColor.push_back(m_color);
-					m_coordColor.push_back(m_color);
-					m_glyphLevel.push_back(glyphLevel);
-					m_glyphLevel.push_back(glyphLevel);
-					m_glyphLevel.push_back(glyphLevel);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					m_VBO->pushOnBuffer(m_vboIdColor, m_color);
+					// set the bliph level
+					m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
+					m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
+					m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
 				}
 			}
 		}
@@ -380,6 +378,7 @@ void ewol::compositing::TextDF::printChar(const char32_t& _charcode) {
 	//EWOL_DEBUG(" 6 print '" << charcode << "' : start=" << m_sizeDisplayStart << " stop=" << m_sizeDisplayStop << " pos=" << m_position);
 	// Register the previous character
 	m_previousCharcode = _charcode;
+	m_VBO->flush();
 	return;
 }
 
diff --git a/ewol/compositing/TextDF.hpp b/ewol/compositing/TextDF.hpp
index 50ea194b..f941f52f 100644
--- a/ewol/compositing/TextDF.hpp
+++ b/ewol/compositing/TextDF.hpp
@@ -20,7 +20,6 @@ namespace ewol {
 		class TextDF : public ewol::compositing::TextBase {
 			protected:
 				ememory::SharedPtr<ewol::resource::DistanceFieldFont> m_fontDF; //!< Font resources
-				std::vector<float> m_glyphLevel; //!< Level of display of the glyph (notmal : 0.50, bold : 0.40, super bold : 0.30 ...)
 			protected:
 				int32_t m_GLglyphLevel; //!< openGL Id on the glyph level display
 			public:
@@ -42,7 +41,6 @@ namespace ewol {
 				 */
 				void updateSizeToRender(const vec2& _size);
 			public:
-				virtual void clear();
 				virtual void drawD(bool _disableDepthTest);
 				virtual void drawMT(const mat4& _transformationMatrix, bool _enableDepthTest);
 			protected:
diff --git a/ewol/resource/Colored3DObject.cpp b/ewol/resource/Colored3DObject.cpp
index 0fbdb69d..bc116458 100644
--- a/ewol/resource/Colored3DObject.cpp
+++ b/ewol/resource/Colored3DObject.cpp
@@ -4,6 +4,8 @@
  * @license APACHE v2.0 (see license file)
  */
 
+#ifndef __TARGET_OS__Web
+
 #include <ewol/debug.hpp>
 #include <ewol/resource/Colored3DObject.hpp>
 #include <gale/resource/Manager.hpp>
@@ -25,11 +27,6 @@ void ewol::resource::Colored3DObject::init() {
 		m_GLColor    = m_GLprogram->getUniform("EW_color");
 		m_GLMatrix   = m_GLprogram->getUniform("EW_MatrixTransformation");
 	}
-	m_VBO = gale::resource::VirtualBufferObject::create(3);
-	if (m_VBO == nullptr) {
-		EWOL_ERROR("can not instanciate VBO ...");
-		return;
-	}
 }
 
 ewol::resource::Colored3DObject::~Colored3DObject() {
@@ -37,17 +34,18 @@ ewol::resource::Colored3DObject::~Colored3DObject() {
 }
 
 
-void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
+void ewol::resource::Colored3DObject::draw(std::vector<vec3>& _vertices,
+                                           const etk::Color<float>& _color,
                                            bool _updateDepthBuffer,
                                            bool _depthtest) {
-	if (m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID) <= 0) {
+	if (_vertices.size() <= 0) {
 		return;
 	}
 	if (m_GLprogram == nullptr) {
 		EWOL_ERROR("No shader ...");
 		return;
 	}
-	if (_depthtest == true) {
+	if (true == _depthtest) {
 		gale::openGL::enable(gale::openGL::flag_depthTest);
 		if (false == _updateDepthBuffer) {
 			glDepthMask(GL_FALSE);
@@ -61,11 +59,11 @@ void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
 	mat4 tmpMatrix = projMatrix * camMatrix;
 	m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
 	// position :
-	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID);
+	m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z,unused*/, &_vertices[0], 4*sizeof(float));
 	// color :
 	m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
 	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID));
+	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, _vertices.size());
 	m_GLprogram->unUse();
 	// Request the draw od the elements : 
 	//glDrawArrays(GL_LINES, 0, vertices.size());
@@ -78,11 +76,12 @@ void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
 	}
 }
 
-void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
+void ewol::resource::Colored3DObject::draw(std::vector<vec3>& _vertices,
+                                           const etk::Color<float>& _color,
                                            mat4& _transformationMatrix,
                                            bool _updateDepthBuffer,
                                            bool _depthtest) {
-	if (m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID) <= 0) {
+	if (_vertices.size() <= 0) {
 		return;
 	}
 	if (m_GLprogram == nullptr) {
@@ -103,11 +102,11 @@ void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
 	mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
 	m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
 	// position :
-	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID);
+	m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z*/, &_vertices[0], 4*sizeof(float));
 	// color :
 	m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
 	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID));
+	gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, _vertices.size());
 	m_GLprogram->unUse();
 	if (true == _depthtest) {
 		if (false == _updateDepthBuffer) {
@@ -117,11 +116,12 @@ void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
 	}
 }
 
-void ewol::resource::Colored3DObject::drawLine(const etk::Color<float>& _color,
+void ewol::resource::Colored3DObject::drawLine(std::vector<vec3>& _vertices,
+                                               const etk::Color<float>& _color,
                                                mat4& _transformationMatrix,
                                                bool _updateDepthBuffer,
                                                bool _depthtest) {
-	if (m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID) <= 0) {
+	if (_vertices.size() <= 0) {
 		return;
 	}
 	if (m_GLprogram == nullptr) {
@@ -142,11 +142,11 @@ void ewol::resource::Colored3DObject::drawLine(const etk::Color<float>& _color,
 	mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
 	m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
 	// position :
-	m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID);
+	m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z*/, &_vertices[0], 4*sizeof(float));
 	// color :
 	m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
 	// Request the draw od the elements : 
-	gale::openGL::drawArrays(gale::openGL::renderMode::line, 0, m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID));
+	gale::openGL::drawArrays(gale::openGL::renderMode::line, 0, _vertices.size());
 	m_GLprogram->unUse();
 	if (true == _depthtest) {
 		if (false == _updateDepthBuffer) {
@@ -163,7 +163,7 @@ void ewol::resource::Colored3DObject::drawSphere(float _radius,
                                                  mat4& _transformationMatrix,
                                                  const etk::Color<float>& _tmpColor) {
 	int i, j;
-	m_VBO->clear();
+	std::vector<vec3> EwolVertices;
 	for(i = 0; i <= _lats; i++) {
 		btScalar lat0 = SIMD_PI * (-btScalar(0.5) + (btScalar) (i - 1) / _lats);
 		btScalar z0  = _radius*sin(lat0);
@@ -187,22 +187,22 @@ void ewol::resource::Colored3DObject::drawSphere(float _radius,
 			vec3 v2 = vec3(x * zr1, y * zr1, z1);
 			vec3 v3 = vec3(x * zr0, y * zr0, z0);
 			
-			m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v1);
-			m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v2);
-			m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v3);
+			EwolVertices.push_back(v1);
+			EwolVertices.push_back(v2);
+			EwolVertices.push_back(v3);
 			
-			m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v1);
-			m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v3);
-			m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v4);
+			EwolVertices.push_back(v1);
+			EwolVertices.push_back(v3);
+			EwolVertices.push_back(v4);
 		}
 	}
-	draw(_tmpColor, _transformationMatrix);
+	draw(EwolVertices, _tmpColor, _transformationMatrix);
 }
 
 void ewol::resource::Colored3DObject::drawSquare(const vec3& _size,
                                                  mat4& _transformationMatrix,
                                                  const etk::Color<float>& _tmpColor){
-	m_VBO->clear();
+	std::vector<vec3> tmpVertices;
 	static int indices[36] = { 0,1,2,	3,2,1,	4,0,6,
 	                           6,0,2,	5,1,4,	4,1,0,
 	                           7,3,1,	7,1,5,	5,4,7,
@@ -215,15 +215,16 @@ void ewol::resource::Colored3DObject::drawSquare(const vec3& _size,
 	                   vec3(-_size[0],_size[1],-_size[2]),
 	                   vec3(_size[0],-_size[1],-_size[2]),
 	                   vec3(-_size[0],-_size[1],-_size[2])};
+	tmpVertices.clear();
 	for (int32_t iii=0 ; iii<36 ; iii+=3) {
 		// normal calculation :
 		//btVector3 normal = (vertices[indices[iii+2]]-vertices[indices[iii]]).cross(vertices[indices[iii+1]]-vertices[indices[iii]]);
 		//normal.normalize ();
-		m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, vertices[indices[iii]]);
-		m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, vertices[indices[iii+1]]);
-		m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, vertices[indices[iii+2]]);
+		tmpVertices.push_back(vertices[indices[iii]]);
+		tmpVertices.push_back(vertices[indices[iii+1]]);
+		tmpVertices.push_back(vertices[indices[iii+2]]);
 	}
-	draw(_tmpColor, _transformationMatrix);
+	draw(tmpVertices, _tmpColor, _transformationMatrix);
 }
 namespace etk {
 	template<> std::string to_string(ewol::resource::Colored3DObject const&) {
@@ -236,3 +237,5 @@ namespace etk {
 ESIGNAL_DECLARE_SIGNAL(ewol::resource::Colored3DObject);
 ESIGNAL_DECLARE_SIGNAL(ememory::SharedPtr<ewol::resource::Colored3DObject>);
 
+#endif
+
diff --git a/ewol/resource/Colored3DObject.hpp b/ewol/resource/Colored3DObject.hpp
index 8ec335d5..e46c2f3e 100644
--- a/ewol/resource/Colored3DObject.hpp
+++ b/ewol/resource/Colored3DObject.hpp
@@ -5,22 +5,24 @@
  */
 #pragma once
 
+#ifndef __TARGET_OS__Web
+
 #include <etk/types.hpp>
 #include <gale/resource/Resource.hpp>
 #include <ewol/resource/Image.hpp>
 #include <gale/resource/Program.hpp>
 
-#define EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID 0
-
 namespace ewol {
 	namespace resource {
+		/**
+		 * @brief simple display of Colored3DObject ==> for DEBUG only Not availlable on ALL platform (like webGL)
+		 */
 		class Colored3DObject : public gale::Resource {
 			protected:
 				ememory::SharedPtr<gale::resource::Program> m_GLprogram;
 				int32_t m_GLPosition;
 				int32_t m_GLMatrix;
 				int32_t m_GLColor;
-				ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
 			protected:
 				Colored3DObject();
 				void init();
@@ -28,14 +30,17 @@ namespace ewol {
 				DECLARE_RESOURCE_FACTORY(Colored3DObject);
 				virtual ~Colored3DObject();
 			public:
-				virtual void draw(const etk::Color<float>& _color,
+				virtual void draw(std::vector<vec3>& _vertices,
+				                  const etk::Color<float>& _color,
 				                  bool _updateDepthBuffer=true,
 				                  bool _depthtest=true);
-				virtual void draw(const etk::Color<float>& _color,
+				virtual void draw(std::vector<vec3>& _vertices,
+				                  const etk::Color<float>& _color,
 				                  mat4& _transformationMatrix,
 				                  bool _updateDepthBuffer=true,
 				                  bool _depthtest=true);
-				virtual void drawLine(const etk::Color<float>& _color,
+				virtual void drawLine(std::vector<vec3>& _vertices,
+				                      const etk::Color<float>& _color,
 				                      mat4& _transformationMatrix,
 				                      bool _updateDepthBuffer=true,
 				                      bool _depthtest=true);
@@ -52,3 +57,4 @@ namespace ewol {
 	};
 };
 
+#endif
diff --git a/tools/visual_test/appl/MainWindows.cpp b/tools/visual_test/appl/MainWindows.cpp
index 8ae38808..4e22a05b 100644
--- a/tools/visual_test/appl/MainWindows.cpp
+++ b/tools/visual_test/appl/MainWindows.cpp
@@ -124,8 +124,8 @@ void appl::MainWindows::onCallbackWidgetChange(int32_t _increment) {
 	std::string tmpConstruct;
 	switch(m_idWidget) {
 		case 0:
-			tmpConstruct = "<spin/>\n";
-			tmpDescription = "Test ewol::widget::Spin";
+			tmpConstruct = "<image src='DATA:sphere.png'/>\n";
+			tmpDescription = "Test ewol::widget::Image";
 			break;
 		case 1:
 			tmpConstruct = std::string()
@@ -147,8 +147,8 @@ void appl::MainWindows::onCallbackWidgetChange(int32_t _increment) {
 			tmpDescription = "Test ewol::widget::Label";
 			break;
 		case 4:
-			tmpConstruct = "<image src='DATA:sphere.png'/>\n";
-			tmpDescription = "Test ewol::widget::Image";
+			tmpConstruct = "<spin/>\n";
+			tmpDescription = "Test ewol::widget::Spin";
 			break;
 		case 5:
 			tmpConstruct = "<checkbox><label>Simple string</label></checkbox>\n";