diff --git a/src/mbgl/layermanager/background_layer_factory.cpp b/src/mbgl/layermanager/background_layer_factory.cpp
index d711d3ec5..fddcf4929 100644
--- a/src/mbgl/layermanager/background_layer_factory.cpp
+++ b/src/mbgl/layermanager/background_layer_factory.cpp
@@ -13,7 +13,7 @@ const style::LayerTypeInfo* BackgroundLayerFactory::getTypeInfo() const noexcept
 std::unique_ptr<style::Layer> BackgroundLayerFactory::createLayer(
     const std::string& id, const style::conversion::Convertible& value) noexcept {
     (void)value;
-    return std::unique_ptr<style::Layer>(new style::BackgroundLayer(id));
+    return std::unique_ptr<style::Layer>(new (std::nothrow) style::BackgroundLayer(id));
 }
 
 std::unique_ptr<RenderLayer> BackgroundLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
diff --git a/src/mbgl/layermanager/circle_layer_factory.cpp b/src/mbgl/layermanager/circle_layer_factory.cpp
index b32fb1317..e92b0a536 100644
--- a/src/mbgl/layermanager/circle_layer_factory.cpp
+++ b/src/mbgl/layermanager/circle_layer_factory.cpp
@@ -14,24 +14,22 @@ const style::LayerTypeInfo* CircleLayerFactory::getTypeInfo() const noexcept {
 
 std::unique_ptr<style::Layer> CircleLayerFactory::createLayer(const std::string& id,
                                                               const style::conversion::Convertible& value) noexcept {
-    auto const source = getSource(value);
-    if (!source) {
-        return nullptr;
-    }
-
-    return std::unique_ptr<style::Layer>(new style::CircleLayer(id, *source));
+    const auto source = getSource(value);
+    return std::unique_ptr<style::Layer>(source ? new (std::nothrow) style::CircleLayer(id, *source) : nullptr);
 }
 
 std::unique_ptr<Layout> CircleLayerFactory::createLayout(
     const LayoutParameters& parameters,
     std::unique_ptr<GeometryTileLayer> layer,
     const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
-    return std::make_unique<CircleLayout>(parameters.bucketParameters, group, std::move(layer));
+    return std::unique_ptr<Layout>(new (std::nothrow)
+                                       CircleLayout(parameters.bucketParameters, group, std::move(layer)));
 }
 
 std::unique_ptr<RenderLayer> CircleLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
     assert(impl->getTypeInfo() == getTypeInfo());
-    return std::make_unique<RenderCircleLayer>(staticImmutableCast<style::CircleLayer::Impl>(impl));
+    return std::unique_ptr<RenderLayer>(new (std::nothrow)
+                                            RenderCircleLayer(staticImmutableCast<style::CircleLayer::Impl>(impl)));
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp b/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
index 8c78f630c..cf757022f 100644
--- a/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
+++ b/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
@@ -13,12 +13,8 @@ const style::LayerTypeInfo* FillExtrusionLayerFactory::getTypeInfo() const noexc
 
 std::unique_ptr<style::Layer> FillExtrusionLayerFactory::createLayer(
     const std::string& id, const style::conversion::Convertible& value) noexcept {
-    auto const source = getSource(value);
-    if (!source) {
-        return nullptr;
-    }
-
-    return std::unique_ptr<style::Layer>(new style::FillExtrusionLayer(id, *source));
+    const auto source = getSource(value);
+    return std::unique_ptr<style::Layer>(source ? new (std::nothrow) style::FillExtrusionLayer(id, *source) : nullptr);
 }
 
 std::unique_ptr<Layout> FillExtrusionLayerFactory::createLayout(
@@ -27,12 +23,14 @@ std::unique_ptr<Layout> FillExtrusionLayerFactory::createLayout(
     const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
     using namespace style;
     using LayoutType = PatternLayout<FillExtrusionBucket, FillExtrusionLayerProperties, FillExtrusionPattern>;
-    return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters);
+    return std::unique_ptr<Layout>(new (std::nothrow)
+                                       LayoutType(parameters.bucketParameters, group, std::move(layer), parameters));
 }
 
 std::unique_ptr<RenderLayer> FillExtrusionLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
     assert(impl->getTypeInfo() == getTypeInfo());
-    return std::make_unique<RenderFillExtrusionLayer>(staticImmutableCast<style::FillExtrusionLayer::Impl>(impl));
+    auto renderImpl = staticImmutableCast<style::FillExtrusionLayer::Impl>(impl);
+    return std::unique_ptr<RenderLayer>(new (std::nothrow) RenderFillExtrusionLayer(std::move(renderImpl)));
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/layermanager/fill_layer_factory.cpp b/src/mbgl/layermanager/fill_layer_factory.cpp
index 5f2de1ed1..f7faf3ac0 100644
--- a/src/mbgl/layermanager/fill_layer_factory.cpp
+++ b/src/mbgl/layermanager/fill_layer_factory.cpp
@@ -27,14 +27,17 @@ std::unique_ptr<Layout> FillLayerFactory::createLayout(
         PatternLayout<FillBucket, FillLayerProperties, FillPattern, FillLayoutProperties, FillSortKey>;
     auto layerProperties = staticImmutableCast<FillLayerProperties>(group.front());
     if (layerProperties->layerImpl().layout.get<FillSortKey>().isUndefined()) {
-        return std::make_unique<LayoutTypeUnsorted>(parameters.bucketParameters, group, std::move(layer), parameters);
+        return std::unique_ptr<Layout>(
+            new (std::nothrow) LayoutTypeUnsorted(parameters.bucketParameters, group, std::move(layer), parameters));
     }
-    return std::make_unique<LayoutTypeSorted>(parameters.bucketParameters, group, std::move(layer), parameters);
+    return std::unique_ptr<Layout>(
+        new (std::nothrow) LayoutTypeSorted(parameters.bucketParameters, group, std::move(layer), parameters));
 }
 
 std::unique_ptr<RenderLayer> FillLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
     assert(impl->getTypeInfo() == getTypeInfo());
-    return std::make_unique<RenderFillLayer>(staticImmutableCast<style::FillLayer::Impl>(impl));
+    auto fillImpl = staticImmutableCast<style::FillLayer::Impl>(impl);
+    return std::unique_ptr<RenderLayer>(new (std::nothrow) RenderFillLayer(std::move(fillImpl)));
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/layermanager/heatmap_layer_factory.cpp b/src/mbgl/layermanager/heatmap_layer_factory.cpp
index 17bbd71fc..77c3e8581 100644
--- a/src/mbgl/layermanager/heatmap_layer_factory.cpp
+++ b/src/mbgl/layermanager/heatmap_layer_factory.cpp
@@ -13,12 +13,11 @@ const style::LayerTypeInfo* HeatmapLayerFactory::getTypeInfo() const noexcept {
 
 std::unique_ptr<style::Layer> HeatmapLayerFactory::createLayer(const std::string& id,
                                                                const style::conversion::Convertible& value) noexcept {
-    auto const source = getSource(value);
+    const auto source = getSource(value);
     if (!source) {
         return nullptr;
     }
-
-    return std::unique_ptr<style::Layer>(new style::HeatmapLayer(id, *source));
+    return std::unique_ptr<style::Layer>(new (std::nothrow) style::HeatmapLayer(id, *source));
 }
 
 std::unique_ptr<Bucket> HeatmapLayerFactory::createBucket(
diff --git a/src/mbgl/layermanager/hillshade_layer_factory.cpp b/src/mbgl/layermanager/hillshade_layer_factory.cpp
index af257d1c9..11fca6a58 100644
--- a/src/mbgl/layermanager/hillshade_layer_factory.cpp
+++ b/src/mbgl/layermanager/hillshade_layer_factory.cpp
@@ -12,13 +12,11 @@ const style::LayerTypeInfo* HillshadeLayerFactory::getTypeInfo() const noexcept
 
 std::unique_ptr<style::Layer> HillshadeLayerFactory::createLayer(const std::string& id,
                                                                  const style::conversion::Convertible& value) noexcept {
-    auto const source = getSource(value);
+    const auto source = getSource(value);
     if (!source) {
         return nullptr;
     }
-
-    std::unique_ptr<style::Layer> layer = std::unique_ptr<style::Layer>(new style::HillshadeLayer(id, *source));
-    return layer;
+    return std::unique_ptr<style::Layer>(new (std::nothrow) style::HillshadeLayer(id, *source));
 }
 
 std::unique_ptr<RenderLayer> HillshadeLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
diff --git a/src/mbgl/layermanager/line_layer_factory.cpp b/src/mbgl/layermanager/line_layer_factory.cpp
index 2ff372a4a..ca6778801 100644
--- a/src/mbgl/layermanager/line_layer_factory.cpp
+++ b/src/mbgl/layermanager/line_layer_factory.cpp
@@ -13,11 +13,8 @@ const style::LayerTypeInfo* LineLayerFactory::getTypeInfo() const noexcept {
 
 std::unique_ptr<style::Layer> LineLayerFactory::createLayer(const std::string& id,
                                                             const style::conversion::Convertible& value) noexcept {
-    auto const source = getSource(value);
-    if (!source) {
-        return nullptr;
-    }
-    return std::unique_ptr<style::Layer>(new style::LineLayer(id, *source));
+    const auto source = getSource(value);
+    return std::unique_ptr<style::Layer>(source ? new (std::nothrow) style::LineLayer(id, *source) : nullptr);
 }
 
 std::unique_ptr<Layout> LineLayerFactory::createLayout(
@@ -30,14 +27,17 @@ std::unique_ptr<Layout> LineLayerFactory::createLayout(
         PatternLayout<LineBucket, LineLayerProperties, LinePattern, LineLayoutProperties, LineSortKey>;
     auto layerProperties = staticImmutableCast<LineLayerProperties>(group.front());
     if (layerProperties->layerImpl().layout.get<LineSortKey>().isUndefined()) {
-        return std::make_unique<LayoutTypeUnsorted>(parameters.bucketParameters, group, std::move(layer), parameters);
+        return std::unique_ptr<Layout>(
+            new (std::nothrow) LayoutTypeUnsorted(parameters.bucketParameters, group, std::move(layer), parameters));
     }
-    return std::make_unique<LayoutTypeSorted>(parameters.bucketParameters, group, std::move(layer), parameters);
+    return std::unique_ptr<Layout>(
+        new (std::nothrow) LayoutTypeSorted(parameters.bucketParameters, group, std::move(layer), parameters));
 }
 
 std::unique_ptr<RenderLayer> LineLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
     assert(impl->getTypeInfo() == getTypeInfo());
-    return std::make_unique<RenderLineLayer>(staticImmutableCast<style::LineLayer::Impl>(impl));
+    auto lineImpl = staticImmutableCast<style::LineLayer::Impl>(impl);
+    return std::unique_ptr<RenderLayer>(new (std::nothrow) RenderLineLayer(std::move(lineImpl)));
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/layermanager/raster_layer_factory.cpp b/src/mbgl/layermanager/raster_layer_factory.cpp
index 05fc9fd66..8b9909202 100644
--- a/src/mbgl/layermanager/raster_layer_factory.cpp
+++ b/src/mbgl/layermanager/raster_layer_factory.cpp
@@ -12,13 +12,11 @@ const style::LayerTypeInfo* RasterLayerFactory::getTypeInfo() const noexcept {
 
 std::unique_ptr<style::Layer> RasterLayerFactory::createLayer(const std::string& id,
                                                               const style::conversion::Convertible& value) noexcept {
-    auto const source = getSource(value);
+    const auto source = getSource(value);
     if (!source) {
         return nullptr;
     }
-
-    std::unique_ptr<style::Layer> layer = std::unique_ptr<style::Layer>(new style::RasterLayer(id, *source));
-    return layer;
+    return std::unique_ptr<style::Layer>(new (std::nothrow) style::RasterLayer(id, *source));
 }
 
 std::unique_ptr<RenderLayer> RasterLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
diff --git a/src/mbgl/layermanager/symbol_layer_factory.cpp b/src/mbgl/layermanager/symbol_layer_factory.cpp
index 465341fb6..3c4d2c4d2 100644
--- a/src/mbgl/layermanager/symbol_layer_factory.cpp
+++ b/src/mbgl/layermanager/symbol_layer_factory.cpp
@@ -13,18 +13,16 @@ const style::LayerTypeInfo* SymbolLayerFactory::getTypeInfo() const noexcept {
 
 std::unique_ptr<style::Layer> SymbolLayerFactory::createLayer(const std::string& id,
                                                               const style::conversion::Convertible& value) noexcept {
-    std::optional<std::string> source = getSource(value);
-    if (!source) {
-        return nullptr;
-    }
-    return std::unique_ptr<style::Layer>(new style::SymbolLayer(id, *source));
+    const auto source = getSource(value);
+    return std::unique_ptr<style::Layer>(source ? new (std::nothrow) style::SymbolLayer(id, *source) : nullptr);
 }
 
 std::unique_ptr<Layout> SymbolLayerFactory::createLayout(
     const LayoutParameters& parameters,
     std::unique_ptr<GeometryTileLayer> tileLayer,
     const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
-    return std::make_unique<SymbolLayout>(parameters.bucketParameters, group, std::move(tileLayer), parameters);
+    return std::unique_ptr<Layout>(
+        new (std::nothrow) SymbolLayout(parameters.bucketParameters, group, std::move(tileLayer), parameters));
 }
 
 std::unique_ptr<RenderLayer> SymbolLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {