diff --git a/include/llmr/geometry/buffer.hpp b/include/llmr/geometry/buffer.hpp
index 93ffbec26..89adfb37f 100644
--- a/include/llmr/geometry/buffer.hpp
+++ b/include/llmr/geometry/buffer.hpp
@@ -4,6 +4,7 @@
 #include <cstdlib>
 #include <cassert>
 #include <llmr/platform/gl.hpp>
+#include <llmr/util/noncopyable.hpp>
 
 namespace llmr {
 
@@ -12,7 +13,7 @@ template <
     int bufferType = GL_ARRAY_BUFFER,
     size_t defaultLength = 8192
 >
-class Buffer {
+class Buffer : private util::noncopyable {
 public:
     ~Buffer() {
         if (array) {
diff --git a/include/llmr/map/tile_data.hpp b/include/llmr/map/tile_data.hpp
index c5a664eb1..b89784c75 100644
--- a/include/llmr/map/tile_data.hpp
+++ b/include/llmr/map/tile_data.hpp
@@ -11,6 +11,13 @@
 #include <llmr/map/vector_tile.hpp>
 #include <llmr/platform/platform.hpp>
 
+#include <llmr/geometry/vertex_buffer.hpp>
+#include <llmr/geometry/elements_buffer.hpp>
+#include <llmr/geometry/fill_buffer.hpp>
+#include <llmr/geometry/line_buffer.hpp>
+#include <llmr/geometry/point_buffer.hpp>
+#include <llmr/geometry/text_buffer.hpp>
+
 #include <cstdint>
 #include <forward_list>
 #include <string>
@@ -26,14 +33,8 @@ class Raster;
 class Bucket;
 class LayerDescription;
 class BucketDescription;
-class FillVertexBuffer;
-class LineVertexBuffer;
-class PointVertexBuffer;
-class TextVertexBuffer;
-class TriangleElementsBuffer;
-class LineElementsBuffer;
-class PointElementsBuffer;
-class TextElementsBuffer;
+
+
 class PlainShader;
 
 class TileData : public std::enable_shared_from_this<TileData>,
@@ -75,14 +76,14 @@ public:
     DebugFontBuffer debugFontBuffer;
     VertexArrayObject debugFontArray;
 
-    std::shared_ptr<FillVertexBuffer> fillVertexBuffer;
-    std::shared_ptr<LineVertexBuffer> lineVertexBuffer;
-    std::shared_ptr<PointVertexBuffer> pointVertexBuffer;
-    std::shared_ptr<TextVertexBuffer> textVertexBuffer;
+    FillVertexBuffer fillVertexBuffer;
+    LineVertexBuffer lineVertexBuffer;
+    PointVertexBuffer pointVertexBuffer;
+    TextVertexBuffer textVertexBuffer;
 
-    std::shared_ptr<TriangleElementsBuffer> triangleElementsBuffer;
-    std::shared_ptr<LineElementsBuffer> lineElementsBuffer;
-    std::shared_ptr<PointElementsBuffer> pointElementsBuffer;
+    TriangleElementsBuffer triangleElementsBuffer;
+    LineElementsBuffer lineElementsBuffer;
+    PointElementsBuffer pointElementsBuffer;
 
     // Holds the buckets of this tile.
     // They contain the location offsets in the buffers stored above
diff --git a/include/llmr/renderer/fill_bucket.hpp b/include/llmr/renderer/fill_bucket.hpp
index 633ae8c2f..7d2b81287 100644
--- a/include/llmr/renderer/fill_bucket.hpp
+++ b/include/llmr/renderer/fill_bucket.hpp
@@ -38,9 +38,9 @@ class FillBucket : public Bucket {
     typedef ElementGroup triangle_group_type;
     typedef ElementGroup line_group_type;
 public:
-    FillBucket(const std::shared_ptr<FillVertexBuffer>& vertexBuffer,
-               const std::shared_ptr<TriangleElementsBuffer>& triangleElementsBuffer,
-               const std::shared_ptr<LineElementsBuffer>& lineElementsBuffer,
+    FillBucket(FillVertexBuffer& vertexBuffer,
+               TriangleElementsBuffer& triangleElementsBuffer,
+               LineElementsBuffer& lineElementsBuffer,
                const BucketDescription& bucket_desc);
     ~FillBucket();
 
@@ -62,9 +62,9 @@ private:
     TESStesselator *tesselator;
     ClipperLib::Clipper clipper;
 
-    std::shared_ptr<FillVertexBuffer> vertexBuffer;
-    std::shared_ptr<TriangleElementsBuffer> triangleElementsBuffer;
-    std::shared_ptr<LineElementsBuffer> lineElementsBuffer;
+    FillVertexBuffer& vertexBuffer;
+    TriangleElementsBuffer& triangleElementsBuffer;
+    LineElementsBuffer& lineElementsBuffer;
 
     // hold information on where the vertices are located in the FillBuffer
     const size_t vertex_start;
diff --git a/include/llmr/renderer/line_bucket.hpp b/include/llmr/renderer/line_bucket.hpp
index 16f7dac98..eb55bba5a 100644
--- a/include/llmr/renderer/line_bucket.hpp
+++ b/include/llmr/renderer/line_bucket.hpp
@@ -5,6 +5,7 @@
 #include <llmr/style/bucket_description.hpp>
 #include <llmr/geometry/vao.hpp>
 #include <llmr/geometry/elements_buffer.hpp>
+#include <llmr/geometry/line_buffer.hpp>
 #include <memory>
 #include <vector>
 
@@ -21,9 +22,9 @@ class LineBucket : public Bucket {
     typedef ElementGroup triangle_group_type;
     typedef ElementGroup point_group_type;
 public:
-    LineBucket(const std::shared_ptr<LineVertexBuffer>& vertexBuffer,
-               const std::shared_ptr<TriangleElementsBuffer>& triangleElementsBuffer,
-               const std::shared_ptr<PointElementsBuffer>& pointElementsBuffer,
+    LineBucket(LineVertexBuffer& vertexBuffer,
+               TriangleElementsBuffer& triangleElementsBuffer,
+               PointElementsBuffer& pointElementsBuffer,
                const BucketDescription& bucket_desc);
 
     virtual void render(Painter& painter, const std::string& layer_name, const Tile::ID& id);
@@ -42,9 +43,9 @@ public:
 
 private:
 
-    std::shared_ptr<LineVertexBuffer> vertexBuffer;
-    std::shared_ptr<TriangleElementsBuffer> triangleElementsBuffer;
-    std::shared_ptr<PointElementsBuffer> pointElementsBuffer;
+    LineVertexBuffer& vertexBuffer;
+    TriangleElementsBuffer& triangleElementsBuffer;
+    PointElementsBuffer& pointElementsBuffer;
 
     const size_t vertex_start;
     const size_t triangle_elements_start;
diff --git a/include/llmr/renderer/point_bucket.hpp b/include/llmr/renderer/point_bucket.hpp
index d65435d68..e615f7ffe 100644
--- a/include/llmr/renderer/point_bucket.hpp
+++ b/include/llmr/renderer/point_bucket.hpp
@@ -23,7 +23,7 @@ struct pbf;
 
 class PointBucket : public Bucket {
 public:
-    PointBucket(const std::shared_ptr<PointVertexBuffer>& vertexBuffer,
+    PointBucket(PointVertexBuffer& vertexBuffer,
                 const BucketDescription& bucket_desc);
 
     virtual void render(Painter& painter, const std::string& layer_name, const Tile::ID& id);
@@ -38,7 +38,8 @@ public:
     const BucketGeometryDescription geometry;
 
 private:
-    std::shared_ptr<PointVertexBuffer> vertexBuffer;
+
+    PointVertexBuffer& vertexBuffer;
     VertexArrayObject array;
 
     const size_t vertex_start;
diff --git a/include/llmr/renderer/text_bucket.hpp b/include/llmr/renderer/text_bucket.hpp
index 4306d8ba0..babec7ea4 100644
--- a/include/llmr/renderer/text_bucket.hpp
+++ b/include/llmr/renderer/text_bucket.hpp
@@ -25,8 +25,8 @@ class TextBucket : public Bucket {
 
 public:
     TextBucket(
-        const std::shared_ptr<TextVertexBuffer> &vertexBuffer,
-        const std::shared_ptr<TriangleElementsBuffer> &triangleElementsBuffer,
+        TextVertexBuffer &vertexBuffer,
+        TriangleElementsBuffer &triangleElementsBuffer,
         const BucketDescription &bucket_desc, Placement &placement);
 
     virtual void render(Painter &painter, const std::string &layer_name,
@@ -47,8 +47,8 @@ public:
     const BucketGeometryDescription &geom_desc;
 
 private:
-    std::shared_ptr<TextVertexBuffer> vertexBuffer;
-    std::shared_ptr<TriangleElementsBuffer> triangleElementsBuffer;
+    TextVertexBuffer& vertexBuffer;
+    TriangleElementsBuffer& triangleElementsBuffer;
     Placement &placement;
 
     const size_t vertex_start;
diff --git a/src/map/tile_data.cpp b/src/map/tile_data.cpp
index 7b070f869..26ffdedb1 100644
--- a/src/map/tile_data.cpp
+++ b/src/map/tile_data.cpp
@@ -17,13 +17,6 @@ TileData::TileData(Tile::ID id, const Style& style, GlyphAtlas& glyphAtlas, cons
       use_retina(use_retina),
       state(State::initial),
       raster(),
-      fillVertexBuffer(std::make_shared<FillVertexBuffer>()),
-      lineVertexBuffer(std::make_shared<LineVertexBuffer>()),
-      pointVertexBuffer(std::make_shared<PointVertexBuffer>()),
-      textVertexBuffer(std::make_shared<TextVertexBuffer>()),
-      triangleElementsBuffer(std::make_shared<TriangleElementsBuffer>()),
-      lineElementsBuffer(std::make_shared<LineElementsBuffer>()),
-      pointElementsBuffer(std::make_shared<PointElementsBuffer>()),
       style(style),
       glyphAtlas(glyphAtlas) {
 
diff --git a/src/renderer/fill_bucket.cpp b/src/renderer/fill_bucket.cpp
index 92d654d14..4e553d23d 100644
--- a/src/renderer/fill_bucket.cpp
+++ b/src/renderer/fill_bucket.cpp
@@ -30,9 +30,9 @@ void FillBucket::free(void *, void *ptr) {
     ::free(ptr);
 }
 
-FillBucket::FillBucket(const std::shared_ptr<FillVertexBuffer>& vertexBuffer,
-                       const std::shared_ptr<TriangleElementsBuffer>& triangleElementsBuffer,
-                       const std::shared_ptr<LineElementsBuffer>& lineElementsBuffer,
+FillBucket::FillBucket(FillVertexBuffer& vertexBuffer,
+                       TriangleElementsBuffer& triangleElementsBuffer,
+                       LineElementsBuffer& lineElementsBuffer,
                        const BucketDescription& bucket_desc)
     : geom_desc(bucket_desc.geometry),
     allocator(new TESSalloc {
@@ -51,9 +51,9 @@ tesselator(tessNewTess(allocator)),
 vertexBuffer(vertexBuffer),
 triangleElementsBuffer(triangleElementsBuffer),
 lineElementsBuffer(lineElementsBuffer),
-vertex_start(vertexBuffer->index()),
-triangle_elements_start(triangleElementsBuffer->index()),
-line_elements_start(lineElementsBuffer->index()) {
+vertex_start(vertexBuffer.index()),
+triangle_elements_start(triangleElementsBuffer.index()),
+line_elements_start(lineElementsBuffer.index()) {
     assert(tesselator);
 }
 
@@ -131,12 +131,12 @@ void FillBucket::tessellate() {
         for (const ClipperLib::IntPoint& pt : polygon) {
             line.push_back(pt.X);
             line.push_back(pt.Y);
-            vertexBuffer->add(pt.X, pt.Y);
+            vertexBuffer.add(pt.X, pt.Y);
         }
 
         for (size_t i = 0; i < group_count; i++) {
             const size_t prev_i = (i == 0 ? group_count : i) - 1;
-            lineElementsBuffer->add(lineIndex + prev_i, lineIndex + i);
+            lineElementsBuffer.add(lineIndex + prev_i, lineIndex + i);
         }
 
         lineIndex += group_count;
@@ -155,7 +155,7 @@ void FillBucket::tessellate() {
 
         for (size_t i = 0; i < vertex_count; ++i) {
             if (vertex_indices[i] == TESS_UNDEF) {
-                vertexBuffer->add(round(vertices[i * 2]), round(vertices[i * 2 + 1]));
+                vertexBuffer.add(round(vertices[i * 2]), round(vertices[i * 2 + 1]));
                 vertex_indices[i] = (TESSindex)total_vertex_count;
                 total_vertex_count++;
             }
@@ -180,7 +180,7 @@ void FillBucket::tessellate() {
                 const TESSindex c = vertex_indices[element_group[2]];
 
                 if (a != TESS_UNDEF && b != TESS_UNDEF && c != TESS_UNDEF) {
-                    triangleElementsBuffer->add(triangleIndex + a, triangleIndex + b, triangleIndex + c);
+                    triangleElementsBuffer.add(triangleIndex + a, triangleIndex + b, triangleIndex + c);
                 } else {
                     // TODO: We're missing a vertex that was not part of the line.
                     fprintf(stderr, "undefined element buffer\n");
@@ -211,34 +211,34 @@ bool FillBucket::empty() const {
 }
 
 void FillBucket::drawElements(PlainShader& shader) {
-    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer->itemSize);
-    char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer->itemSize);
+    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
+    char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
     for (triangle_group_type& group : triangleGroups) {
-        group.array.bind(shader, *vertexBuffer, *triangleElementsBuffer, vertex_index);
+        group.array.bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
         glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
-        vertex_index += group.vertex_length * vertexBuffer->itemSize;
-        elements_index += group.elements_length * triangleElementsBuffer->itemSize;
+        vertex_index += group.vertex_length * vertexBuffer.itemSize;
+        elements_index += group.elements_length * triangleElementsBuffer.itemSize;
     }
 }
 
 void FillBucket::drawElements(PatternShader& shader) {
-    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer->itemSize);
-    char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer->itemSize);
+    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
+    char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
     for (triangle_group_type& group : triangleGroups) {
-        group.array.bind(shader, *vertexBuffer, *triangleElementsBuffer, vertex_index);
+        group.array.bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
         glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
-        vertex_index += group.vertex_length * vertexBuffer->itemSize;
-        elements_index += group.elements_length * triangleElementsBuffer->itemSize;
+        vertex_index += group.vertex_length * vertexBuffer.itemSize;
+        elements_index += group.elements_length * triangleElementsBuffer.itemSize;
     }
 }
 
 void FillBucket::drawVertices(OutlineShader& shader) {
-    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer->itemSize);
-    char *elements_index = BUFFER_OFFSET(line_elements_start * lineElementsBuffer->itemSize);
+    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
+    char *elements_index = BUFFER_OFFSET(line_elements_start * lineElementsBuffer.itemSize);
     for (line_group_type& group : lineGroups) {
-        group.array.bind(shader, *vertexBuffer, *lineElementsBuffer, vertex_index);
+        group.array.bind(shader, vertexBuffer, lineElementsBuffer, vertex_index);
         glDrawElements(GL_LINES, group.elements_length * 2, GL_UNSIGNED_SHORT, elements_index);
-        vertex_index += group.vertex_length * vertexBuffer->itemSize;
-        elements_index += group.elements_length * lineElementsBuffer->itemSize;
+        vertex_index += group.vertex_length * vertexBuffer.itemSize;
+        elements_index += group.elements_length * lineElementsBuffer.itemSize;
     }
 }
diff --git a/src/renderer/line_bucket.cpp b/src/renderer/line_bucket.cpp
index b30fa635c..7b607d693 100644
--- a/src/renderer/line_bucket.cpp
+++ b/src/renderer/line_bucket.cpp
@@ -1,5 +1,4 @@
 #include <llmr/renderer/line_bucket.hpp>
-#include <llmr/geometry/line_buffer.hpp>
 #include <llmr/geometry/elements_buffer.hpp>
 #include <llmr/geometry/geometry.hpp>
 
@@ -18,17 +17,17 @@ struct geometry_too_long_exception : std::exception {};
 
 using namespace llmr;
 
-LineBucket::LineBucket(const std::shared_ptr<LineVertexBuffer>& vertexBuffer,
-                       const std::shared_ptr<TriangleElementsBuffer>& triangleElementsBuffer,
-                       const std::shared_ptr<PointElementsBuffer>& pointElementsBuffer,
+LineBucket::LineBucket(LineVertexBuffer& vertexBuffer,
+                       TriangleElementsBuffer& triangleElementsBuffer,
+                       PointElementsBuffer& pointElementsBuffer,
                        const BucketDescription& bucket_desc)
     : geometry(bucket_desc.geometry),
       vertexBuffer(vertexBuffer),
       triangleElementsBuffer(triangleElementsBuffer),
       pointElementsBuffer(pointElementsBuffer),
-      vertex_start(vertexBuffer->index()),
-      triangle_elements_start(triangleElementsBuffer->index()),
-      point_elements_start(pointElementsBuffer->index())
+      vertex_start(vertexBuffer.index()),
+      triangle_elements_start(triangleElementsBuffer.index()),
+      point_elements_start(pointElementsBuffer.index())
 {
 }
 
@@ -101,7 +100,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
         nextNormal = util::normal<double>(currentVertex, lastVertex);
     }
 
-    int32_t start_vertex = (int32_t)vertexBuffer->index();
+    int32_t start_vertex = (int32_t)vertexBuffer.index();
 
     std::vector<TriangleElement> triangle_store;
     std::vector<PointElement> point_store;
@@ -172,7 +171,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
         // Add offset square begin cap.
         if (!prevVertex && beginCap == CapType::Square) {
             // Add first vertex
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    flip * (prevNormal.x + prevNormal.y), flip * (-prevNormal.x + prevNormal.y), // extrude normal
                                    0, 0, distance) - start_vertex; // texture normal
 
@@ -180,7 +179,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
             e1 = e2; e2 = e3;
 
             // Add second vertex
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    flip * (prevNormal.x - prevNormal.y), flip * (prevNormal.x + prevNormal.y), // extrude normal
                                    0, 1, distance) - start_vertex; // texture normal
 
@@ -191,7 +190,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
         // Add offset square end cap.
         else if (!nextVertex && endCap == CapType::Square) {
             // Add first vertex
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    nextNormal.x - flip * nextNormal.y, flip * nextNormal.x + nextNormal.y, // extrude normal
                                    0, 0, distance) - start_vertex; // texture normal
 
@@ -199,7 +198,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
             e1 = e2; e2 = e3;
 
             // Add second vertex
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    nextNormal.x + flip * nextNormal.y, -flip * nextNormal.x + nextNormal.y, // extrude normal
                                    0, 1, distance) - start_vertex; // texture normal
 
@@ -225,7 +224,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
             }
 
             // Add first vertex
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    flip * joinNormal.x, flip * joinNormal.y, // extrude normal
                                    0, 0, distance) - start_vertex; // texture normal
 
@@ -233,7 +232,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
             e1 = e2; e2 = e3;
 
             // Add second vertex
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    -flip * joinNormal.x, -flip * joinNormal.y, // extrude normal
                                    0, 1, distance) - start_vertex; // texture normal
 
@@ -249,7 +248,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
         else {
             // Close up the previous line
             // Add first vertex
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    flip * prevNormal.y, -flip * prevNormal.x, // extrude normal
                                    0, 0, distance) - start_vertex; // texture normal
 
@@ -257,7 +256,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
             e1 = e2; e2 = e3;
 
             // Add second vertex.
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    -flip * prevNormal.y, flip * prevNormal.x, // extrude normal
                                    0, 1, distance) - start_vertex; // texture normal
 
@@ -287,7 +286,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
 
             // Start the new quad.
             // Add first vertex
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    -flip * nextNormal.y, flip * nextNormal.x, // extrude normal
                                    0, 0, distance) - start_vertex; // texture normal
 
@@ -295,7 +294,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
             e1 = e2; e2 = e3;
 
             // Add second vertex
-            e3 = (int32_t)vertexBuffer->add(currentVertex.x, currentVertex.y, // vertex pos
+            e3 = (int32_t)vertexBuffer.add(currentVertex.x, currentVertex.y, // vertex pos
                                    flip * nextNormal.y, -flip * nextNormal.x, // extrude normal
                                    0, 1, distance) - start_vertex; // texture normal
 
@@ -304,7 +303,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
         }
     }
 
-    size_t end_vertex = vertexBuffer->index();
+    size_t end_vertex = vertexBuffer.index();
     size_t vertex_count = end_vertex - start_vertex;
 
     // Store the triangle/line groups.
@@ -316,7 +315,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
 
         triangle_group_type& group = triangleGroups.back();
         for (const TriangleElement& triangle : triangle_store) {
-            triangleElementsBuffer->add(
+            triangleElementsBuffer.add(
                 group.vertex_length + triangle.a,
                 group.vertex_length + triangle.b,
                 group.vertex_length + triangle.c
@@ -336,7 +335,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
 
         point_group_type& group = pointGroups.back();
         for (PointElement point : point_store) {
-            pointElementsBuffer->add(group.vertex_length + point);
+            pointElementsBuffer.add(group.vertex_length + point);
         }
 
         group.vertex_length += vertex_count;
@@ -357,23 +356,23 @@ bool LineBucket::hasPoints() const {
 }
 
 void LineBucket::drawLines(LineShader& shader) {
-    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer->itemSize);
-    char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer->itemSize);
+    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
+    char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
     for (triangle_group_type& group : triangleGroups) {
-        group.array.bind(shader, *vertexBuffer, *triangleElementsBuffer, vertex_index);
+        group.array.bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
         glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
-        vertex_index += group.vertex_length * vertexBuffer->itemSize;
-        elements_index += group.elements_length * triangleElementsBuffer->itemSize;
+        vertex_index += group.vertex_length * vertexBuffer.itemSize;
+        elements_index += group.elements_length * triangleElementsBuffer.itemSize;
     }
 }
 
 void LineBucket::drawPoints(LinejoinShader& shader) {
-    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer->itemSize);
-    char *elements_index = BUFFER_OFFSET(point_elements_start * pointElementsBuffer->itemSize);
+    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
+    char *elements_index = BUFFER_OFFSET(point_elements_start * pointElementsBuffer.itemSize);
     for (point_group_type& group : pointGroups) {
-        group.array.bind(shader, *vertexBuffer, *pointElementsBuffer, vertex_index);
+        group.array.bind(shader, vertexBuffer, pointElementsBuffer, vertex_index);
         glDrawElements(GL_POINTS, group.elements_length, GL_UNSIGNED_SHORT, elements_index);
-        vertex_index += group.vertex_length * vertexBuffer->itemSize;
-        elements_index += group.elements_length * pointElementsBuffer->itemSize;
+        vertex_index += group.vertex_length * vertexBuffer.itemSize;
+        elements_index += group.elements_length * pointElementsBuffer.itemSize;
     }
 }
diff --git a/src/renderer/point_bucket.cpp b/src/renderer/point_bucket.cpp
index 04e9fbe9d..53e9566d0 100644
--- a/src/renderer/point_bucket.cpp
+++ b/src/renderer/point_bucket.cpp
@@ -15,11 +15,11 @@ struct geometry_too_long_exception : std::exception {};
 
 using namespace llmr;
 
-PointBucket::PointBucket(const std::shared_ptr<PointVertexBuffer>& vertexBuffer,
+PointBucket::PointBucket(PointVertexBuffer& vertexBuffer,
                          const BucketDescription& bucket_desc)
     : geometry(bucket_desc.geometry),
       vertexBuffer(vertexBuffer),
-      vertex_start(vertexBuffer->index()) {
+      vertex_start(vertexBuffer.index()) {
 }
 
 void PointBucket::addGeometry(pbf& geom) {
@@ -28,13 +28,13 @@ void PointBucket::addGeometry(pbf& geom) {
     int32_t x, y;
     while ((cmd = geometry.next(x, y)) != Geometry::end) {
         if (cmd == Geometry::move_to) {
-            vertexBuffer->add(x, y);
+            vertexBuffer.add(x, y);
         } else {
             fprintf(stderr, "other command than move_to in point geometry\n");
         }
     }
 
-    vertex_end = vertexBuffer->index();
+    vertex_end = vertexBuffer.index();
 }
 
 void PointBucket::render(Painter& painter, const std::string& layer_name, const Tile::ID& id) {
@@ -46,7 +46,7 @@ bool PointBucket::hasPoints() const {
 }
 
 void PointBucket::drawPoints(PointShader& shader) {
-    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer->itemSize);
-    array.bind(shader, *vertexBuffer, vertex_index);
+    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
+    array.bind(shader, vertexBuffer, vertex_index);
     glDrawArrays(GL_POINTS, 0, (GLsizei)(vertex_end - vertex_start));
 }
diff --git a/src/renderer/text_bucket.cpp b/src/renderer/text_bucket.cpp
index d515a4a2b..a2a88e9a7 100644
--- a/src/renderer/text_bucket.cpp
+++ b/src/renderer/text_bucket.cpp
@@ -21,15 +21,15 @@
 using namespace llmr;
 
 TextBucket::TextBucket(
-    const std::shared_ptr<TextVertexBuffer> &vertexBuffer,
-    const std::shared_ptr<TriangleElementsBuffer> &triangleElementsBuffer,
+    TextVertexBuffer &vertexBuffer,
+    TriangleElementsBuffer &triangleElementsBuffer,
     const BucketDescription &bucket_desc, Placement &placement)
     : geom_desc(bucket_desc.geometry),
       vertexBuffer(vertexBuffer),
       triangleElementsBuffer(triangleElementsBuffer),
       placement(placement),
-      vertex_start(vertexBuffer->index()),
-      triangle_elements_start(triangleElementsBuffer->index()) {}
+      vertex_start(vertexBuffer.index()),
+      triangle_elements_start(triangleElementsBuffer.index()) {}
 
 void TextBucket::addGlyphs(const PlacedGlyphs &glyphs, float placementZoom,
                            PlacementRange placementRange, float zoom) {
@@ -77,24 +77,24 @@ void TextBucket::addGlyphs(const PlacedGlyphs &glyphs, float placementZoom,
         uint32_t triangleIndex = triangleGroup.vertex_length;
 
         // coordinates (2 triangles)
-        vertexBuffer->add(glyphAnchor.x, glyphAnchor.y, tl.x, tl.y, tex.x,
+        vertexBuffer.add(glyphAnchor.x, glyphAnchor.y, tl.x, tl.y, tex.x,
                           tex.y, angle, minZoom, placementRange, maxZoom,
                           placementZoom);
-        vertexBuffer->add(glyphAnchor.x, glyphAnchor.y, tr.x, tr.y,
+        vertexBuffer.add(glyphAnchor.x, glyphAnchor.y, tr.x, tr.y,
                           tex.x + width, tex.y, angle, minZoom, placementRange,
                           maxZoom, placementZoom);
-        vertexBuffer->add(glyphAnchor.x, glyphAnchor.y, bl.x, bl.y, tex.x,
+        vertexBuffer.add(glyphAnchor.x, glyphAnchor.y, bl.x, bl.y, tex.x,
                           tex.y + height, angle, minZoom, placementRange,
                           maxZoom, placementZoom);
-        vertexBuffer->add(glyphAnchor.x, glyphAnchor.y, br.x, br.y,
+        vertexBuffer.add(glyphAnchor.x, glyphAnchor.y, br.x, br.y,
                           tex.x + width, tex.y + height, angle, minZoom,
                           placementRange, maxZoom, placementZoom);
 
         // add the two triangles, referencing the four coordinates we just
         // inserted.
-        triangleElementsBuffer->add(triangleIndex + 0, triangleIndex + 1,
+        triangleElementsBuffer.add(triangleIndex + 0, triangleIndex + 1,
                                     triangleIndex + 2);
-        triangleElementsBuffer->add(triangleIndex + 1, triangleIndex + 2,
+        triangleElementsBuffer.add(triangleIndex + 1, triangleIndex + 2,
                                     triangleIndex + 3);
 
         triangleGroup.vertex_length += glyph_vertex_length;
@@ -151,13 +151,13 @@ void TextBucket::render(Painter &painter, const std::string &layer_name,
 bool TextBucket::empty() const { return triangleGroups.empty(); }
 
 void TextBucket::drawGlyphs(TextShader &shader) {
-    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer->itemSize);
+    char *vertex_index = BUFFER_OFFSET(vertex_start * vertexBuffer.itemSize);
     char *elements_index =
-        BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer->itemSize);
+        BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
     for (triangle_group_type &group : triangleGroups) {
-        group.array.bind(shader, *vertexBuffer, *triangleElementsBuffer, vertex_index);
+        group.array.bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
         glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
-        vertex_index += group.vertex_length * vertexBuffer->itemSize;
-        elements_index += group.elements_length * triangleElementsBuffer->itemSize;
+        vertex_index += group.vertex_length * vertexBuffer.itemSize;
+        elements_index += group.elements_length * triangleElementsBuffer.itemSize;
     }
 }