diff --git a/CMakeLists.txt b/CMakeLists.txt
index e008db2117e..4c98a913c87 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -752,8 +752,6 @@ add_library(
     ${PROJECT_SOURCE_DIR}/src/mbgl/util/http_timeout.hpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/util/i18n.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/util/i18n.hpp
-    ${PROJECT_SOURCE_DIR}/src/mbgl/util/id.cpp
-    ${PROJECT_SOURCE_DIR}/src/mbgl/util/id.hpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/util/interpolate.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/util/intersection_tests.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/util/intersection_tests.hpp
diff --git a/src/mbgl/renderer/buckets/debug_bucket.cpp b/src/mbgl/renderer/buckets/debug_bucket.cpp
index 6b3ce87998f..fcdc727f4b8 100644
--- a/src/mbgl/renderer/buckets/debug_bucket.cpp
+++ b/src/mbgl/renderer/buckets/debug_bucket.cpp
@@ -20,7 +20,6 @@ DebugBucket::DebugBucket(const OverscaledTileID& id,
       modified(std::move(modified_)),
       expires(std::move(expires_)),
       debugMode(debugMode_) {
-
     auto addText = [&] (const std::string& text, double left, double baseline, double scale) {
         for (uint8_t c : text) {
             if (c < 32 || c >= 127)
diff --git a/src/mbgl/renderer/buckets/raster_bucket.cpp b/src/mbgl/renderer/buckets/raster_bucket.cpp
index d5663657ef6..859ee8d2a24 100644
--- a/src/mbgl/renderer/buckets/raster_bucket.cpp
+++ b/src/mbgl/renderer/buckets/raster_bucket.cpp
@@ -8,12 +8,9 @@ namespace mbgl {
 using namespace style;
 
 RasterBucket::RasterBucket(PremultipliedImage&& image_)
-    : image(std::make_shared<PremultipliedImage>(std::move(image_))){
-}
+    : image(std::make_shared<PremultipliedImage>(std::move(image_))) {}
 
-RasterBucket::RasterBucket(std::shared_ptr<PremultipliedImage> image_)
-    : image(std::move(image_)) {
-}
+RasterBucket::RasterBucket(std::shared_ptr<PremultipliedImage> image_) : image(std::move(image_)) {}
 
 RasterBucket::~RasterBucket() = default;
 
diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index 92c63dc8684..8995ae55ef7 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -7,7 +7,6 @@
 #include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/renderer/render_static_data.hpp>
 #include <mbgl/programs/programs.hpp>
-#include <mbgl/programs/background_program.hpp>
 #include <mbgl/util/tile_cover.hpp>
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/gfx/cull_face_mode.hpp>
@@ -18,28 +17,22 @@ using namespace style;
 
 namespace {
 
-inline const BackgroundLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
+inline const BackgroundLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
     assert(impl->getTypeInfo() == BackgroundLayer::Impl::staticTypeInfo());
     return static_cast<const style::BackgroundLayer::Impl&>(*impl);
 }
 
 } // namespace
 
-class RenderBackgroundLayer::Impl {
-public:
-    SegmentVector<BackgroundAttributes> segments;
-};
-
 RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl> _impl)
     : RenderLayer(makeMutable<BackgroundLayerProperties>(std::move(_impl))),
-      unevaluated(impl_cast(baseImpl).paint.untransitioned()),
-      impl(std::make_unique<Impl>()) {
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
 RenderBackgroundLayer::~RenderBackgroundLayer() = default;
 
 void RenderBackgroundLayer::transition(const TransitionParameters &parameters) {
-    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters &parameters) {
@@ -94,23 +87,22 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) {
             parameters.context,
             *parameters.renderPass,
             gfx::Triangles(),
-            parameters.depthModeForSublayer(0, parameters.pass == RenderPass::Opaque
-                ? gfx::DepthMaskType::ReadWrite
-                : gfx::DepthMaskType::ReadOnly),
+            parameters.depthModeForSublayer(
+                0,
+                parameters.pass == RenderPass::Opaque ? gfx::DepthMaskType::ReadWrite : gfx::DepthMaskType::ReadOnly),
             gfx::StencilMode::disabled(),
             parameters.colorModeForRenderPass(),
             gfx::CullFaceMode::disabled(),
             *parameters.staticData.quadTriangleIndexBuffer,
-            impl->segments,
+            segments,
             allUniformValues,
             allAttributeBindings,
             textureBindings,
-            util::toString(id)
-        );
+            util::toString(id));
     };
 
-    if (impl->segments.empty()) {
-        impl->segments = parameters.staticData.tileTriangleSegments();
+    if (segments.empty()) {
+        segments = parameters.staticData.tileTriangleSegments();
     }
 
     const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated;
@@ -126,23 +118,19 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) {
 
         uint32_t i = 0;
         for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
-            draw(
-                parameters.programs.getBackgroundLayerPrograms().backgroundPattern,
-                BackgroundPatternProgram::layoutUniformValues(
-                    parameters.matrixForTile(tileID),
-                    evaluated.get<BackgroundOpacity>(),
-                    parameters.patternAtlas.getPixelSize(),
-                    *imagePosA,
-                    *imagePosB,
-                    crossfade,
-                    tileID,
-                    parameters.state
-                ),
-                BackgroundPatternProgram::TextureBindings{
-                    textures::image::Value{ parameters.patternAtlas.textureBinding() },
-                },
-                i++
-            );
+            draw(parameters.programs.getBackgroundLayerPrograms().backgroundPattern,
+                 BackgroundPatternProgram::layoutUniformValues(parameters.matrixForTile(tileID),
+                                                               evaluated.get<BackgroundOpacity>(),
+                                                               parameters.patternAtlas.getPixelSize(),
+                                                               *imagePosA,
+                                                               *imagePosB,
+                                                               crossfade,
+                                                               tileID,
+                                                               parameters.state),
+                 BackgroundPatternProgram::TextureBindings{
+                     textures::image::Value{parameters.patternAtlas.textureBinding()},
+                 },
+                 i++);
         }
     } else {
         auto backgroundRenderPass = (evaluated.get<BackgroundColor>().a >= 1.0f
@@ -153,16 +141,14 @@ void RenderBackgroundLayer::render(PaintParameters& parameters) {
         }
         uint32_t i = 0;
         for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
-            draw(
-                parameters.programs.getBackgroundLayerPrograms().background,
-                BackgroundProgram::LayoutUniformValues {
-                    uniforms::matrix::Value( parameters.matrixForTile(tileID) ),
-                    uniforms::color::Value( evaluated.get<BackgroundColor>() ),
-                    uniforms::opacity::Value( evaluated.get<BackgroundOpacity>() ),
-                },
-                BackgroundProgram::TextureBindings{},
-                i++
-            );
+            draw(parameters.programs.getBackgroundLayerPrograms().background,
+                 BackgroundProgram::LayoutUniformValues{
+                     uniforms::matrix::Value(parameters.matrixForTile(tileID)),
+                     uniforms::color::Value(evaluated.get<BackgroundColor>()),
+                     uniforms::opacity::Value(evaluated.get<BackgroundOpacity>()),
+                 },
+                 BackgroundProgram::TextureBindings{},
+                 i++);
         }
     }
 }
diff --git a/src/mbgl/renderer/layers/render_background_layer.hpp b/src/mbgl/renderer/layers/render_background_layer.hpp
index a72173619ff..dab733172b8 100644
--- a/src/mbgl/renderer/layers/render_background_layer.hpp
+++ b/src/mbgl/renderer/layers/render_background_layer.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mbgl/programs/background_program.hpp>
 #include <mbgl/renderer/render_layer.hpp>
 #include <mbgl/style/layers/background_layer_impl.hpp>
 #include <mbgl/style/layers/background_layer_properties.hpp>
@@ -22,8 +23,7 @@ class RenderBackgroundLayer final : public RenderLayer {
 
     // Paint properties
     style::BackgroundPaintProperties::Unevaluated unevaluated;
-    class Impl;
-    const std::unique_ptr<Impl> impl;
+    SegmentVector<BackgroundAttributes> segments;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index 4567ec40fe5..b88a026e118 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -17,7 +17,7 @@ using namespace style;
 
 namespace {
 
-inline const style::CircleLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
+inline const style::CircleLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
     assert(impl->getTypeInfo() == CircleLayer::Impl::staticTypeInfo());
     return static_cast<const style::CircleLayer::Impl&>(*impl);
 }
@@ -26,11 +26,11 @@ inline const style::CircleLayer::Impl& impl_cast(const Immutable<style::Layer::I
 
 RenderCircleLayer::RenderCircleLayer(Immutable<style::CircleLayer::Impl> _impl)
     : RenderLayer(makeMutable<CircleLayerProperties>(std::move(_impl))),
-      unevaluated(impl_cast(baseImpl).paint.untransitioned()) {
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
 void RenderCircleLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 0c6949a7530..af0bc788d05 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -23,7 +23,7 @@ using namespace style;
 
 namespace {
 
-inline const FillExtrusionLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
+inline const FillExtrusionLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
     assert(impl->getTypeInfo() == FillExtrusionLayer::Impl::staticTypeInfo());
     return static_cast<const FillExtrusionLayer::Impl&>(*impl);
 }
@@ -32,13 +32,13 @@ inline const FillExtrusionLayer::Impl& impl_cast(const Immutable<style::Layer::I
 
 RenderFillExtrusionLayer::RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl> _impl)
     : RenderLayer(makeMutable<FillExtrusionLayerProperties>(std::move(_impl))),
-      unevaluated(impl_cast(baseImpl).paint.untransitioned()) {
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
 RenderFillExtrusionLayer::~RenderFillExtrusionLayer() = default;
 
 void RenderFillExtrusionLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderFillExtrusionLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index b7d70ec93f1..bbfcef7aba4 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -24,7 +24,7 @@ using namespace style;
 
 namespace {
 
-inline const FillLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
+inline const FillLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
     assert(impl->getTypeInfo() == FillLayer::Impl::staticTypeInfo());
     return static_cast<const FillLayer::Impl&>(*impl);
 }
@@ -33,13 +33,13 @@ inline const FillLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& imp
 
 RenderFillLayer::RenderFillLayer(Immutable<style::FillLayer::Impl> _impl)
     : RenderLayer(makeMutable<FillLayerProperties>(std::move(_impl))),
-      unevaluated(impl_cast(baseImpl).paint.untransitioned()) {
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
 RenderFillLayer::~RenderFillLayer() = default;
 
 void RenderFillLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index a269cb9daec..647d6064e53 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -4,7 +4,6 @@
 #include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/renderer/render_static_data.hpp>
 #include <mbgl/programs/programs.hpp>
-#include <mbgl/programs/heatmap_program.hpp>
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/style/layers/heatmap_layer.hpp>
 #include <mbgl/style/layers/heatmap_layer_impl.hpp>
@@ -12,9 +11,6 @@
 #include <mbgl/gfx/cull_face_mode.hpp>
 #include <mbgl/gfx/render_pass.hpp>
 #include <mbgl/gfx/context.hpp>
-#include <mbgl/gfx/texture.hpp>
-#include <mbgl/gfx/offscreen_texture.hpp>
-#include <mbgl/util/optional.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
 
@@ -24,36 +20,23 @@ using namespace style;
 
 namespace {
 
-inline const HeatmapLayer::Impl& impl_cast(const Immutable<Layer::Impl>& impl) {
+inline const HeatmapLayer::Impl& impl(const Immutable<Layer::Impl>& impl) {
     assert(impl->getTypeInfo() == HeatmapLayer::Impl::staticTypeInfo());
     return static_cast<const HeatmapLayer::Impl&>(*impl);
 }
 
 } // namespace
 
-class RenderHeatmapLayer::Impl {
-public:
-    Impl() : colorRamp({256, 1}) {}
-
-    void updateColorRamp(ColorRampPropertyValue);
-
-    PremultipliedImage colorRamp;
-    std::unique_ptr<gfx::OffscreenTexture> renderTexture;
-    optional<gfx::Texture> colorRampTexture;
-    SegmentVector<HeatmapTextureAttributes> segments;
-};
-
 RenderHeatmapLayer::RenderHeatmapLayer(Immutable<HeatmapLayer::Impl> _impl)
     : RenderLayer(makeMutable<HeatmapLayerProperties>(std::move(_impl))),
-    unevaluated(impl_cast(baseImpl).paint.untransitioned()),
-    impl(std::make_unique<Impl>()) {
-}
+      unevaluated(impl(baseImpl).paint.untransitioned()),
+      colorRamp({256, 1}) {}
 
 RenderHeatmapLayer::~RenderHeatmapLayer() = default;
 
 void RenderHeatmapLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
-    impl->updateColorRamp(unevaluated.get<HeatmapColor>().getValue());
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
+    updateColorRamp();
 }
 
 void RenderHeatmapLayer::evaluate(const PropertyEvaluationParameters& parameters) {
@@ -77,9 +60,9 @@ bool RenderHeatmapLayer::hasCrossfade() const {
 }
 
 void RenderHeatmapLayer::upload(gfx::UploadPass& uploadPass) {
-    if (!impl->colorRampTexture) {
-        impl->colorRampTexture =
-            uploadPass.createTexture(impl->colorRamp, gfx::TextureChannelDataType::UnsignedByte);
+    if (!colorRampTexture) {
+        colorRampTexture =
+            uploadPass.createTexture(colorRamp, gfx::TextureChannelDataType::UnsignedByte);
     }
 }
 
@@ -93,27 +76,27 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) {
         const auto& viewportSize = parameters.staticData.backendSize;
         const auto size = Size{viewportSize.width / 4, viewportSize.height / 4};
 
-        assert(impl->colorRampTexture);
+        assert(colorRampTexture);
 
-        if (!impl->renderTexture || impl->renderTexture->getSize() != size) {
-            impl->renderTexture.reset();
+        if (!renderTexture || renderTexture->getSize() != size) {
+            renderTexture.reset();
             if (parameters.context.supportsHalfFloatTextures) {
-                impl->renderTexture = parameters.context.createOffscreenTexture(size, gfx::TextureChannelDataType::HalfFloat);
+                renderTexture = parameters.context.createOffscreenTexture(size, gfx::TextureChannelDataType::HalfFloat);
 
-                if (!impl->renderTexture->isRenderable()) {
+                if (!renderTexture->isRenderable()) {
                     // can't render to a half-float texture; falling back to unsigned byte one
-                    impl->renderTexture.reset();
+                    renderTexture.reset();
                     parameters.context.supportsHalfFloatTextures = false;
                 }
             }
 
-            if (!impl->renderTexture) {
-                impl->renderTexture = parameters.context.createOffscreenTexture(size, gfx::TextureChannelDataType::UnsignedByte);
+            if (!renderTexture) {
+                renderTexture = parameters.context.createOffscreenTexture(size, gfx::TextureChannelDataType::UnsignedByte);
             }
         }
 
         auto renderPass = parameters.encoder->createRenderPass(
-            "heatmap texture", { *impl->renderTexture, Color{ 0.0f, 0.0f, 0.0f, 1.0f }, {}, {} });
+            "heatmap texture", { *renderTexture, Color{ 0.0f, 0.0f, 0.0f, 1.0f }, {}, {} });
 
         for (const RenderTile& tile : *renderTiles) {
             const LayerRenderData* renderData = getRenderDataForPass(tile, parameters.pass);
@@ -193,9 +176,9 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) {
 
         checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
 
-        if (impl->segments.empty()) {
+        if (segments.empty()) {
             // Copy over the segments so that we can create our own DrawScopes.
-            impl->segments = parameters.staticData.heatmapTextureSegments();
+            segments = parameters.staticData.heatmapTextureSegments();
         }
         programInstance.draw(
             parameters.context,
@@ -206,19 +189,19 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) {
             parameters.colorModeForRenderPass(),
             gfx::CullFaceMode::disabled(),
             *parameters.staticData.quadTriangleIndexBuffer,
-            impl->segments,
+            segments,
             allUniformValues,
             allAttributeBindings,
             HeatmapTextureProgram::TextureBindings{
-                textures::image::Value{ impl->renderTexture->getTexture().getResource(), gfx::TextureFilterType::Linear },
-                textures::color_ramp::Value{ impl->colorRampTexture->getResource(), gfx::TextureFilterType::Linear },
+                textures::image::Value{renderTexture->getTexture().getResource(), gfx::TextureFilterType::Linear},
+                textures::color_ramp::Value{colorRampTexture->getResource(), gfx::TextureFilterType::Linear},
             },
-            getID()
-        );
+            getID());
     }
 }
 
-void RenderHeatmapLayer::Impl::updateColorRamp(ColorRampPropertyValue colorValue) {
+void RenderHeatmapLayer::updateColorRamp() {
+    auto colorValue = unevaluated.get<HeatmapColor>().getValue();
     if (colorValue.isUndefined()) {
         colorValue = HeatmapLayer::getDefaultHeatmapColor();
     }
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
index f742d660c1a..b7a03a6ba59 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
@@ -1,8 +1,12 @@
 #pragma once
 
+#include <mbgl/gfx/offscreen_texture.hpp>
+#include <mbgl/gfx/texture.hpp>
+#include <mbgl/programs/heatmap_program.hpp>
 #include <mbgl/renderer/render_layer.hpp>
 #include <mbgl/style/layers/heatmap_layer_impl.hpp>
 #include <mbgl/style/layers/heatmap_layer_properties.hpp>
+#include <mbgl/util/optional.hpp>
 
 namespace mbgl {
 
@@ -21,11 +25,14 @@ class RenderHeatmapLayer final : public RenderLayer {
 
     bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float,
                                 const TransformState&, const float, const mat4&, const FeatureState&) const override;
+    void updateColorRamp();
 
     // Paint properties
     style::HeatmapPaintProperties::Unevaluated unevaluated;
-    class Impl;
-    const std::unique_ptr<Impl> impl;
+    PremultipliedImage colorRamp;
+    std::unique_ptr<gfx::OffscreenTexture> renderTexture;
+    optional<gfx::Texture> colorRampTexture;
+    SegmentVector<HeatmapTextureAttributes> segments;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index e0d22becd75..16b04dc6d54 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -20,7 +20,7 @@ using namespace style;
 
 namespace {
 
-inline const HillshadeLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
+inline const HillshadeLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
     assert(impl->getTypeInfo() == HillshadeLayer::Impl::staticTypeInfo());
     return static_cast<const HillshadeLayer::Impl&>(*impl);
 }
@@ -29,7 +29,7 @@ inline const HillshadeLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>
 
 RenderHillshadeLayer::RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl> _impl)
     : RenderLayer(makeMutable<HillshadeLayerProperties>(std::move(_impl))),
-      unevaluated(impl_cast(baseImpl).paint.untransitioned()) {
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
 RenderHillshadeLayer::~RenderHillshadeLayer() = default;
@@ -48,7 +48,7 @@ const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters&
 }
 
 void RenderHillshadeLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderHillshadeLayer::evaluate(const PropertyEvaluationParameters& parameters) {
@@ -111,21 +111,19 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
 
         checkRenderability(parameters, programInstance.activeBindingCount(allAttributeBindings));
 
-        programInstance.draw(
-            parameters.context,
-            *parameters.renderPass,
-            gfx::Triangles(),
-            parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
-            gfx::StencilMode::disabled(),
-            parameters.colorModeForRenderPass(),
-            gfx::CullFaceMode::disabled(),
-            indexBuffer,
-            segments,
-            allUniformValues,
-            allAttributeBindings,
-            textureBindings,
-            getID()
-        );
+        programInstance.draw(parameters.context,
+                             *parameters.renderPass,
+                             gfx::Triangles(),
+                             parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
+                             gfx::StencilMode::disabled(),
+                             parameters.colorModeForRenderPass(),
+                             gfx::CullFaceMode::disabled(),
+                             indexBuffer,
+                             segments,
+                             allUniformValues,
+                             allAttributeBindings,
+                             textureBindings,
+                             getID());
     };
 
     mat4 mat;
@@ -180,23 +178,21 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
             // Copy over the segments so that we can create our own DrawScopes that get destroyed
             // after this draw call.
             auto segments = parameters.staticData.rasterSegments();
-            programInstance.draw(
-                parameters.context,
-                *renderPass,
-                gfx::Triangles(),
-                parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
-                gfx::StencilMode::disabled(),
-                parameters.colorModeForRenderPass(),
-                gfx::CullFaceMode::disabled(),
-                *parameters.staticData.quadTriangleIndexBuffer,
-                segments,
-                allUniformValues,
-                allAttributeBindings,
-                HillshadePrepareProgram::TextureBindings{
-                    textures::image::Value{ bucket.dem->getResource() },
-                },
-                "prepare"
-            );
+            programInstance.draw(parameters.context,
+                                 *renderPass,
+                                 gfx::Triangles(),
+                                 parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
+                                 gfx::StencilMode::disabled(),
+                                 parameters.colorModeForRenderPass(),
+                                 gfx::CullFaceMode::disabled(),
+                                 *parameters.staticData.quadTriangleIndexBuffer,
+                                 segments,
+                                 allUniformValues,
+                                 allAttributeBindings,
+                                 HillshadePrepareProgram::TextureBindings{
+                                     textures::image::Value{bucket.dem->getResource()},
+                                 },
+                                 "prepare");
             bucket.texture = std::move(view->getTexture());
             bucket.setPrepared(true);
         } else if (parameters.pass == RenderPass::Translucent) {
@@ -224,7 +220,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
                      bucket.segments,
                      tile.id,
                      HillshadeProgram::TextureBindings{
-                         textures::image::Value{ bucket.texture->getResource(), gfx::TextureFilterType::Linear },
+                         textures::image::Value{bucket.texture->getResource(), gfx::TextureFilterType::Linear},
                      });
             }
         }
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 6664baf021a..588cf6286cf 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -23,7 +23,7 @@ using namespace style;
 
 namespace {
 
-inline const LineLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
+inline const LineLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
     assert(impl->getTypeInfo() == LineLayer::Impl::staticTypeInfo());
     return static_cast<const LineLayer::Impl&>(*impl);
 }
@@ -32,14 +32,14 @@ inline const LineLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& imp
 
 RenderLineLayer::RenderLineLayer(Immutable<style::LineLayer::Impl> _impl)
     : RenderLayer(makeMutable<LineLayerProperties>(std::move(_impl))),
-      unevaluated(impl_cast(baseImpl).paint.untransitioned()),
+      unevaluated(impl(baseImpl).paint.untransitioned()),
       colorRamp({256, 1}) {
 }
 
 RenderLineLayer::~RenderLineLayer() = default;
 
 void RenderLineLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
     updateColorRamp();
 }
 
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index 9cbcfbd850f..4eee348ad95 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -16,7 +16,7 @@ using namespace style;
 
 namespace {
 
-inline const RasterLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
+inline const RasterLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
     assert(impl->getTypeInfo() == RasterLayer::Impl::staticTypeInfo());
     return static_cast<const RasterLayer::Impl&>(*impl);
 }
@@ -25,13 +25,13 @@ inline const RasterLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& i
 
 RenderRasterLayer::RenderRasterLayer(Immutable<style::RasterLayer::Impl> _impl)
     : RenderLayer(makeMutable<RasterLayerProperties>(std::move(_impl))),
-      unevaluated(impl_cast(baseImpl).paint.untransitioned()) {
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
 RenderRasterLayer::~RenderRasterLayer() = default;
 
 void RenderRasterLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) {
@@ -153,14 +153,14 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
         size_t i = 0;
         for (const auto& matrix_ : imageData->matrices) {
             draw(matrix_,
-                *bucket.vertexBuffer,
-                *bucket.indexBuffer,
-                bucket.segments,
-                RasterProgram::TextureBindings{
-                    textures::image0::Value{ bucket.texture->getResource(), filter },
-                    textures::image1::Value{ bucket.texture->getResource(), filter },
-                },
-                std::to_string(i++));
+                 *bucket.vertexBuffer,
+                 *bucket.indexBuffer,
+                 bucket.segments,
+                 RasterProgram::TextureBindings{
+                     textures::image0::Value{bucket.texture->getResource(), filter},
+                     textures::image1::Value{bucket.texture->getResource(), filter},
+                 },
+                 std::to_string(i++));
         }
     } else if (renderTiles) {
         for (const RenderTile& tile : *renderTiles) {
@@ -181,8 +181,8 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
                      *bucket.indexBuffer,
                      bucket.segments,
                      RasterProgram::TextureBindings{
-                         textures::image0::Value{ bucket.texture->getResource(), filter },
-                         textures::image1::Value{ bucket.texture->getResource(), filter },
+                         textures::image0::Value{bucket.texture->getResource(), filter},
+                         textures::image1::Value{bucket.texture->getResource(), filter},
                      },
                      "image");
             } else {
@@ -196,8 +196,8 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
                      *parameters.staticData.quadTriangleIndexBuffer,
                      bucket.segments,
                      RasterProgram::TextureBindings{
-                         textures::image0::Value{ bucket.texture->getResource(), filter },
-                         textures::image1::Value{ bucket.texture->getResource(), filter },
+                         textures::image0::Value{bucket.texture->getResource(), filter},
+                         textures::image1::Value{bucket.texture->getResource(), filter},
                      },
                      "image");
             }
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 903768e079d..955ad2ce515 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -290,7 +290,7 @@ void drawText(const DrawFn& draw,
     }
 }
 
-inline const SymbolLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& impl) {
+inline const SymbolLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
     assert(impl->getTypeInfo() == SymbolLayer::Impl::staticTypeInfo());
     return static_cast<const SymbolLayer::Impl&>(*impl);
 }
@@ -299,14 +299,14 @@ inline const SymbolLayer::Impl& impl_cast(const Immutable<style::Layer::Impl>& i
 
 RenderSymbolLayer::RenderSymbolLayer(Immutable<style::SymbolLayer::Impl> _impl)
     : RenderLayer(makeMutable<SymbolLayerProperties>(std::move(_impl))),
-      unevaluated(impl_cast(baseImpl).paint.untransitioned()) {
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
 RenderSymbolLayer::~RenderSymbolLayer() = default;
 
 void RenderSymbolLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl_cast(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
-    hasFormatSectionOverrides = SymbolLayerPaintPropertyOverrides::hasOverrides(impl_cast(baseImpl).layout.get<TextField>());
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
+    hasFormatSectionOverrides = SymbolLayerPaintPropertyOverrides::hasOverrides(impl(baseImpl).layout.get<TextField>());
 }
 
 void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) {
@@ -314,7 +314,7 @@ void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters)
         staticImmutableCast<SymbolLayer::Impl>(baseImpl),
         unevaluated.evaluate(parameters));
     auto& evaluated = properties->evaluated;
-    auto& layout = impl_cast(baseImpl).layout;
+    auto& layout = impl(baseImpl).layout;
 
     if (hasFormatSectionOverrides) {
         SymbolLayerPaintPropertyOverrides::setOverrides(layout, evaluated);
@@ -346,7 +346,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters) {
         return;
     }
 
-    const bool sortFeaturesByKey = !impl_cast(baseImpl).layout.get<SymbolSortKey>().isUndefined();
+    const bool sortFeaturesByKey = !impl(baseImpl).layout.get<SymbolSortKey>().isUndefined();
     std::multiset<RenderableSegment> renderableSegments;
 
     const auto draw = [&parameters, this] (auto& programInstance,
diff --git a/src/mbgl/renderer/paint_parameters.cpp b/src/mbgl/renderer/paint_parameters.cpp
index 011cb9bb833..b2f958b14ef 100644
--- a/src/mbgl/renderer/paint_parameters.cpp
+++ b/src/mbgl/renderer/paint_parameters.cpp
@@ -129,39 +129,30 @@ void PaintParameters::renderTileClippingMasks(const RenderTiles& renderTiles) {
         const int32_t stencilID = nextStencilID++;
         tileClippingMaskIDs.emplace(renderTile.id, stencilID);
 
-        program.draw(
-            context,
-            *renderPass,
-            gfx::Triangles(),
-            gfx::DepthMode::disabled(),
-            gfx::StencilMode {
-                gfx::StencilMode::Always{},
-                stencilID,
-                0b11111111,
-                gfx::StencilOpType::Keep,
-                gfx::StencilOpType::Keep,
-                gfx::StencilOpType::Replace
-            },
-            gfx::ColorMode::disabled(),
-            gfx::CullFaceMode::disabled(),
-            *staticData.quadTriangleIndexBuffer,
-            staticData.clippingMaskSegments,
-            program.computeAllUniformValues(
-                ClippingMaskProgram::LayoutUniformValues {
-                    uniforms::matrix::Value( matrixForTile(renderTile.id) ),
-                },
-                paintAttributeData,
-                properties,
-                state.getZoom()
-            ),
-            program.computeAllAttributeBindings(
-                *staticData.tileVertexBuffer,
-                paintAttributeData,
-                properties
-            ),
-            ClippingMaskProgram::TextureBindings{},
-            "clipping/" + util::toString(stencilID)
-        );
+        program.draw(context,
+                     *renderPass,
+                     gfx::Triangles(),
+                     gfx::DepthMode::disabled(),
+                     gfx::StencilMode{gfx::StencilMode::Always{},
+                                      stencilID,
+                                      0b11111111,
+                                      gfx::StencilOpType::Keep,
+                                      gfx::StencilOpType::Keep,
+                                      gfx::StencilOpType::Replace},
+                     gfx::ColorMode::disabled(),
+                     gfx::CullFaceMode::disabled(),
+                     *staticData.quadTriangleIndexBuffer,
+                     staticData.clippingMaskSegments,
+                     program.computeAllUniformValues(
+                         ClippingMaskProgram::LayoutUniformValues{
+                             uniforms::matrix::Value(matrixForTile(renderTile.id)),
+                         },
+                         paintAttributeData,
+                         properties,
+                         state.getZoom()),
+                     program.computeAllAttributeBindings(*staticData.tileVertexBuffer, paintAttributeData, properties),
+                     ClippingMaskProgram::TextureBindings{},
+                     "clipping/" + util::toString(stencilID));
     }
 }
 
diff --git a/src/mbgl/renderer/render_static_data.cpp b/src/mbgl/renderer/render_static_data.cpp
index 347f33e7d3d..f7d9c18a785 100644
--- a/src/mbgl/renderer/render_static_data.cpp
+++ b/src/mbgl/renderer/render_static_data.cpp
@@ -50,9 +50,11 @@ static gfx::VertexVector<HeatmapTextureLayoutVertex> heatmapTextureVertices() {
 }
 
 RenderStaticData::RenderStaticData(gfx::Context& context, float pixelRatio)
-    : programs(context, ProgramParameters { pixelRatio, false })
+    : programs(context, ProgramParameters{pixelRatio, false}),
+      clippingMaskSegments(tileTriangleSegments())
 #ifndef NDEBUG
-    , overdrawPrograms(context, ProgramParameters { pixelRatio, true })
+      ,
+      overdrawPrograms(context, ProgramParameters{pixelRatio, true})
 #endif
 {
 }
diff --git a/src/mbgl/renderer/render_static_data.hpp b/src/mbgl/renderer/render_static_data.hpp
index 80b8288229e..22b29387dbb 100644
--- a/src/mbgl/renderer/render_static_data.hpp
+++ b/src/mbgl/renderer/render_static_data.hpp
@@ -35,7 +35,6 @@ class RenderStaticData {
     static SegmentVector<RasterAttributes> rasterSegments();
     static SegmentVector<HeatmapTextureAttributes> heatmapTextureSegments();
 
-
     optional<gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>> depthRenderbuffer;
     bool has3D = false;
     bool uploaded = false;
diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp
index bbd93d5189f..ce5fef05b8e 100644
--- a/src/mbgl/renderer/render_tile.cpp
+++ b/src/mbgl/renderer/render_tile.cpp
@@ -147,50 +147,40 @@ void RenderTile::finishRender(PaintParameters& parameters) const {
         program.draw(
             parameters.context,
             *parameters.renderPass,
-            gfx::Lines { 4.0f * parameters.pixelRatio },
+            gfx::Lines{4.0f * parameters.pixelRatio},
             gfx::DepthMode::disabled(),
             gfx::StencilMode::disabled(),
             gfx::ColorMode::unblended(),
             gfx::CullFaceMode::disabled(),
             *debugBucket->indexBuffer,
             debugBucket->segments,
-            program.computeAllUniformValues(
-                DebugProgram::LayoutUniformValues {
-                    uniforms::matrix::Value( matrix ),
-                    uniforms::color::Value( Color::white() )
-                },
-                paintAttributeData,
-                properties,
-                parameters.state.getZoom()
-            ),
+            program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
+                                                                              uniforms::color::Value(Color::white())},
+                                            paintAttributeData,
+                                            properties,
+                                            parameters.state.getZoom()),
             allAttributeBindings,
             DebugProgram::TextureBindings{},
-            "text-outline"
-        );
+            "text-outline");
 
         program.draw(
             parameters.context,
             *parameters.renderPass,
-            gfx::Lines { 2.0f * parameters.pixelRatio },
+            gfx::Lines{2.0f * parameters.pixelRatio},
             gfx::DepthMode::disabled(),
             gfx::StencilMode::disabled(),
             gfx::ColorMode::unblended(),
             gfx::CullFaceMode::disabled(),
             *debugBucket->indexBuffer,
             debugBucket->segments,
-            program.computeAllUniformValues(
-                DebugProgram::LayoutUniformValues {
-                    uniforms::matrix::Value( matrix ),
-                    uniforms::color::Value( Color::black() )
-                },
-                paintAttributeData,
-                properties,
-                parameters.state.getZoom()
-            ),
+            program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
+                                                                              uniforms::color::Value(Color::black())},
+                                            paintAttributeData,
+                                            properties,
+                                            parameters.state.getZoom()),
             allAttributeBindings,
             DebugProgram::TextureBindings{},
-            "text"
-        );
+            "text");
     }
 
     if (parameters.debugOptions & MapDebugOptions::TileBorders) {
@@ -201,30 +191,22 @@ void RenderTile::finishRender(PaintParameters& parameters) const {
         parameters.programs.debug.draw(
             parameters.context,
             *parameters.renderPass,
-            gfx::LineStrip { 4.0f * parameters.pixelRatio },
+            gfx::LineStrip{4.0f * parameters.pixelRatio},
             gfx::DepthMode::disabled(),
             gfx::StencilMode::disabled(),
             gfx::ColorMode::unblended(),
             gfx::CullFaceMode::disabled(),
             *parameters.staticData.tileBorderIndexBuffer,
             debugBucket->tileBorderSegments,
-            program.computeAllUniformValues(
-                DebugProgram::LayoutUniformValues {
-                    uniforms::matrix::Value( matrix ),
-                    uniforms::color::Value( Color::red() )
-                },
-                paintAttributeData,
-                properties,
-                parameters.state.getZoom()
-            ),
+            program.computeAllUniformValues(DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
+                                                                              uniforms::color::Value(Color::red())},
+                                            paintAttributeData,
+                                            properties,
+                                            parameters.state.getZoom()),
             program.computeAllAttributeBindings(
-                *parameters.staticData.tileVertexBuffer,
-                paintAttributeData,
-                properties
-            ),
+                *parameters.staticData.tileVertexBuffer, paintAttributeData, properties),
             DebugProgram::TextureBindings{},
-            "border"
-        );
+            "border");
     }
 }
 
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 9e1d44586ce..30f1bbcee65 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -36,33 +36,25 @@ void ImageSourceRenderData::render(PaintParameters& parameters) const {
     auto& programInstance = parameters.programs.debug;
 
     for (auto matrix : matrices) {
-        programInstance.draw(
-            parameters.context,
-            *parameters.renderPass,
-            gfx::LineStrip { 4.0f * parameters.pixelRatio },
-            gfx::DepthMode::disabled(),
-            gfx::StencilMode::disabled(),
-            gfx::ColorMode::unblended(),
-            gfx::CullFaceMode::disabled(),
-            *parameters.staticData.tileBorderIndexBuffer,
-            parameters.staticData.tileBorderSegments(),
-            programInstance.computeAllUniformValues(
-                DebugProgram::LayoutUniformValues {
-                    uniforms::matrix::Value( matrix ),
-                    uniforms::color::Value( Color::red() )
-                },
-                paintAttributeData,
-                properties,
-                parameters.state.getZoom()
-            ),
-            programInstance.computeAllAttributeBindings(
-                *parameters.staticData.tileVertexBuffer,
-                paintAttributeData,
-                properties
-            ),
-            DebugProgram::TextureBindings{},
-            "image"
-        );
+        programInstance.draw(parameters.context,
+                             *parameters.renderPass,
+                             gfx::LineStrip{4.0f * parameters.pixelRatio},
+                             gfx::DepthMode::disabled(),
+                             gfx::StencilMode::disabled(),
+                             gfx::ColorMode::unblended(),
+                             gfx::CullFaceMode::disabled(),
+                             *parameters.staticData.tileBorderIndexBuffer,
+                             parameters.staticData.tileBorderSegments(),
+                             programInstance.computeAllUniformValues(
+                                 DebugProgram::LayoutUniformValues{uniforms::matrix::Value(matrix),
+                                                                   uniforms::color::Value(Color::red())},
+                                 paintAttributeData,
+                                 properties,
+                                 parameters.state.getZoom()),
+                             programInstance.computeAllAttributeBindings(
+                                 *parameters.staticData.tileVertexBuffer, paintAttributeData, properties),
+                             DebugProgram::TextureBindings{},
+                             "image");
     }
 }