diff --git a/include/mbgl/map/raster_tile_data.hpp b/include/mbgl/map/raster_tile_data.hpp
index bf8691454..76b7eee2c 100644
--- a/include/mbgl/map/raster_tile_data.hpp
+++ b/include/mbgl/map/raster_tile_data.hpp
@@ -26,6 +26,7 @@ public:
     virtual bool hasData(std::shared_ptr<StyleLayer> layer_desc) const;
 
 protected:
+    StyleBucketRaster properties;
     RasterBucket bucket;
 };
 
diff --git a/include/mbgl/map/tile_parser.hpp b/include/mbgl/map/tile_parser.hpp
index 313431c86..1b0a8bfe6 100644
--- a/include/mbgl/map/tile_parser.hpp
+++ b/include/mbgl/map/tile_parser.hpp
@@ -14,6 +14,7 @@
 namespace mbgl {
 
 class Bucket;
+class Texturepool;
 class FontStack;
 class GlyphAtlas;
 class GlyphStore;
@@ -36,6 +37,7 @@ public:
                const std::shared_ptr<GlyphStore> &glyphStore,
                const std::shared_ptr<SpriteAtlas> &spriteAtlas,
                const std::shared_ptr<Sprite> &sprite);
+               const std::shared_ptr<Texturepool> &texturepool);
 
 public:
     void parse();
@@ -46,7 +48,7 @@ private:
     std::unique_ptr<Bucket> createBucket(std::shared_ptr<StyleBucket> bucket_desc);
 
     std::unique_ptr<Bucket> createFillBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketFill &fill);
-    std::unique_ptr<Bucket> createRasterBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketRaster &raster);
+    std::unique_ptr<Bucket> createRasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster &raster);
     std::unique_ptr<Bucket> createLineBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketLine &line);
     std::unique_ptr<Bucket> createSymbolBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketSymbol &symbol);
 
@@ -62,6 +64,7 @@ private:
     std::shared_ptr<GlyphStore> glyphStore;
     std::shared_ptr<SpriteAtlas> spriteAtlas;
     std::shared_ptr<Sprite> sprite;
+    std::shared_ptr<Texturepool> texturePool;
 
     Collision collision;
 };
diff --git a/include/mbgl/renderer/bucket.hpp b/include/mbgl/renderer/bucket.hpp
index 18f58ee46..a8bd437bb 100644
--- a/include/mbgl/renderer/bucket.hpp
+++ b/include/mbgl/renderer/bucket.hpp
@@ -5,7 +5,6 @@
 #include <memory>
 #include <mbgl/map/tile.hpp>
 #include <mbgl/util/noncopyable.hpp>
-#include <mbgl/renderer/prerendered_texture.hpp>
 
 namespace mbgl {
 
@@ -18,7 +17,6 @@ public:
     virtual bool hasData() const = 0;
     virtual ~Bucket() {}
 
-    std::unique_ptr<PrerenderedTexture> prerendered;
 };
 
 }
diff --git a/include/mbgl/renderer/painter.hpp b/include/mbgl/renderer/painter.hpp
index 82b71b6cb..fa981c3c2 100644
--- a/include/mbgl/renderer/painter.hpp
+++ b/include/mbgl/renderer/painter.hpp
@@ -40,7 +40,8 @@ class FillBucket;
 class LineBucket;
 class SymbolBucket;
 class RasterBucket;
-
+class PrerenderedTexture;
+    
 struct FillProperties;
 struct CompositeProperties;
 
@@ -84,15 +85,13 @@ public:
     void renderLine(LineBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
     void renderSymbol(SymbolBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
     void renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
-    void renderRaster(GLuint texture, const RasterizeProperties &properties); // do I want to save that?
 
-    void preparePrerender(PrerenderedTexture &texture);
-    void finishPrerender(PrerenderedTexture &texture);
+    void preparePrerender(RasterBucket &bucket);
+    void finishPrerender(RasterBucket &bucket);
 
-    template <typename Properties>
-    void renderPrerenderedTexture(PrerenderedTexture &texture, const Properties &properties);
+    void renderPrerenderedTexture(RasterBucket &bucket);
     
-    void createPrerendered(RasterBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const RasterizeProperties& properties);
+    void createPrerendered(RasterBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
 
     void resize();
 
diff --git a/include/mbgl/renderer/prerendered_texture.hpp b/include/mbgl/renderer/prerendered_texture.hpp
index 310375b5e..4a5b736d4 100644
--- a/include/mbgl/renderer/prerendered_texture.hpp
+++ b/include/mbgl/renderer/prerendered_texture.hpp
@@ -3,16 +3,15 @@
 
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/platform/gl.hpp>
-#include <mbgl/style/rasterize_properties.hpp>
-//#include <mbgl/renderer/raster_bucket.hpp>
 
 namespace mbgl {
 
+class StyleBucketRaster;
 class Painter;
 
 class PrerenderedTexture : private util::noncopyable {
 public:
-    PrerenderedTexture(const RasterBucket &properties);
+    PrerenderedTexture(const StyleBucketRaster &properties);
     ~PrerenderedTexture();
 
     void bindTexture();
@@ -24,7 +23,7 @@ public:
     void blur(Painter& painter, uint16_t passes);
 
 public:
-    const RasterBucket properties;
+    const StyleBucketRaster &properties;
 
 private:
     GLint previous_fbo = 0;
diff --git a/include/mbgl/renderer/raster_bucket.hpp b/include/mbgl/renderer/raster_bucket.hpp
index c11119312..631fb3471 100644
--- a/include/mbgl/renderer/raster_bucket.hpp
+++ b/include/mbgl/renderer/raster_bucket.hpp
@@ -3,6 +3,10 @@
 
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/util/raster.hpp>
+#include <mbgl/renderer/prerendered_texture.hpp>
+#include <mbgl/style/style_bucket.hpp>
+
+
 
 namespace mbgl {
 
@@ -12,12 +16,15 @@ class VertexArrayObject;
 
 class RasterBucket : public Bucket {
 public:
-    RasterBucket(const std::shared_ptr<Texturepool> &texturepool);
-
+    RasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster& properties);
+    
     virtual void render(Painter& painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
     virtual bool hasData() const;
 
     bool setImage(const std::string &data);
+    
+    const StyleBucketRaster &properties;
+    PrerenderedTexture texture;
 
     void drawRaster(RasterShader& shader, VertexBuffer &vertices, VertexArrayObject &array);
 
diff --git a/include/mbgl/style/rasterize_properties.hpp b/include/mbgl/style/rasterize_properties.hpp
deleted file mode 100644
index e156ede77..000000000
--- a/include/mbgl/style/rasterize_properties.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef MBGL_STYLE_RASTERIZE_PROPERTIES
-#define MBGL_STYLE_RASTERIZE_PROPERTIES
-
-#include <mbgl/style/function_properties.hpp>
-
-namespace mbgl {
-
-// The calculated properties for a layer in a tile.
-class RasterizedProperties {
-public:
-    float buffer = 1.0f / 32.0f;
-    uint16_t size = 256;
-    uint8_t blur = 0;
-};
-
-class RasterizeProperties {
-public:
-    Function<bool> enabled = ConstantFunction<bool>(false);                                 // maybe delete?
-    Function<float> buffer = ConstantFunction<float>(1.0f / 32.0f);
-    Function<float> size = ConstantFunction<float>(256);
-    Function<float> blur = ConstantFunction<float>(0);
-
-//    inline bool isEnabled(const int8_t z) const {
-//        return util::apply_visitor(FunctionEvaluator<bool>(z), enabled);
-//    }
-
-    inline RasterizedProperties get(const int8_t z) const {
-        RasterizedProperties properties;
-        properties.buffer = util::apply_visitor(FunctionEvaluator<float>(z), buffer);
-        properties.size = util::apply_visitor(FunctionEvaluator<float>(z), size);
-        properties.blur = util::apply_visitor(FunctionEvaluator<float>(z), blur);
-        return properties;
-    }
-};
-
-}
-
-#endif
diff --git a/include/mbgl/style/style_bucket.hpp b/include/mbgl/style/style_bucket.hpp
index 5cb1b6931..11b87d849 100644
--- a/include/mbgl/style/style_bucket.hpp
+++ b/include/mbgl/style/style_bucket.hpp
@@ -83,7 +83,7 @@ public:
 class StyleBucketRaster {
 public:
     bool prerendered = false;
-    uint16_t raster_size = 256;
+    uint16_t size = 256;
     float blur = 0.0f;
     float buffer = 0.03125f;
 };
diff --git a/include/mbgl/style/style_layer.hpp b/include/mbgl/style/style_layer.hpp
index bcda9950a..f8cfff7f6 100644
--- a/include/mbgl/style/style_layer.hpp
+++ b/include/mbgl/style/style_layer.hpp
@@ -4,7 +4,6 @@
 #include <mbgl/style/class_dictionary.hpp>
 #include <mbgl/style/class_properties.hpp>
 #include <mbgl/style/style_properties.hpp>
-#include <mbgl/style/rasterize_properties.hpp>
 #include <mbgl/style/applied_class_properties.hpp>
 
 #include <vector>
@@ -79,11 +78,6 @@ public:
     // layer's type.
     StyleProperties properties;
 
-    // Rasterization properties are used for prerendering the tile to a bitmap,
-    // which is then used as a raster image instead of rendering this layer
-    // directly in every frame.
-//    const std::unique_ptr<const RasterizeProperties> rasterize;
-
     // Child layer array (if this layer has child layers).
     std::shared_ptr<StyleLayerGroup> layers;
 };
diff --git a/include/mbgl/style/style_parser.hpp b/include/mbgl/style/style_parser.hpp
index 8b8dc74f2..e4e1b7f63 100644
--- a/include/mbgl/style/style_parser.hpp
+++ b/include/mbgl/style/style_parser.hpp
@@ -6,7 +6,6 @@
 #include <mbgl/style/style_source.hpp>
 #include <mbgl/style/filter_expression.hpp>
 #include <mbgl/style/class_properties.hpp>
-#include <mbgl/style/rasterize_properties.hpp>
 #include <mbgl/style/style_bucket.hpp>
 
 #include <unordered_map>
@@ -52,7 +51,6 @@ private:
     void parseLayer(std::pair<JSVal, std::shared_ptr<StyleLayer>> &pair);
     void parseStyles(JSVal value, std::map<ClassID, ClassProperties> &styles);
     void parseStyle(JSVal, ClassProperties &properties);
-    std::unique_ptr<RasterizeProperties> parseRasterize(JSVal value);
     void parseReference(JSVal value, std::shared_ptr<StyleLayer> &layer);
     void parseBucket(JSVal value, std::shared_ptr<StyleLayer> &layer);
     void parseRender(JSVal value, std::shared_ptr<StyleLayer> &layer);
diff --git a/src/map/map.cpp b/src/map/map.cpp
index a6e245376..3a143bc5b 100644
--- a/src/map/map.cpp
+++ b/src/map/map.cpp
@@ -649,63 +649,29 @@ void Map::renderLayers(std::shared_ptr<StyleLayerGroup> group) {
 }
 
 void Map::renderLayer(std::shared_ptr<StyleLayer> layer_desc, RenderPass pass) {
-    if (layer_desc->layers) {
-        if (layer_desc->type == StyleLayerType::Raster) {
-            const RasterProperties &properties = layer_desc->getProperties<RasterProperties>();
-            
-//            const RasterizedProperties rasterize = layer_desc->getProperties<RasterProperties>();
-//            
-//            auto prerendered = std::make_unique<PrerenderedTexture>(rasterize);
-//            prerendered->bindFramebuffer();
-//            
-//            painter.preparePrerender(*prerendered);
-//            
-//            const int buffer = rasterize.buffer * 4096.0f;
-//            const mat4 vtxMatrix = [&]{
-//                mat4 vtxMatrix;
-//                matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
-//                matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
-//                return vtxMatrix;
-//            }();
-//            
-//            painter.setOpaque();
-//            renderLayers(layer_desc->layers);
-//            painter.setTranslucent();
-//            renderLayers(layer_desc->layers);
-//            
-//            if (rasterize.blur > 0) {
-//                prerendered->blur(painter, rasterize.blur);
-//            }
-//            
-//            prerendered->unbindFramebuffer();
-//            painter.finishPrerender(*prerendered);
-//            
-//            painter.renderPrerenderedTexture(*prerendered, rasterize);
-            
-        } else {
-            // This is a layer group. We render them during our translucent render pass.
-            if (pass == Translucent) {
-                const CompositeProperties &properties = layer_desc->getProperties<CompositeProperties>();
-                if (properties.isVisible()) {
-                    gl::group group(std::string("group: ") + layer_desc->id);
+    if (layer_desc->layers && layer_desc->type != StyleLayerType::Raster) {
+        // This is a layer group. We render them during our translucent render pass.
+        if (pass == Translucent) {
+            const CompositeProperties &properties = layer_desc->getProperties<CompositeProperties>();
+            if (properties.isVisible()) {
+                gl::group group(std::string("group: ") + layer_desc->id);
 
-                    if (debug::renderTree) {
-                        std::cout << std::string(indent++ * 4, ' ') << "+ " << layer_desc->id
-                                  << " (Composite) {" << std::endl;
-                    }
+                if (debug::renderTree) {
+                    std::cout << std::string(indent++ * 4, ' ') << "+ " << layer_desc->id
+                              << " (Composite) {" << std::endl;
+                }
 
-                    painter.pushFramebuffer();
+                painter.pushFramebuffer();
 
-                    renderLayers(layer_desc->layers);
+                renderLayers(layer_desc->layers);
 
-                    GLuint texture = painter.popFramebuffer();
+                GLuint texture = painter.popFramebuffer();
 
-                    // Render the previous texture onto the screen.
-                    painter.drawComposite(texture, properties);
+                // Render the previous texture onto the screen.
+                painter.drawComposite(texture, properties);
 
-                    if (debug::renderTree) {
-                        std::cout << std::string(--indent * 4, ' ') << "}" << std::endl;
-                    }
+                if (debug::renderTree) {
+                    std::cout << std::string(--indent * 4, ' ') << "}" << std::endl;
                 }
             }
         }
diff --git a/src/map/raster_tile_data.cpp b/src/map/raster_tile_data.cpp
index a3c6d21a6..a401fdc4d 100644
--- a/src/map/raster_tile_data.cpp
+++ b/src/map/raster_tile_data.cpp
@@ -7,7 +7,7 @@ using namespace mbgl;
 
 RasterTileData::RasterTileData(Tile::ID id, Map &map, const SourceInfo &source)
     : TileData(id, map, source),
-    bucket(map.getTexturepool()) {
+    bucket(map.getTexturepool(), properties) {
 }
 
 RasterTileData::~RasterTileData() {
diff --git a/src/map/tile_parser.cpp b/src/map/tile_parser.cpp
index ae129b3e7..8b8c0ec2d 100644
--- a/src/map/tile_parser.cpp
+++ b/src/map/tile_parser.cpp
@@ -14,6 +14,7 @@
 #include <mbgl/geometry/glyph_atlas.hpp>
 #include <mbgl/text/glyph_store.hpp>
 #include <mbgl/text/glyph.hpp>
+#include <mbgl/map/map.hpp>
 
 #include <mbgl/util/std.hpp>
 #include <mbgl/util/utf.hpp>
@@ -44,6 +45,7 @@ TileParser::TileParser(const std::string &data, VectorTileData &tile,
       spriteAtlas(spriteAtlas),
       sprite(sprite),
       collision(tile.id.z, 4096, tile.source.tile_size, tile.depth) {
+//      placement(tile.id.z, tile.id.z >= tile.source.max_zoom ? tile.source.max_zoom - tile.id.z : 1) {                // TODO : i'm guessing remove this in the rebase?
 }
 
 void TileParser::parse() {
@@ -116,7 +118,7 @@ std::unique_ptr<Bucket> TileParser::createBucket(std::shared_ptr<StyleBucket> bu
         }
     } else if (bucket_desc->render.is<StyleBucketRaster>()) {
         // Assume this is a prerendered raster layer -- TODO more thorough checking here??
-        return createRasterBucket(layer, bucket_desc->filter, bucket_desc->render.get<StyleBucketRaster>());
+        return createRasterBucket(texturePool, bucket_desc->render.get<StyleBucketRaster>());
     } else {
         // The layer specified in the bucket does not exist. Do nothing.
         if (debug::tileParseWarnings) {
@@ -152,9 +154,8 @@ std::unique_ptr<Bucket> TileParser::createFillBucket(const VectorTileLayer& laye
     return obsolete() ? nullptr : std::move(bucket);
 }
 
-std::unique_ptr<Bucket> TileParser::createRasterBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketRaster &raster) {
-    std::unique_ptr<RasterBucket> bucket = std::make_unique<RasterBucket>(raster);
-//    addBucketFeatures(bucket, layer, filter);
+std::unique_ptr<Bucket> TileParser::createRasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster &raster) {
+    std::unique_ptr<RasterBucket> bucket = std::make_unique<RasterBucket>(texturepool, raster);
     return obsolete() ? nullptr : std::move(bucket);
 }
 
diff --git a/src/map/vector_tile_data.cpp b/src/map/vector_tile_data.cpp
index f4a841b3f..2bf339b65 100644
--- a/src/map/vector_tile_data.cpp
+++ b/src/map/vector_tile_data.cpp
@@ -58,9 +58,6 @@ void VectorTileData::render(Painter &painter, std::shared_ptr<StyleLayer> layer_
         if (databucket_it != buckets.end()) {
             assert(databucket_it->second);
             databucket_it->second->render(painter, layer_desc, id);
-        } else if (layer_desc->type == StyleLayerType::Raster && layer_desc->layers) {
-//            HELP
-
         }
     }
 }
diff --git a/src/renderer/painter_fill.cpp b/src/renderer/painter_fill.cpp
index 750aaa465..d0bfcad83 100644
--- a/src/renderer/painter_fill.cpp
+++ b/src/renderer/painter_fill.cpp
@@ -150,54 +150,6 @@ void Painter::renderFill(FillBucket& bucket, std::shared_ptr<StyleLayer> layer_d
     // Abort early.
     if (!bucket.hasData()) return;
     const FillProperties &properties = layer_desc->getProperties<FillProperties>();
-
-//    if (layer_desc->rasterize && layer_desc->rasterize->isEnabled(id.z)) {
-//        if (pass == Translucent) {
-//            const RasterizedProperties rasterize = layer_desc->rasterize->get(id.z);
-//            // Buffer value around the 0..4096 extent that will be drawn into the 256x256 pixel
-//            // texture. We later scale the texture so that the actual bounds will align with this
-//            // tile's bounds. The reason we do this is so that the
-//            if (!bucket.prerendered) {
-//                bucket.prerendered = std::make_unique<PrerenderedTexture>(rasterize);
-//                bucket.prerendered->bindFramebuffer();
-//
-//                preparePrerender(*bucket.prerendered);
-//
-//                const FillProperties modifiedProperties = [&]{
-//                    FillProperties modifiedProperties = properties;
-//                    modifiedProperties.opacity = 1;
-//                    return modifiedProperties;
-//                }();
-//
-//                // When drawing the fill, we want to draw a buffer around too, so we
-//                // essentially downscale everyting, and then upscale it later when rendering.
-//                const int buffer = rasterize.buffer * 4096.0f;
-//                const mat4 vtxMatrix = [&]{
-//                    mat4 vtxMatrix;
-//                    matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
-//                    matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
-//                    return vtxMatrix;
-//                }();
-//
-//                setOpaque();
-//                renderFill(bucket, modifiedProperties, id, vtxMatrix);
-//
-//                setTranslucent();
-//                renderFill(bucket, modifiedProperties, id, vtxMatrix);
-//
-//                if (rasterize.blur > 0) {
-//                    bucket.prerendered->blur(*this, rasterize.blur);
-//                }
-//
-//                // RESET STATE
-//                bucket.prerendered->unbindFramebuffer();
-//                finishPrerender(*bucket.prerendered);
-//            }
-//
-//            renderPrerenderedTexture(*bucket.prerendered, properties);
-//        }
-//    } else {
-        const mat4 &vtxMatrix = translatedMatrix(properties.translate, id, properties.translateAnchor);
-        renderFill(bucket, properties, id, vtxMatrix);
-//    }
+    const mat4 &vtxMatrix = translatedMatrix(properties.translate, id, properties.translateAnchor);
+    renderFill(bucket, properties, id, vtxMatrix);
 }
diff --git a/src/renderer/painter_prerender.cpp b/src/renderer/painter_prerender.cpp
index 94ccc7fc4..1e1137855 100644
--- a/src/renderer/painter_prerender.cpp
+++ b/src/renderer/painter_prerender.cpp
@@ -1,9 +1,11 @@
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/style/style_properties.hpp>
+#include <mbgl/renderer/prerendered_texture.hpp>
+#include <mbgl/renderer/raster_bucket.hpp>
 
 using namespace mbgl;
 
-void Painter::preparePrerender(PrerenderedTexture &texture) {
+void Painter::preparePrerender(RasterBucket &bucket) {
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_STENCIL_TEST);
 
@@ -14,19 +16,18 @@ void Painter::preparePrerender(PrerenderedTexture &texture) {
 #endif
     glClear(GL_COLOR_BUFFER_BIT);
 
-    glViewport(0, 0, texture.properties.size, texture.properties.size);
+    glViewport(0, 0, bucket.properties.size, bucket.properties.size);
 }
 
-void Painter::finishPrerender(PrerenderedTexture &/*texture*/) {
+void Painter::finishPrerender(RasterBucket &bucket) {
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_STENCIL_TEST);
 
     glViewport(0, 0, gl_viewport[0], gl_viewport[1]);
 }
 
-template <typename Properties>
-void Painter::renderPrerenderedTexture(PrerenderedTexture &texture, const Properties &properties) {
-    const int buffer = texture.properties.buffer * 4096.0f;
+void Painter::renderPrerenderedTexture(RasterBucket &bucket) {
+    const int buffer = bucket.properties.buffer * 4096.0f;
     
     // draw the texture on a quad
     useProgram(rasterShader->program);
@@ -39,11 +40,8 @@ void Painter::renderPrerenderedTexture(PrerenderedTexture &texture, const Proper
     rasterShader->setImage(0);
     rasterShader->setBuffer(buffer);
     rasterShader->setOpacity(1);
-//    rasterShader->setOpacity(properties.opacity);             // TODO find a place to pass opacity and change this back
-    texture.bindTexture();
+//    rasterShader->setOpacity(bucket.properties.opacity);             // TODO find a place to pass opacity and change this back
+    bucket.texture.bindTexture();
     coveringRasterArray.bind(*rasterShader, tileStencilBuffer, BUFFER_OFFSET(0));
     glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index());
 }
-
-template void Painter::renderPrerenderedTexture(PrerenderedTexture &, const FillProperties &);
-template void Painter::renderPrerenderedTexture(PrerenderedTexture &, const RasterizedProperties &);
diff --git a/src/renderer/painter_raster.cpp b/src/renderer/painter_raster.cpp
index ea0688ced..a1dc969b8 100644
--- a/src/renderer/painter_raster.cpp
+++ b/src/renderer/painter_raster.cpp
@@ -11,81 +11,37 @@ void Painter::renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> lay
     
     const RasterProperties &properties = layer_desc->getProperties<RasterProperties>();
     
-    if (layer_desc->rasterize) {
-        auto rasterize = std::make_unique<RasterizeProperties>();
+    if (layer_desc->layers) {
+
+        bucket.texture.bindFramebuffer();
         
-        if (pass == Translucent) {
-            // Buffer value around the 0..4096 extent that will be drawn into the 256x256 pixel
-            // texture. We later scale the texture so that the actual bounds will align with this
-            // tile's bounds. The reason we do this is so that the
-            const RasterizedProperties rasterize = layer_desc->rasterize->get(id.z);
-            if (!bucket.prerendered) {
-                
-                bucket.prerendered = std::make_unique<PrerenderedTexture>(rasterize);
-                bucket.prerendered->bindFramebuffer();
-                
-                preparePrerender(*bucket.prerendered);
-                
-                const RasterProperties modifiedProperties = [&]{
-                    RasterProperties modifiedProperties = properties;
-                    //                modifiedProperties.opacity = 1;   // figure out why this was here
-                    return modifiedProperties;
-                }();
-                
-                // When drawing the fill, we want to draw a buffer around too, so we
-                // essentially downscale everyting, and then upscale it later when rendering.
-                const int buffer = rasterize.buffer * 4096.0f;
-                const mat4 vtxMatrix = [&]{
-                    mat4 vtxMatrix;
-                    matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
-                    matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
-                    return vtxMatrix;
-                }();
-                
-                setOpaque();
-                //                renderFill(bucket, modifiedProperties, id, vtxMatrix);
-                
-                
-                
-                //                resize();
-                
-                //                changeMatrix();
-                
-                //                map.updateRenderState();
-                
-                //                drawClippingMasks(getActiveSources());
-                
-                // Actually render the layers
-                map.renderLayers(layer_desc->layers);
-                
-                // Finalize the rendering, e.g. by calling debug render calls per tile.
-                // This guarantees that we have at least one function per tile called.
-                // When only rendering layers via the stylesheet, it's possible that we don't
-                // ever visit a tile during rendering.
-                //                for (const std::shared_ptr<StyleSource> &source : getActiveSources()) {
-                //                    source->source->finishRender(painter);
-                //                }
-                //
-                //                // Schedule another rerender when we definitely need a next frame.
-                //                if (transform.needsTransition() || style->hasTransitions()) {
-                //                    update();
-                //                }
-                
-                glFlush();
+        preparePrerender(bucket);
 
-                if (rasterize.blur > 0) {
-                    bucket.prerendered->blur(*this, rasterize.blur);
-                }
-                
-                // RESET STATE
-                bucket.prerendered->unbindFramebuffer();
-                finishPrerender(*bucket.prerendered);
-            }
-            
-            renderPrerenderedTexture(*bucket.prerendered, properties);
+        const RasterProperties modifiedProperties = [&]{
+            RasterProperties modifiedProperties = properties;
+            modifiedProperties.opacity = 1;   // figure out why this was here
+            return modifiedProperties;
+        }();
 
+        const int buffer = bucket.properties.buffer * 4096.0f;
+        
+        const mat4 vtxMatrix = [&]{
+            mat4 vtxMatrix;
+            matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
+            matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
+            return vtxMatrix;
+        }();
+
+        map.renderLayers(layer_desc->layers);
+
+        if (bucket.properties.blur > 0) {
+            bucket.texture.blur(*this, bucket.properties.blur);
         }
 
+        bucket.texture.unbindFramebuffer();
+        finishPrerender(bucket);
+        renderPrerenderedTexture(bucket);
+
     }
 
     depthMask(false);
@@ -94,7 +50,7 @@ void Painter::renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> lay
     rasterShader->setMatrix(matrix);
     rasterShader->setBuffer(0);
     rasterShader->setOpacity(1);
-    // rasterShader->setOpacity(properties.opacity * tile_data->raster->opacity);
+//    rasterShader->setOpacity(properties.opacity * tile_data->raster->opacity);        // TODO fix
 
     glDepthRange(strata + strata_epsilon, 1.0f);
     bucket.drawRaster(*rasterShader, tileStencilBuffer, coveringRasterArray);
@@ -102,7 +58,3 @@ void Painter::renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> lay
     depthMask(true);
 
 }
-void Painter::renderRaster(GLuint texture, const RasterizeProperties &properties){
-//    TODO do I need this?
-//    map.renderLayers(layer_desc->layers);
-}
diff --git a/src/renderer/prerendered_texture.cpp b/src/renderer/prerendered_texture.cpp
index 78bf2407f..59a854a0c 100644
--- a/src/renderer/prerendered_texture.cpp
+++ b/src/renderer/prerendered_texture.cpp
@@ -1,10 +1,11 @@
 #include <mbgl/renderer/prerendered_texture.hpp>
 
 #include <mbgl/renderer/painter.hpp>
+#include <mbgl/style/style_bucket.hpp>
 
 using namespace mbgl;
 
-PrerenderedTexture::PrerenderedTexture(const RasterizedProperties &properties)
+PrerenderedTexture::PrerenderedTexture(const StyleBucketRaster &properties)
     : properties(properties) {
 }
 
@@ -40,8 +41,7 @@ void PrerenderedTexture::bindFramebuffer() {
         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
-//        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);           // TODO change this back once i have non-zero size readings
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
         glBindTexture(GL_TEXTURE_2D, 0);
     }
 
diff --git a/src/renderer/raster_bucket.cpp b/src/renderer/raster_bucket.cpp
index 83289b370..dc9b13687 100644
--- a/src/renderer/raster_bucket.cpp
+++ b/src/renderer/raster_bucket.cpp
@@ -3,16 +3,12 @@
 
 using namespace mbgl;
 
-RasterBucket::RasterBucket(const std::shared_ptr<Texturepool> &texturepool)
-    : raster(texturepool) {
+RasterBucket::RasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster& properties)
+: properties(properties),
+  texture(properties),
+  raster(texturepool) {
 }
 
-//RasterBucket::RasterBucket(const StyleBucketRaster &properties)
-//    : properties(properties) {
-//}
-
-// TODO ^ Somehow overload with another constructor for prerender?
-
 void RasterBucket::render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID &id) {
     painter.renderRaster(*this, layer_desc, id);
 }
diff --git a/src/style/style_parser.cpp b/src/style/style_parser.cpp
index 60f2195f6..17c8fdf25 100644
--- a/src/style/style_parser.cpp
+++ b/src/style/style_parser.cpp
@@ -492,15 +492,8 @@ std::shared_ptr<StyleLayer> StyleParser::createLayer(JSVal value) {
         std::map<ClassID, ClassProperties> styles;
         parseStyles(value, styles);
 
-        // Parse Rasterization options, as they can't be inherited anyway.
-//        std::unique_ptr<const RasterizeProperties> rasterize;
-//        if (value.HasMember("rasterize")) {
-//            rasterize = parseRasterize(replaceConstant(value["rasterize"]));
-//        }
-
         std::shared_ptr<StyleLayer> layer = std::make_shared<StyleLayer>(
             layer_id, std::move(styles));
-//            layer_id, std::move(styles), std::move(rasterize));
 
         if (value.HasMember("layers")) {
             if (value.HasMember("type")) {
@@ -643,7 +636,7 @@ void StyleParser::parseStyle(JSVal value, ClassProperties &klass) {
     parseOptionalProperty<Function<float>>("composite-opacity", Key::CompositeOpacity, klass, value);
     parseOptionalProperty<PropertyTransition>("transition-composite-opacity", Key::CompositeOpacity, klass, value);
 
-//    TODO edit these:
+//    TODO edit these?:
     parseOptionalProperty<Function<float>>("raster-opacity", Key::RasterOpacity, klass, value);
     parseOptionalProperty<PropertyTransition>("transition-raster-opacity", Key::RasterOpacity, klass, value);
     parseOptionalProperty<Function<float>>("raster-spin", Key::RasterSpin, klass, value);
@@ -924,8 +917,7 @@ void StyleParser::parseRender(JSVal value, std::shared_ptr<StyleLayer> &layer) {
     case StyleLayerType::Raster: {
         StyleBucketRaster &render = bucket.render.get<StyleBucketRaster>();
         
-//        auto rasterize = std::make_unique<RasterizedProperties>();
-        parseRenderProperty(value, render.raster_size, "raster-size");
+        parseRenderProperty(value, render.size, "raster-size");
         parseRenderProperty(value, render.blur, "raster-blur");
         parseRenderProperty(value, render.buffer, "raster-buffer");
         if (layer->layers) {