diff --git a/include/mbgl/renderer/backend_scope.hpp b/include/mbgl/gfx/backend_scope.hpp
similarity index 96%
rename from include/mbgl/renderer/backend_scope.hpp
rename to include/mbgl/gfx/backend_scope.hpp
index 73bafc84c..b92334ae0 100644
--- a/include/mbgl/renderer/backend_scope.hpp
+++ b/include/mbgl/gfx/backend_scope.hpp
@@ -4,6 +4,8 @@ namespace mbgl {
 
 class RendererBackend;
 
+namespace gfx {
+
 class BackendScope {
 public:
     // There are two types of scopes: Creating an "Implicit" scope tells Mapbox GL that the
@@ -32,4 +34,5 @@ private:
     bool activated = false;
 };
 
+} // namespace gfx
 } // namespace mbgl
diff --git a/include/mbgl/renderer/renderer_backend.hpp b/include/mbgl/renderer/renderer_backend.hpp
index 1d5f4e8f4..f75d00ebb 100644
--- a/include/mbgl/renderer/renderer_backend.hpp
+++ b/include/mbgl/renderer/renderer_backend.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/util/image.hpp>
 #include <mbgl/util/size.hpp>
 #include <mbgl/util/util.hpp>
@@ -82,7 +82,7 @@ protected:
 private:
     std::once_flag initialized;
 
-    friend class BackendScope;
+    friend class gfx::BackendScope;
 };
 
 MBGL_CONSTEXPR bool operator==(const RendererBackend& a, const RendererBackend& b) {
diff --git a/platform/android/src/android_renderer_backend.cpp b/platform/android/src/android_renderer_backend.cpp
index ae35acc5d..52a9a9317 100755
--- a/platform/android/src/android_renderer_backend.cpp
+++ b/platform/android/src/android_renderer_backend.cpp
@@ -13,7 +13,7 @@ namespace android {
  * From mbgl::View
  */
 void AndroidRendererBackend::bind() {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
     setFramebufferBinding(0);
     setViewport(0, 0, getFramebufferSize());
 }
@@ -22,12 +22,12 @@ void AndroidRendererBackend::bind() {
  * From mbgl::RendererBackend.
  */
 gl::ProcAddress AndroidRendererBackend::getExtensionFunctionPointer(const char* name) {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
     return eglGetProcAddress(name);
 }
 
 void AndroidRendererBackend::updateViewPort() {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
     setViewport(0, 0, getFramebufferSize());
 }
 
@@ -37,7 +37,7 @@ void AndroidRendererBackend::resizeFramebuffer(int width, int height) {
 }
 
 PremultipliedImage AndroidRendererBackend::readFramebuffer() const {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
     return RendererBackend::readFramebuffer(getFramebufferSize());
 }
 
diff --git a/platform/android/src/map_renderer.cpp b/platform/android/src/map_renderer.cpp
index 8d226c000..f0273cee5 100644
--- a/platform/android/src/map_renderer.cpp
+++ b/platform/android/src/map_renderer.cpp
@@ -135,7 +135,7 @@ void MapRenderer::render(JNIEnv&) {
     }
 
     // Activate the backend
-    BackendScope backendGuard { *backend };
+    gfx::BackendScope backendGuard { *backend };
 
     // Ensure that the "current" scheduler on the render thread is
     // this scheduler.
diff --git a/platform/darwin/src/MGLRendererFrontend.h b/platform/darwin/src/MGLRendererFrontend.h
index c0e03351c..5e6a051bb 100644
--- a/platform/darwin/src/MGLRendererFrontend.h
+++ b/platform/darwin/src/MGLRendererFrontend.h
@@ -1,4 +1,4 @@
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/renderer/renderer.hpp>
 #include <mbgl/renderer/renderer_backend.hpp>
 #include <mbgl/renderer/renderer_frontend.hpp>
@@ -47,7 +47,7 @@ public:
     void render() {
         if (!renderer || !updateParameters) return;
         
-        mbgl::BackendScope guard { mbglBackend, mbgl::BackendScope::ScopeType::Implicit };
+        mbgl::gfx::BackendScope guard { mbglBackend, mbgl::gfx::BackendScope::ScopeType::Implicit };
         
         // onStyleImageMissing might be called during a render. The user implemented method
         // could trigger a call to MGLRenderFrontend#update which overwrites `updateParameters`.
diff --git a/platform/default/src/mbgl/gl/headless_backend.cpp b/platform/default/src/mbgl/gl/headless_backend.cpp
index b4814acb5..4d05be167 100644
--- a/platform/default/src/mbgl/gl/headless_backend.cpp
+++ b/platform/default/src/mbgl/gl/headless_backend.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/gl/headless_backend.hpp>
 #include <mbgl/gl/context.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 
 #include <cassert>
 #include <stdexcept>
@@ -26,7 +26,7 @@ HeadlessBackend::HeadlessBackend(Size size_)
 }
 
 HeadlessBackend::~HeadlessBackend() {
-    BackendScope guard { *this };
+    gfx::BackendScope guard { *this };
     view.reset();
     context.reset();
 }
diff --git a/platform/default/src/mbgl/gl/headless_frontend.cpp b/platform/default/src/mbgl/gl/headless_frontend.cpp
index c311e2df4..3c8188c8a 100644
--- a/platform/default/src/mbgl/gl/headless_frontend.cpp
+++ b/platform/default/src/mbgl/gl/headless_frontend.cpp
@@ -19,7 +19,7 @@ HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, Scheduler& sch
               static_cast<uint32_t>(size.height * pixelRatio) }),
     asyncInvalidate([this] {
         if (renderer && updateParameters) {
-            mbgl::BackendScope guard { backend };
+            gfx::BackendScope guard { backend };
 
             // onStyleImageMissing might be called during a render. The user implemented method
             // could trigger a call to MGLRenderFrontend#update which overwrites `updateParameters`.
diff --git a/platform/default/src/mbgl/util/thread_local.cpp b/platform/default/src/mbgl/util/thread_local.cpp
index db70773c1..068c2880c 100644
--- a/platform/default/src/mbgl/util/thread_local.cpp
+++ b/platform/default/src/mbgl/util/thread_local.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/util/thread_local.hpp>
 
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/run_loop.hpp>
 
@@ -58,7 +58,7 @@ void ThreadLocal<T>::set(T* ptr) {
     }
 }
 
-template class ThreadLocal<BackendScope>;
+template class ThreadLocal<gfx::BackendScope>;
 template class ThreadLocal<Scheduler>;
 template class ThreadLocal<int>; // For unit tests
 
diff --git a/platform/glfw/glfw_renderer_frontend.cpp b/platform/glfw/glfw_renderer_frontend.cpp
index 9c5320cc7..82efbcdfb 100644
--- a/platform/glfw/glfw_renderer_frontend.cpp
+++ b/platform/glfw/glfw_renderer_frontend.cpp
@@ -1,6 +1,7 @@
 #include "glfw_renderer_frontend.hpp"
 
 #include <mbgl/renderer/renderer.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 
 GLFWRendererFrontend::GLFWRendererFrontend(std::unique_ptr<mbgl::Renderer> renderer_, GLFWView& glfwView_)
     : glfwView(glfwView_)
@@ -30,7 +31,7 @@ void GLFWRendererFrontend::render() {
     
     if (!updateParameters) return;
     
-    mbgl::BackendScope guard { glfwView, mbgl::BackendScope::ScopeType::Implicit };
+    mbgl::gfx::BackendScope guard { glfwView, mbgl::gfx::BackendScope::ScopeType::Implicit };
 
     // onStyleImageMissing might be called during a render. The user implemented method
     // could trigger a call to MGLRenderFrontend#update which overwrites `updateParameters`.
diff --git a/platform/glfw/glfw_view.cpp b/platform/glfw/glfw_view.cpp
index 601642cfa..483ca1455 100644
--- a/platform/glfw/glfw_view.cpp
+++ b/platform/glfw/glfw_view.cpp
@@ -14,7 +14,7 @@
 #include <mbgl/util/chrono.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/renderer/renderer.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/map/camera.hpp>
 
 #include <mapbox/cheap_ruler.hpp>
@@ -502,7 +502,7 @@ void GLFWView::onFramebufferResize(GLFWwindow *window, int width, int height) {
     view->fbWidth = width;
     view->fbHeight = height;
 
-    mbgl::BackendScope scope { *view, mbgl::BackendScope::ScopeType::Implicit };
+    mbgl::gfx::BackendScope scope { *view, mbgl::gfx::BackendScope::ScopeType::Implicit };
     view->bind();
 
     // This is only triggered when the framebuffer is resized, but not the window. It can
diff --git a/platform/ios/src/MGLMapView.mm b/platform/ios/src/MGLMapView.mm
index 715929818..f78b2d150 100644
--- a/platform/ios/src/MGLMapView.mm
+++ b/platform/ios/src/MGLMapView.mm
@@ -20,7 +20,6 @@
 #include <mbgl/renderer/mode.hpp>
 #include <mbgl/renderer/renderer.hpp>
 #include <mbgl/renderer/renderer_backend.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
 #include <mbgl/math/wrap.hpp>
 #include <mbgl/util/exception.hpp>
 #include <mbgl/util/geo.hpp>
diff --git a/platform/macos/src/MGLMapView.mm b/platform/macos/src/MGLMapView.mm
index 091ba462c..cb0cd7fa0 100644
--- a/platform/macos/src/MGLMapView.mm
+++ b/platform/macos/src/MGLMapView.mm
@@ -35,7 +35,6 @@
 #import <mbgl/style/image.hpp>
 #import <mbgl/renderer/renderer.hpp>
 #import <mbgl/renderer/renderer_backend.hpp>
-#import <mbgl/renderer/backend_scope.hpp>
 #import <mbgl/storage/network_status.hpp>
 #import <mbgl/storage/resource_options.hpp>
 #import <mbgl/math/wrap.hpp>
diff --git a/platform/qt/src/qmapboxgl.cpp b/platform/qt/src/qmapboxgl.cpp
index 4f7952525..7dcc75334 100644
--- a/platform/qt/src/qmapboxgl.cpp
+++ b/platform/qt/src/qmapboxgl.cpp
@@ -33,7 +33,6 @@
 #include <mbgl/style/transition_options.hpp>
 #include <mbgl/style/image.hpp>
 #include <mbgl/renderer/renderer.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
 #include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/storage/network_status.hpp>
 #include <mbgl/storage/resource_options.hpp>
diff --git a/platform/qt/src/qmapboxgl_map_renderer.cpp b/platform/qt/src/qmapboxgl_map_renderer.cpp
index 8962a8e05..6b4103eab 100644
--- a/platform/qt/src/qmapboxgl_map_renderer.cpp
+++ b/platform/qt/src/qmapboxgl_map_renderer.cpp
@@ -79,7 +79,7 @@ void QMapboxGLMapRenderer::render()
     }
 
     // The OpenGL implementation automatically enables the OpenGL context for us.
-    mbgl::BackendScope scope(m_backend, mbgl::BackendScope::ScopeType::Implicit);
+    mbgl::gfx::BackendScope scope(m_backend, mbgl::gfx::BackendScope::ScopeType::Implicit);
 
     m_renderer->render(*params);
 
diff --git a/platform/qt/src/qmapboxgl_renderer_backend.cpp b/platform/qt/src/qmapboxgl_renderer_backend.cpp
index c6de7c6d8..ac1298127 100644
--- a/platform/qt/src/qmapboxgl_renderer_backend.cpp
+++ b/platform/qt/src/qmapboxgl_renderer_backend.cpp
@@ -11,7 +11,7 @@ void QMapboxGLRendererBackend::updateAssumedState()
 
 void QMapboxGLRendererBackend::bind()
 {
-    assert(mbgl::BackendScope::exists());
+    assert(mbgl::gfx::BackendScope::exists());
 
     setFramebufferBinding(m_fbo);
     setViewport(0, 0, m_size);
diff --git a/platform/qt/src/thread_local.cpp b/platform/qt/src/thread_local.cpp
index 467bfb0d0..4191195a8 100644
--- a/platform/qt/src/thread_local.cpp
+++ b/platform/qt/src/thread_local.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/util/thread_local.hpp>
 
 #include <mbgl/actor/scheduler.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 
 #include <array>
 #include <cassert>
@@ -42,7 +42,7 @@ void ThreadLocal<T>::set(T* ptr) {
 }
 
 template class ThreadLocal<Scheduler>;
-template class ThreadLocal<BackendScope>;
+template class ThreadLocal<gfx::BackendScope>;
 template class ThreadLocal<int>; // For unit tests
 
 } // namespace util
diff --git a/src/core-files.json b/src/core-files.json
index 98d1de376..9d3cbddd7 100644
--- a/src/core-files.json
+++ b/src/core-files.json
@@ -321,6 +321,7 @@
         "mbgl/actor/message.hpp": "include/mbgl/actor/message.hpp",
         "mbgl/actor/scheduler.hpp": "include/mbgl/actor/scheduler.hpp",
         "mbgl/annotation/annotation.hpp": "include/mbgl/annotation/annotation.hpp",
+        "mbgl/gfx/backend_scope.hpp": "include/mbgl/gfx/backend_scope.hpp",
         "mbgl/gfx/renderable.hpp": "include/mbgl/gfx/renderable.hpp",
         "mbgl/gl/renderable_resource.hpp": "include/mbgl/gl/renderable_resource.hpp",
         "mbgl/layermanager/background_layer_factory.hpp": "include/mbgl/layermanager/background_layer_factory.hpp",
@@ -348,7 +349,6 @@
         "mbgl/math/minmax.hpp": "include/mbgl/math/minmax.hpp",
         "mbgl/math/wrap.hpp": "include/mbgl/math/wrap.hpp",
         "mbgl/platform/gl_functions.hpp": "include/mbgl/platform/gl_functions.hpp",
-        "mbgl/renderer/backend_scope.hpp": "include/mbgl/renderer/backend_scope.hpp",
         "mbgl/renderer/mode.hpp": "include/mbgl/renderer/mode.hpp",
         "mbgl/renderer/query.hpp": "include/mbgl/renderer/query.hpp",
         "mbgl/renderer/renderer.hpp": "include/mbgl/renderer/renderer.hpp",
diff --git a/src/mbgl/renderer/backend_scope.cpp b/src/mbgl/renderer/backend_scope.cpp
index ad430961a..e4988a37c 100644
--- a/src/mbgl/renderer/backend_scope.cpp
+++ b/src/mbgl/renderer/backend_scope.cpp
@@ -1,13 +1,13 @@
-#include <mbgl/renderer/backend_scope.hpp>
 #include <mbgl/renderer/renderer_backend.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/util/thread_local.hpp>
 
 #include <cassert>
 
 namespace {
 
-mbgl::util::ThreadLocal<mbgl::BackendScope>& currentScope() {
-    static mbgl::util::ThreadLocal<mbgl::BackendScope> backendScope;
+mbgl::util::ThreadLocal<mbgl::gfx::BackendScope>& currentScope() {
+    static mbgl::util::ThreadLocal<mbgl::gfx::BackendScope> backendScope;
 
     return backendScope;
 }
@@ -15,6 +15,7 @@ mbgl::util::ThreadLocal<mbgl::BackendScope>& currentScope() {
 } // namespace
 
 namespace mbgl {
+namespace gfx {
 
 BackendScope::BackendScope(RendererBackend& backend_, ScopeType scopeType_)
     : priorScope(currentScope().get()),
@@ -71,4 +72,5 @@ bool BackendScope::exists() {
     return currentScope().get();
 }
 
+} // namespace gfx
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_custom_layer.cpp b/src/mbgl/renderer/layers/render_custom_layer.cpp
index 10cc37558..240aef84c 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/renderer/layers/render_custom_layer.hpp>
 #include <mbgl/renderer/paint_parameters.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
 #include <mbgl/renderer/renderer_backend.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/platform/gl_functions.hpp>
 #include <mbgl/style/layers/custom_layer_impl.hpp>
@@ -15,12 +15,12 @@ using namespace style;
 
 RenderCustomLayer::RenderCustomLayer(Immutable<style::CustomLayer::Impl> _impl)
     : RenderLayer(std::move(_impl)), host(impl().host) {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
     MBGL_CHECK_ERROR(host->initialize());
 }
 
 RenderCustomLayer::~RenderCustomLayer() {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
     if (contextDestroyed) {
         host->contextLost();
     } else {
diff --git a/src/mbgl/renderer/renderer.cpp b/src/mbgl/renderer/renderer.cpp
index 4da7b7837..a345ed6e1 100644
--- a/src/mbgl/renderer/renderer.cpp
+++ b/src/mbgl/renderer/renderer.cpp
@@ -2,7 +2,7 @@
 
 #include <mbgl/layermanager/layer_manager.hpp>
 #include <mbgl/renderer/renderer_impl.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/annotation/annotation_manager.hpp>
 
 namespace mbgl {
@@ -18,7 +18,7 @@ Renderer::Renderer(RendererBackend& backend,
 }
 
 Renderer::~Renderer() {
-    BackendScope guard { impl->backend };
+    gfx::BackendScope guard { impl->backend };
     impl.reset();
 }
 
@@ -116,7 +116,7 @@ void Renderer::dumpDebugLogs() {
 }
 
 void Renderer::reduceMemoryUse() {
-    BackendScope guard { impl->backend };
+    gfx::BackendScope guard { impl->backend };
     impl->reduceMemoryUse();
 }
 
diff --git a/src/mbgl/renderer/renderer_backend.cpp b/src/mbgl/renderer/renderer_backend.cpp
index d44386db5..24249e06a 100644
--- a/src/mbgl/renderer/renderer_backend.cpp
+++ b/src/mbgl/renderer/renderer_backend.cpp
@@ -1,5 +1,5 @@
 #include <mbgl/renderer/renderer_backend.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gl/context.hpp>
 #include <mbgl/gl/extension.hpp>
 
@@ -10,7 +10,7 @@ namespace mbgl {
 RendererBackend::RendererBackend() = default;
 
 gl::Context& RendererBackend::getContext() {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
     std::call_once(initialized, [this] {
         context = std::make_unique<gl::Context>();
         context->enableDebugging();
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index da051d61d..3a85928cc 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -14,7 +14,7 @@
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/style_diff.hpp>
 #include <mbgl/renderer/query.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/gl/context.hpp>
 #include <mbgl/geometry/line_atlas.hpp>
@@ -56,7 +56,7 @@ Renderer::Impl::Impl(RendererBackend& backend_,
     , placement(std::make_unique<Placement>(TransformState{}, MapMode::Static, TransitionOptions{}, true)) {}
 
 Renderer::Impl::~Impl() {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
 
     if (contextLost) {
         // Signal all RenderLayers that the context was lost
@@ -89,8 +89,8 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         // Reset zoom history state.
         zoomHistory.first = true;
     }
-    
-    assert(BackendScope::exists());
+
+    assert(gfx::BackendScope::exists());
     if (LayerManager::annotationsEnabled) {
         updateParameters.annotationManager.updateData();
     }
@@ -598,7 +598,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 }
 
 void  Renderer::Impl::flush() {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
 
     backend.getContext().flush();
 }
@@ -728,7 +728,7 @@ FeatureExtensionValue Renderer::Impl::queryFeatureExtensions(const std::string&
 }
 
 void Renderer::Impl::reduceMemoryUse() {
-    assert(BackendScope::exists());
+    assert(gfx::BackendScope::exists());
     for (const auto& entry : renderSources) {
         entry.second->reduceMemoryUse();
     }
diff --git a/test/api/api_misuse.test.cpp b/test/api/api_misuse.test.cpp
index cca47de69..b65bdf991 100644
--- a/test/api/api_misuse.test.cpp
+++ b/test/api/api_misuse.test.cpp
@@ -4,7 +4,7 @@
 #include <mbgl/test/map_adapter.hpp>
 
 #include <mbgl/map/map_options.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/util/default_thread_pool.hpp>
 #include <mbgl/util/exception.hpp>
diff --git a/test/api/recycle_map.cpp b/test/api/recycle_map.cpp
index ac9de9b23..18cc9c00a 100644
--- a/test/api/recycle_map.cpp
+++ b/test/api/recycle_map.cpp
@@ -4,7 +4,7 @@
 
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/map/map_options.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/sources/geojson_source.hpp>
 #include <mbgl/style/image.hpp>
diff --git a/test/gl/bucket.test.cpp b/test/gl/bucket.test.cpp
index 2be224382..48cdc1c0f 100644
--- a/test/gl/bucket.test.cpp
+++ b/test/gl/bucket.test.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/test/util.hpp>
 #include <mbgl/test/stub_geometry_tile_feature.hpp>
 
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/renderer/buckets/circle_bucket.hpp>
 #include <mbgl/renderer/buckets/fill_bucket.hpp>
 #include <mbgl/renderer/buckets/line_bucket.hpp>
@@ -44,7 +44,7 @@ PropertyMap properties;
 
 TEST(Buckets, CircleBucket) {
     HeadlessBackend backend({ 512, 256 });
-    BackendScope scope { backend };
+    gfx::BackendScope scope { backend };
 
     gl::Context context;
     CircleBucket bucket { { {0, 0, 0}, MapMode::Static, 1.0, nullptr }, {} };
@@ -63,7 +63,7 @@ TEST(Buckets, CircleBucket) {
 
 TEST(Buckets, FillBucket) {
     HeadlessBackend backend({ 512, 256 });
-    BackendScope scope { backend };
+    gfx::BackendScope scope { backend };
     style::Properties<>::PossiblyEvaluated layout;
 
     gl::Context context;
@@ -82,7 +82,7 @@ TEST(Buckets, FillBucket) {
 
 TEST(Buckets, LineBucket) {
     HeadlessBackend backend({ 512, 256 });
-    BackendScope scope { backend };
+    gfx::BackendScope scope { backend };
     style::LineLayoutProperties::PossiblyEvaluated layout;
 
     gl::Context context;
@@ -106,7 +106,7 @@ TEST(Buckets, LineBucket) {
 
 TEST(Buckets, SymbolBucket) {
     HeadlessBackend backend({ 512, 256 });
-    BackendScope scope { backend };
+    gfx::BackendScope scope { backend };
 
     style::SymbolLayoutProperties::PossiblyEvaluated layout;
     bool sdfIcons = false;
@@ -140,7 +140,7 @@ TEST(Buckets, SymbolBucket) {
 
 TEST(Buckets, RasterBucket) {
     HeadlessBackend backend({ 512, 256 });
-    BackendScope scope { backend };
+    gfx::BackendScope scope { backend };
 
     gl::Context context;
     PremultipliedImage rgba({ 1, 1 });
diff --git a/test/gl/context.test.cpp b/test/gl/context.test.cpp
index 291813bd9..14f7cd3a1 100644
--- a/test/gl/context.test.cpp
+++ b/test/gl/context.test.cpp
@@ -5,6 +5,7 @@
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
 #include <mbgl/util/default_thread_pool.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gl/defines.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/storage/resource_options.hpp>
@@ -103,8 +104,8 @@ TEST(GLContextMode, Shared) {
 
     {
         // Custom rendering outside of GL Native render loop.
-        BackendScope scope { *frontend.getBackend() };
         frontend.getBackend()->bind();
+        gfx::BackendScope scope { *frontend.getBackend() };
 
         Shader paintShader(vertexShaderSource, fragmentShaderSource);
         Buffer triangleBuffer({ 0, 0.5, 0.5, -0.5, -0.5, -0.5 });
diff --git a/test/gl/object.test.cpp b/test/gl/object.test.cpp
index a29b2ff95..5441c4c33 100644
--- a/test/gl/object.test.cpp
+++ b/test/gl/object.test.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/test/util.hpp>
 
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gl/headless_backend.hpp>
 #include <mbgl/gl/context.hpp>
 
@@ -46,7 +46,7 @@ TEST(GLObject, Value) {
 
 TEST(GLObject, Store) {
     HeadlessBackend backend { { 256, 256 } };
-    BackendScope scope { backend };
+    gfx::BackendScope scope { backend };
 
     gl::Context context;
     EXPECT_TRUE(context.empty());
diff --git a/test/map/map.test.cpp b/test/map/map.test.cpp
index be92890b0..41275df7f 100644
--- a/test/map/map.test.cpp
+++ b/test/map/map.test.cpp
@@ -6,6 +6,7 @@
 #include <mbgl/test/map_adapter.hpp>
 
 #include <mbgl/map/map_options.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gl/context.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/util/default_thread_pool.hpp>
@@ -613,8 +614,8 @@ TEST(Map, AddLayer) {
 TEST(Map, WithoutVAOExtension) {
     MapTest<DefaultFileSource> test { ":memory:", "test/fixtures/api/assets" };
 
-    BackendScope scope { *test.frontend.getBackend() };
     test.frontend.getBackend()->getContext().disableVAOExtension = true;
+    gfx::BackendScope scope { *test.frontend.getBackend() };
 
     test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));
 
diff --git a/test/renderer/backend_scope.test.cpp b/test/renderer/backend_scope.test.cpp
index 05b82695b..e78c895ac 100644
--- a/test/renderer/backend_scope.test.cpp
+++ b/test/renderer/backend_scope.test.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/test/util.hpp>
 
 #include <mbgl/renderer/renderer_backend.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 
 #include <functional>
 
@@ -49,7 +49,7 @@ TEST(BackendScope, SingleScope) {
     backend.deactivateFunction = [&] { deactivated = true; };
 
     {
-        BackendScope test { backend };
+        gfx::BackendScope test { backend };
     }
 
     ASSERT_TRUE(activated);
@@ -67,10 +67,10 @@ TEST(BackendScope, NestedScopes) {
     backend.deactivateFunction = [&] { deactivated++; };
 
     {
-        BackendScope outer { backend };
+        gfx::BackendScope outer { backend };
         ASSERT_EQ(1, activated);
         {
-            BackendScope inner { backend };
+            gfx::BackendScope inner { backend };
             ASSERT_EQ(1, activated);
         }
         ASSERT_EQ(0, deactivated);
@@ -96,10 +96,10 @@ TEST(BackendScope, ChainedScopes) {
     backendB.deactivateFunction = [&] { activatedB = false; };
 
     {
-        BackendScope scopeA { backendA };
+        gfx::BackendScope scopeA { backendA };
         ASSERT_TRUE(activatedA);
         {
-            BackendScope scopeB { backendB };
+            gfx::BackendScope scopeB { backendB };
             ASSERT_FALSE(activatedA);
             ASSERT_TRUE(activatedB);
         }
diff --git a/test/util/offscreen_texture.test.cpp b/test/util/offscreen_texture.test.cpp
index 887a1cdc0..91bae66ce 100644
--- a/test/util/offscreen_texture.test.cpp
+++ b/test/util/offscreen_texture.test.cpp
@@ -1,12 +1,12 @@
 #include <mbgl/test/util.hpp>
 
 #include <mbgl/platform/gl_functions.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gl/context.hpp>
 #include <mbgl/gl/texture.hpp>
 #include <mbgl/gl/defines.hpp>
 #include <mbgl/gl/renderable_resource.hpp>
 #include <mbgl/gl/headless_backend.hpp>
-#include <mbgl/renderer/backend_scope.hpp>
 #include <mbgl/gl/offscreen_texture.hpp>
 
 
@@ -15,7 +15,7 @@ using namespace mbgl::platform;
 
 TEST(OffscreenTexture, EmptyRed) {
     HeadlessBackend backend({ 512, 256 });
-    BackendScope scope { backend };
+    gfx::BackendScope scope { backend };
 
     // Scissor test shouldn't leak after HeadlessBackend::bind().
     MBGL_CHECK_ERROR(glScissor(64, 64, 128, 128));
@@ -77,8 +77,8 @@ struct Buffer {
 
 TEST(OffscreenTexture, RenderToTexture) {
     HeadlessBackend backend({ 512, 256 });
-    BackendScope scope { backend };
     auto& context = backend.getContext();
+    gfx::BackendScope scope { backend };
 
     MBGL_CHECK_ERROR(glEnable(GL_BLEND));
     MBGL_CHECK_ERROR(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));