diff --git a/.rive_head b/.rive_head
index 5f7b8b1f..47ee0691 100644
--- a/.rive_head
+++ b/.rive_head
@@ -1 +1 @@
-cc903ee0236a43b850488e029f270e5da23625b7
+57a94aff03ab42d68b04c32ecbaeb4fadb752fec
diff --git a/renderer/include/rive/renderer/gl/render_context_gl_impl.hpp b/renderer/include/rive/renderer/gl/render_context_gl_impl.hpp
index 1409cd2f..c8f7d648 100644
--- a/renderer/include/rive/renderer/gl/render_context_gl_impl.hpp
+++ b/renderer/include/rive/renderer/gl/render_context_gl_impl.hpp
@@ -135,7 +135,7 @@ class RenderContextGLImpl : public RenderContextHelperImpl
         DrawShader(const DrawShader&) = delete;
         DrawShader& operator=(const DrawShader&) = delete;
 
-        DrawShader(RenderContextGLImpl* plsContextImpl,
+        DrawShader(RenderContextGLImpl* renderContextImpl,
                    GLenum shaderType,
                    gpu::DrawType drawType,
                    ShaderFeatures shaderFeatures,
diff --git a/renderer/include/rive/renderer/render_context.hpp b/renderer/include/rive/renderer/render_context.hpp
index 70ee1d7a..d6e6df20 100644
--- a/renderer/include/rive/renderer/render_context.hpp
+++ b/renderer/include/rive/renderer/render_context.hpp
@@ -615,7 +615,7 @@ class RenderContext : public RiveRenderFactory
 
         // High-level draw list. These get built into a low-level list of gpu::DrawBatch objects
         // during writeResources().
-        std::vector<DrawUniquePtr> m_plsDraws;
+        std::vector<DrawUniquePtr> m_draws;
         IAABB m_combinedDrawBounds;
 
         // Layout state.
diff --git a/renderer/include/rive/renderer/rive_render_image.hpp b/renderer/include/rive/renderer/rive_render_image.hpp
new file mode 100644
index 00000000..1e251efb
--- /dev/null
+++ b/renderer/include/rive/renderer/rive_render_image.hpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2023 Rive
+ */
+
+#pragma once
+
+#include "rive/renderer/texture.hpp"
+
+namespace rive
+{
+class RiveRenderImage : public lite_rtti_override<RenderImage, RiveRenderImage>
+{
+public:
+    RiveRenderImage(rcp<gpu::Texture> texture) :
+        RiveRenderImage(texture->width(), texture->height())
+    {
+        resetTexture(std::move(texture));
+    }
+
+    rcp<gpu::Texture> refTexture() const { return m_texture; }
+    const gpu::Texture* getTexture() const { return m_texture.get(); }
+
+protected:
+    RiveRenderImage(int width, int height)
+    {
+        m_Width = width;
+        m_Height = height;
+    }
+
+    void resetTexture(rcp<gpu::Texture> texture = nullptr)
+    {
+        assert(texture == nullptr || texture->width() == m_Width);
+        assert(texture == nullptr || texture->height() == m_Height);
+        m_texture = std::move(texture);
+    }
+
+    // Used by the android runtime to send m_texture off to the worker thread to be deleted.
+    gpu::Texture* releaseTexture() { return m_texture.release(); }
+
+private:
+    rcp<gpu::Texture> m_texture;
+};
+} // namespace rive
diff --git a/renderer/include/rive/renderer/image.hpp b/renderer/include/rive/renderer/texture.hpp
similarity index 52%
rename from renderer/include/rive/renderer/image.hpp
rename to renderer/include/rive/renderer/texture.hpp
index 62ac48a5..c03742a3 100644
--- a/renderer/include/rive/renderer/image.hpp
+++ b/renderer/include/rive/renderer/texture.hpp
@@ -33,35 +33,4 @@ class Texture : public RefCnt<Texture>
     uint64_t m_bindlessTextureHandle = 0;
 };
 
-class Image : public lite_rtti_override<RenderImage, Image>
-{
-public:
-    Image(rcp<Texture> texture) : Image(texture->width(), texture->height())
-    {
-        resetTexture(std::move(texture));
-    }
-
-    rcp<Texture> refTexture() const { return m_texture; }
-    const Texture* getTexture() const { return m_texture.get(); }
-
-protected:
-    Image(int width, int height)
-    {
-        m_Width = width;
-        m_Height = height;
-    }
-
-    void resetTexture(rcp<Texture> texture = nullptr)
-    {
-        assert(texture == nullptr || texture->width() == m_Width);
-        assert(texture == nullptr || texture->height() == m_Height);
-        m_texture = std::move(texture);
-    }
-
-    // Used by the android runtime to send m_texture off to the worker thread to be deleted.
-    Texture* releaseTexture() { return m_texture.release(); }
-
-private:
-    rcp<Texture> m_texture;
-};
 } // namespace rive::gpu
diff --git a/renderer/include/rive/renderer/vulkan/render_context_vulkan_impl.hpp b/renderer/include/rive/renderer/vulkan/render_context_vulkan_impl.hpp
index 531ff555..22838ad8 100644
--- a/renderer/include/rive/renderer/vulkan/render_context_vulkan_impl.hpp
+++ b/renderer/include/rive/renderer/vulkan/render_context_vulkan_impl.hpp
@@ -159,7 +159,7 @@ class RenderContextVulkanImpl : public RenderContextImpl
     // its allocated descriptor sets.
     // The vkutil::RenderingResource base ensures this class stays alive until its
     // command buffer finishes, at which point we free the allocated descriptor
-    // sets and return the VkDescriptor to the plsContext.
+    // sets and return the VkDescriptor to the renderContext.
     class DescriptorSetPool final : public vkutil::RenderingResource
     {
     public:
@@ -170,11 +170,11 @@ class RenderContextVulkanImpl : public RenderContextImpl
         void freeDescriptorSets();
 
     private:
-        // Recycles this instance in the plsContext's m_descriptorSetPoolPool, if
-        // the plsContext still exists.
+        // Recycles this instance in the renderContext's m_descriptorSetPoolPool, if
+        // the renderContext still exists.
         void onRefCntReachedZero() const;
 
-        RenderContextVulkanImpl* const m_plsImplVulkan;
+        RenderContextVulkanImpl* const m_renderContextImpl;
         VkDescriptorPool m_vkDescriptorPool;
         std::vector<VkDescriptorSet> m_descriptorSets;
     };
diff --git a/renderer/path_fiddle/fiddle_context.hpp b/renderer/path_fiddle/fiddle_context.hpp
index bca2e30c..6ee5a9a9 100644
--- a/renderer/path_fiddle/fiddle_context.hpp
+++ b/renderer/path_fiddle/fiddle_context.hpp
@@ -25,8 +25,8 @@ class FiddleContext
     virtual ~FiddleContext() {}
     virtual float dpiScale(GLFWwindow*) const = 0;
     virtual rive::Factory* factory() = 0;
-    virtual rive::gpu::RenderContext* plsContextOrNull() = 0;
-    virtual rive::gpu::RenderTarget* plsRenderTargetOrNull() = 0;
+    virtual rive::gpu::RenderContext* renderContextOrNull() = 0;
+    virtual rive::gpu::RenderTarget* renderTargetOrNull() = 0;
     virtual void onSizeChanged(GLFWwindow*, int width, int height, uint32_t sampleCount) {}
     virtual void toggleZoomWindow() = 0;
     virtual std::unique_ptr<rive::Renderer> makeRenderer(int width, int height) = 0;
diff --git a/renderer/path_fiddle/fiddle_context_d3d.cpp b/renderer/path_fiddle/fiddle_context_d3d.cpp
index a08e4873..734190e2 100644
--- a/renderer/path_fiddle/fiddle_context_d3d.cpp
+++ b/renderer/path_fiddle/fiddle_context_d3d.cpp
@@ -30,16 +30,16 @@ class FiddleContextD3DPLS : public FiddleContext
         m_d3dFactory(std::move(d3dFactory)),
         m_gpu(std::move(gpu)),
         m_gpuContext(std::move(gpuContext)),
-        m_plsContext(RenderContextD3DImpl::MakeContext(m_gpu, m_gpuContext, contextOptions))
+        m_renderContext(RenderContextD3DImpl::MakeContext(m_gpu, m_gpuContext, contextOptions))
     {}
 
     float dpiScale(GLFWwindow*) const override { return 1; }
 
-    rive::Factory* factory() override { return m_plsContext.get(); }
+    rive::Factory* factory() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderContext* plsContextOrNull() override { return m_plsContext.get(); }
+    rive::gpu::RenderContext* renderContextOrNull() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderTarget* plsRenderTargetOrNull() override { return m_renderTarget.get(); }
+    rive::gpu::RenderTarget* renderTargetOrNull() override { return m_renderTarget.get(); }
 
     void onSizeChanged(GLFWwindow* window, int width, int height, uint32_t sampleCount) override
     {
@@ -60,8 +60,8 @@ class FiddleContextD3DPLS : public FiddleContext
                                                        NULL,
                                                        m_swapchain.ReleaseAndGetAddressOf()));
 
-        auto plsContextImpl = m_plsContext->static_impl_cast<RenderContextD3DImpl>();
-        m_renderTarget = plsContextImpl->makeRenderTarget(width, height);
+        auto renderContextImpl = m_renderContext->static_impl_cast<RenderContextD3DImpl>();
+        m_renderTarget = renderContextImpl->makeRenderTarget(width, height);
         m_readbackTexture = nullptr;
     }
 
@@ -69,12 +69,12 @@ class FiddleContextD3DPLS : public FiddleContext
 
     std::unique_ptr<Renderer> makeRenderer(int width, int height) override
     {
-        return std::make_unique<RiveRenderer>(m_plsContext.get());
+        return std::make_unique<RiveRenderer>(m_renderContext.get());
     }
 
     void begin(const rive::gpu::RenderContext::FrameDescriptor& frameDescriptor) override
     {
-        m_plsContext->beginFrame(frameDescriptor);
+        m_renderContext->beginFrame(frameDescriptor);
     }
 
     void flushPLSContext() final
@@ -88,7 +88,7 @@ class FiddleContextD3DPLS : public FiddleContext
                 reinterpret_cast<void**>(backbuffer.ReleaseAndGetAddressOf())));
             m_renderTarget->setTargetTexture(backbuffer);
         }
-        m_plsContext->flush({.renderTarget = m_renderTarget.get()});
+        m_renderContext->flush({.renderTarget = m_renderTarget.get()});
     }
 
     void end(GLFWwindow*, std::vector<uint8_t>* pixelData = nullptr) override
@@ -138,7 +138,7 @@ class FiddleContextD3DPLS : public FiddleContext
     ComPtr<ID3D11DeviceContext> m_gpuContext;
     ComPtr<IDXGISwapChain1> m_swapchain;
     ComPtr<ID3D11Texture2D> m_readbackTexture;
-    std::unique_ptr<RenderContext> m_plsContext;
+    std::unique_ptr<RenderContext> m_renderContext;
     rcp<RenderTargetD3D> m_renderTarget;
 };
 
diff --git a/renderer/path_fiddle/fiddle_context_dawn.cpp b/renderer/path_fiddle/fiddle_context_dawn.cpp
index 334c9b62..fa9c32fd 100644
--- a/renderer/path_fiddle/fiddle_context_dawn.cpp
+++ b/renderer/path_fiddle/fiddle_context_dawn.cpp
@@ -160,7 +160,7 @@ class FiddleContextDawnPLS : public FiddleContext
         backendProcs.deviceSetLoggingCallback(m_backendDevice, device_log_callback, nullptr);
         m_device = wgpu::Device::Acquire(m_backendDevice);
         m_queue = m_device.GetQueue();
-        m_plsContext =
+        m_renderContext =
             RenderContextWebGPUImpl::MakeContext(m_device,
                                                  m_queue,
                                                  RenderContextWebGPUImpl::ContextOptions());
@@ -171,11 +171,11 @@ class FiddleContextDawnPLS : public FiddleContext
         return GetDawnWindowBackingScaleFactor(window, m_options.retinaDisplay);
     }
 
-    Factory* factory() override { return m_plsContext.get(); }
+    Factory* factory() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderContext* plsContextOrNull() override { return m_plsContext.get(); }
+    rive::gpu::RenderContext* renderContextOrNull() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderTarget* plsRenderTargetOrNull() override { return m_renderTarget.get(); }
+    rive::gpu::RenderTarget* renderTargetOrNull() override { return m_renderTarget.get(); }
 
     void onSizeChanged(GLFWwindow* window, int width, int height, uint32_t sampleCount) override
     {
@@ -205,7 +205,7 @@ class FiddleContextDawnPLS : public FiddleContext
             backendProcs.deviceCreateSwapChain(m_backendDevice, surface, &swapChainDesc);
         m_swapchain = wgpu::SwapChain::Acquire(backendSwapChain);
 
-        m_renderTarget = m_plsContext->static_impl_cast<RenderContextWebGPUImpl>()
+        m_renderTarget = m_renderContext->static_impl_cast<RenderContextWebGPUImpl>()
                              ->makeRenderTarget(wgpu::TextureFormat::BGRA8Unorm, width, height);
         m_pixelReadBuff = {};
     }
@@ -214,7 +214,7 @@ class FiddleContextDawnPLS : public FiddleContext
 
     std::unique_ptr<Renderer> makeRenderer(int width, int height) override
     {
-        return std::make_unique<RiveRenderer>(m_plsContext.get());
+        return std::make_unique<RiveRenderer>(m_renderContext.get());
     }
 
     void begin(const RenderContext::FrameDescriptor& frameDescriptor) override
@@ -222,10 +222,10 @@ class FiddleContextDawnPLS : public FiddleContext
         assert(m_swapchain.GetCurrentTexture().GetWidth() == m_renderTarget->width());
         assert(m_swapchain.GetCurrentTexture().GetHeight() == m_renderTarget->height());
         m_renderTarget->setTargetTextureView(m_swapchain.GetCurrentTextureView());
-        m_plsContext->beginFrame(std::move(frameDescriptor));
+        m_renderContext->beginFrame(std::move(frameDescriptor));
     }
 
-    void flushPLSContext() final { m_plsContext->flush({.renderTarget = m_renderTarget.get()}); }
+    void flushPLSContext() final { m_renderContext->flush({.renderTarget = m_renderTarget.get()}); }
 
     void end(GLFWwindow* window, std::vector<uint8_t>* pixelData) final
     {
@@ -327,7 +327,7 @@ class FiddleContextDawnPLS : public FiddleContext
     wgpu::Queue m_queue = {};
     wgpu::SwapChain m_swapchain = {};
     std::unique_ptr<dawn::native::Instance> m_instance;
-    std::unique_ptr<RenderContext> m_plsContext;
+    std::unique_ptr<RenderContext> m_renderContext;
     rcp<RenderTargetWebGPU> m_renderTarget;
     wgpu::Buffer m_pixelReadBuff;
 };
diff --git a/renderer/path_fiddle/fiddle_context_gl.cpp b/renderer/path_fiddle/fiddle_context_gl.cpp
index 459578da..5e744a13 100644
--- a/renderer/path_fiddle/fiddle_context_gl.cpp
+++ b/renderer/path_fiddle/fiddle_context_gl.cpp
@@ -202,18 +202,18 @@ class FiddleContextGLPLS : public FiddleContextGL
 public:
     FiddleContextGLPLS()
     {
-        if (!m_plsContext)
+        if (!m_renderContext)
         {
             fprintf(stderr, "Failed to create a PLS renderer.\n");
             abort();
         }
     }
 
-    rive::Factory* factory() override { return m_plsContext.get(); }
+    rive::Factory* factory() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderContext* plsContextOrNull() override { return m_plsContext.get(); }
+    rive::gpu::RenderContext* renderContextOrNull() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderTarget* plsRenderTargetOrNull() override { return m_renderTarget.get(); }
+    rive::gpu::RenderTarget* renderTargetOrNull() override { return m_renderTarget.get(); }
 
     void onSizeChanged(GLFWwindow* window, int width, int height, uint32_t sampleCount) override
     {
@@ -222,25 +222,28 @@ class FiddleContextGLPLS : public FiddleContextGL
 
     std::unique_ptr<Renderer> makeRenderer(int width, int height) override
     {
-        return std::make_unique<RiveRenderer>(m_plsContext.get());
+        return std::make_unique<RiveRenderer>(m_renderContext.get());
     }
 
     void begin(const RenderContext::FrameDescriptor& frameDescriptor) override
     {
-        m_plsContext->static_impl_cast<RenderContextGLImpl>()->invalidateGLState();
-        m_plsContext->beginFrame(frameDescriptor);
+        m_renderContext->static_impl_cast<RenderContextGLImpl>()->invalidateGLState();
+        m_renderContext->beginFrame(frameDescriptor);
     }
 
     void onEnd() override
     {
         flushPLSContext();
-        m_plsContext->static_impl_cast<RenderContextGLImpl>()->unbindGLInternalResources();
+        m_renderContext->static_impl_cast<RenderContextGLImpl>()->unbindGLInternalResources();
     }
 
-    void flushPLSContext() override { m_plsContext->flush({.renderTarget = m_renderTarget.get()}); }
+    void flushPLSContext() override
+    {
+        m_renderContext->flush({.renderTarget = m_renderTarget.get()});
+    }
 
 private:
-    std::unique_ptr<RenderContext> m_plsContext =
+    std::unique_ptr<RenderContext> m_renderContext =
         RenderContextGLImpl::MakeContext(RenderContextGLImpl::ContextOptions());
     rcp<RenderTargetGL> m_renderTarget;
 };
@@ -288,9 +291,9 @@ class FiddleContextGLSkia : public FiddleContextGL
 
     rive::Factory* factory() override { return &m_factory; }
 
-    rive::gpu::RenderContext* plsContextOrNull() override { return nullptr; }
+    rive::gpu::RenderContext* renderContextOrNull() override { return nullptr; }
 
-    rive::gpu::RenderTarget* plsRenderTargetOrNull() override { return nullptr; }
+    rive::gpu::RenderTarget* renderTargetOrNull() override { return nullptr; }
 
     std::unique_ptr<Renderer> makeRenderer(int width, int height) override
     {
diff --git a/renderer/path_fiddle/fiddle_context_metal.mm b/renderer/path_fiddle/fiddle_context_metal.mm
index 997ffe0d..608fd260 100644
--- a/renderer/path_fiddle/fiddle_context_metal.mm
+++ b/renderer/path_fiddle/fiddle_context_metal.mm
@@ -33,7 +33,7 @@
             // sure we test every unique shader.
             metalOptions.disableFramebufferReads = true;
         }
-        m_plsContext = RenderContextMetalImpl::MakeContext(m_gpu, metalOptions);
+        m_renderContext = RenderContextMetalImpl::MakeContext(m_gpu, metalOptions);
         printf("==== MTLDevice: %s ====\n", m_gpu.name.UTF8String);
     }
 
@@ -43,11 +43,11 @@ float dpiScale(GLFWwindow* window) const override
         return m_fiddleOptions.retinaDisplay ? nsWindow.backingScaleFactor : 1;
     }
 
-    Factory* factory() override { return m_plsContext.get(); }
+    Factory* factory() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderContext* plsContextOrNull() override { return m_plsContext.get(); }
+    rive::gpu::RenderContext* renderContextOrNull() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderTarget* plsRenderTargetOrNull() override { return m_renderTarget.get(); }
+    rive::gpu::RenderTarget* renderTargetOrNull() override { return m_renderTarget.get(); }
 
     void onSizeChanged(GLFWwindow* window, int width, int height, uint32_t sampleCount) override
     {
@@ -64,8 +64,9 @@ void onSizeChanged(GLFWwindow* window, int width, int height, uint32_t sampleCou
         m_swapchain.displaySyncEnabled = NO;
         view.layer = m_swapchain;
 
-        auto plsContextImpl = m_plsContext->static_impl_cast<RenderContextMetalImpl>();
-        m_renderTarget = plsContextImpl->makeRenderTarget(MTLPixelFormatBGRA8Unorm, width, height);
+        auto renderContextImpl = m_renderContext->static_impl_cast<RenderContextMetalImpl>();
+        m_renderTarget =
+            renderContextImpl->makeRenderTarget(MTLPixelFormatBGRA8Unorm, width, height);
         m_pixelReadBuff = nil;
     }
 
@@ -73,12 +74,12 @@ void toggleZoomWindow() override {}
 
     std::unique_ptr<Renderer> makeRenderer(int width, int height) override
     {
-        return std::make_unique<RiveRenderer>(m_plsContext.get());
+        return std::make_unique<RiveRenderer>(m_renderContext.get());
     }
 
     void begin(const RenderContext::FrameDescriptor& frameDescriptor) override
     {
-        m_plsContext->beginFrame(frameDescriptor);
+        m_renderContext->beginFrame(frameDescriptor);
     }
 
     void flushPLSContext() final
@@ -92,8 +93,8 @@ void flushPLSContext() final
         }
 
         id<MTLCommandBuffer> flushCommandBuffer = [m_queue commandBuffer];
-        m_plsContext->flush({.renderTarget = m_renderTarget.get(),
-                             .externalCommandBuffer = (__bridge void*)flushCommandBuffer});
+        m_renderContext->flush({.renderTarget = m_renderTarget.get(),
+                                .externalCommandBuffer = (__bridge void*)flushCommandBuffer});
         [flushCommandBuffer commit];
     }
 
@@ -165,7 +166,7 @@ void end(GLFWwindow* window, std::vector<uint8_t>* pixelData) final
     const FiddleContextOptions m_fiddleOptions;
     id<MTLDevice> m_gpu = MTLCreateSystemDefaultDevice();
     id<MTLCommandQueue> m_queue = [m_gpu newCommandQueue];
-    std::unique_ptr<RenderContext> m_plsContext;
+    std::unique_ptr<RenderContext> m_renderContext;
     CAMetalLayer* m_swapchain;
     rcp<RenderTargetMetal> m_renderTarget;
     id<MTLBuffer> m_pixelReadBuff;
diff --git a/renderer/path_fiddle/fiddle_context_vulkan.cpp b/renderer/path_fiddle/fiddle_context_vulkan.cpp
index 992659c5..75cd9847 100644
--- a/renderer/path_fiddle/fiddle_context_vulkan.cpp
+++ b/renderer/path_fiddle/fiddle_context_vulkan.cpp
@@ -81,12 +81,12 @@ class FiddleContextVulkanPLS : public FiddleContext
                 m_vkDispatch.allocateCommandBuffers(&commandBufferAllocateInfo, &commandBuffer));
         }
 
-        m_plsContext = RenderContextVulkanImpl::MakeContext(m_instance,
-                                                            m_physicalDevice,
-                                                            m_device,
-                                                            vulkanFeatures,
-                                                            m_instance.fp_vkGetInstanceProcAddr,
-                                                            m_instance.fp_vkGetDeviceProcAddr);
+        m_renderContext = RenderContextVulkanImpl::MakeContext(m_instance,
+                                                               m_physicalDevice,
+                                                               m_device,
+                                                               vulkanFeatures,
+                                                               m_instance.fp_vkGetInstanceProcAddr,
+                                                               m_instance.fp_vkGetDeviceProcAddr);
 
         VkSemaphoreCreateInfo semaphoreCreateInfo = {
             .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
@@ -102,7 +102,7 @@ class FiddleContextVulkanPLS : public FiddleContext
     ~FiddleContextVulkanPLS()
     {
         // Destroy these before destroying the VkDevice.
-        m_plsContext.reset();
+        m_renderContext.reset();
         m_renderTarget.reset();
         m_pixelReadBuffer.reset();
         m_swapchainImageViews.clear();
@@ -142,11 +142,11 @@ class FiddleContextVulkanPLS : public FiddleContext
 #endif
     }
 
-    Factory* factory() override { return m_plsContext.get(); }
+    Factory* factory() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderContext* plsContextOrNull() override { return m_plsContext.get(); }
+    rive::gpu::RenderContext* renderContextOrNull() override { return m_renderContext.get(); }
 
-    rive::gpu::RenderTarget* plsRenderTargetOrNull() override { return m_renderTarget.get(); }
+    rive::gpu::RenderTarget* renderTargetOrNull() override { return m_renderTarget.get(); }
 
     void onSizeChanged(GLFWwindow* window, int width, int height, uint32_t sampleCount) override
     {
@@ -232,7 +232,7 @@ class FiddleContextVulkanPLS : public FiddleContext
 
     std::unique_ptr<Renderer> makeRenderer(int width, int height) override
     {
-        return std::make_unique<RiveRenderer>(m_plsContext.get());
+        return std::make_unique<RiveRenderer>(m_renderContext.get());
     }
 
     void begin(const RenderContext::FrameDescriptor& frameDescriptor) override
@@ -243,7 +243,7 @@ class FiddleContextVulkanPLS : public FiddleContext
                                          VK_NULL_HANDLE,
                                          &m_swapchainImageIndex);
 
-        m_plsContext->beginFrame(std::move(frameDescriptor));
+        m_renderContext->beginFrame(std::move(frameDescriptor));
 
         VkCommandBuffer commandBuffer = m_commandBuffers[m_resourcePoolIdx];
         m_vkDispatch.resetCommandBuffer(commandBuffer, {});
@@ -263,7 +263,7 @@ class FiddleContextVulkanPLS : public FiddleContext
 
     void flushPLSContext() final
     {
-        m_plsContext->flush({
+        m_renderContext->flush({
             .renderTarget = m_renderTarget.get(),
             .externalCommandBuffer = m_commandBuffers[m_resourcePoolIdx],
             .frameCompletionFence = m_frameFence.get(),
@@ -377,7 +377,7 @@ class FiddleContextVulkanPLS : public FiddleContext
 private:
     RenderContextVulkanImpl* impl() const
     {
-        return m_plsContext->static_impl_cast<RenderContextVulkanImpl>();
+        return m_renderContext->static_impl_cast<RenderContextVulkanImpl>();
     }
 
     VulkanContext* vk() const { return impl()->vulkanContext(); }
@@ -413,7 +413,7 @@ class FiddleContextVulkanPLS : public FiddleContext
     rcp<VulkanFencePool> m_fencePool;
     rcp<VulkanFence> m_frameFence;
 
-    std::unique_ptr<RenderContext> m_plsContext;
+    std::unique_ptr<RenderContext> m_renderContext;
     rcp<RenderTargetVulkan> m_renderTarget;
     rcp<vkutil::Buffer> m_pixelReadBuffer;
 
diff --git a/renderer/src/d3d/render_context_d3d_impl.cpp b/renderer/src/d3d/render_context_d3d_impl.cpp
index 6e9fb80c..37995b71 100644
--- a/renderer/src/d3d/render_context_d3d_impl.cpp
+++ b/renderer/src/d3d/render_context_d3d_impl.cpp
@@ -4,7 +4,7 @@
 
 #include "rive/renderer/d3d/render_context_d3d_impl.hpp"
 
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "shaders/constants.glsl"
 
 #include <D3DCompiler.h>
@@ -132,9 +132,9 @@ std::unique_ptr<RenderContext> RenderContextD3DImpl::MakeContext(
 
     d3dCapabilities.isIntel = contextOptions.isIntel;
 
-    auto plsContextImpl = std::unique_ptr<RenderContextD3DImpl>(
+    auto renderContextImpl = std::unique_ptr<RenderContextD3DImpl>(
         new RenderContextD3DImpl(std::move(gpu), std::move(gpuContext), d3dCapabilities));
-    return std::make_unique<RenderContext>(std::move(plsContextImpl));
+    return std::make_unique<RenderContext>(std::move(renderContextImpl));
 }
 
 RenderContextD3DImpl::RenderContextD3DImpl(ComPtr<ID3D11Device> gpu,
@@ -520,20 +520,20 @@ rcp<RenderBuffer> RenderContextD3DImpl::makeRenderBuffer(RenderBufferType type,
 class TextureD3DImpl : public Texture
 {
 public:
-    TextureD3DImpl(RenderContextD3DImpl* plsImpl,
+    TextureD3DImpl(RenderContextD3DImpl* renderContextImpl,
                    UINT width,
                    UINT height,
                    UINT mipLevelCount,
                    const uint8_t imageDataRGBA[]) :
         Texture(width, height)
     {
-        m_texture =
-            plsImpl->makeSimple2DTexture(DXGI_FORMAT_R8G8B8A8_UNORM,
-                                         width,
-                                         height,
-                                         mipLevelCount,
-                                         D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET,
-                                         D3D11_RESOURCE_MISC_GENERATE_MIPS);
+        m_texture = renderContextImpl->makeSimple2DTexture(DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                           width,
+                                                           height,
+                                                           mipLevelCount,
+                                                           D3D11_BIND_SHADER_RESOURCE |
+                                                               D3D11_BIND_RENDER_TARGET,
+                                                           D3D11_RESOURCE_MISC_GENERATE_MIPS);
 
         // Specify the top-level image in the mipmap chain.
         D3D11_BOX box;
@@ -543,14 +543,15 @@ class TextureD3DImpl : public Texture
         box.bottom = height;
         box.front = 0;
         box.back = 1;
-        plsImpl->gpuContext()
+        renderContextImpl->gpuContext()
             ->UpdateSubresource(m_texture.Get(), 0, &box, imageDataRGBA, width * 4, 0);
 
         // Create a view and generate mipmaps.
-        VERIFY_OK(plsImpl->gpu()->CreateShaderResourceView(m_texture.Get(),
-                                                           NULL,
-                                                           m_srv.ReleaseAndGetAddressOf()));
-        plsImpl->gpuContext()->GenerateMips(m_srv.Get());
+        VERIFY_OK(
+            renderContextImpl->gpu()->CreateShaderResourceView(m_texture.Get(),
+                                                               NULL,
+                                                               m_srv.ReleaseAndGetAddressOf()));
+        renderContextImpl->gpuContext()->GenerateMips(m_srv.Get());
     }
 
     ID3D11ShaderResourceView* srv() const { return m_srv.Get(); }
@@ -572,19 +573,19 @@ rcp<Texture> RenderContextD3DImpl::makeImageTexture(uint32_t width,
 class BufferRingD3D : public BufferRing
 {
 public:
-    BufferRingD3D(RenderContextD3DImpl* plsImpl, size_t capacityInBytes, UINT bindFlags) :
-        BufferRingD3D(plsImpl, capacityInBytes, bindFlags, 0, 0)
+    BufferRingD3D(RenderContextD3DImpl* renderContextImpl, size_t capacityInBytes, UINT bindFlags) :
+        BufferRingD3D(renderContextImpl, capacityInBytes, bindFlags, 0, 0)
     {}
 
     ID3D11Buffer* submittedBuffer() const { return m_buffers[submittedBufferIdx()].Get(); }
 
 protected:
-    BufferRingD3D(RenderContextD3DImpl* plsImpl,
+    BufferRingD3D(RenderContextD3DImpl* renderContextImpl,
                   size_t capacityInBytes,
                   UINT bindFlags,
                   UINT elementSizeInBytes,
                   UINT miscFlags) :
-        BufferRing(capacityInBytes), m_gpuContext(plsImpl->gpuContext())
+        BufferRing(capacityInBytes), m_gpuContext(renderContextImpl->gpuContext())
     {
         D3D11_BUFFER_DESC desc{};
         desc.ByteWidth = math::lossless_numeric_cast<UINT>(capacityInBytes);
@@ -596,9 +597,8 @@ class BufferRingD3D : public BufferRing
 
         for (size_t i = 0; i < kBufferRingSize; ++i)
         {
-            VERIFY_OK(plsImpl->gpu()->CreateBuffer(&desc,
-                                                   nullptr,
-                                                   m_buffers[i].ReleaseAndGetAddressOf()));
+            VERIFY_OK(renderContextImpl->gpu()
+                          ->CreateBuffer(&desc, nullptr, m_buffers[i].ReleaseAndGetAddressOf()));
         }
     }
 
@@ -638,10 +638,10 @@ class BufferRingD3D : public BufferRing
 class StructuredBufferRingD3D : public BufferRingD3D
 {
 public:
-    StructuredBufferRingD3D(RenderContextD3DImpl* plsImpl,
+    StructuredBufferRingD3D(RenderContextD3DImpl* renderContextImpl,
                             size_t capacityInBytes,
                             UINT elementSizeInBytes) :
-        BufferRingD3D(plsImpl,
+        BufferRingD3D(renderContextImpl,
                       capacityInBytes,
                       D3D11_BIND_SHADER_RESOURCE,
                       elementSizeInBytes,
@@ -702,10 +702,12 @@ std::unique_ptr<BufferRing> RenderContextD3DImpl::makeTextureTransferBufferRing(
     return std::make_unique<HeapBufferRing>(capacityInBytes);
 }
 
-RenderTargetD3D::RenderTargetD3D(RenderContextD3DImpl* plsImpl, uint32_t width, uint32_t height) :
+RenderTargetD3D::RenderTargetD3D(RenderContextD3DImpl* renderContextImpl,
+                                 uint32_t width,
+                                 uint32_t height) :
     RenderTarget(width, height),
-    m_gpu(plsImpl->gpu()),
-    m_gpuSupportsTypedUAVLoadStore(plsImpl->d3dCapabilities().supportsTypedUAVLoadStore)
+    m_gpu(renderContextImpl->gpu()),
+    m_gpuSupportsTypedUAVLoadStore(renderContextImpl->d3dCapabilities().supportsTypedUAVLoadStore)
 {}
 
 void RenderTargetD3D::setTargetTexture(ComPtr<ID3D11Texture2D> tex)
diff --git a/renderer/src/draw.cpp b/renderer/src/draw.cpp
index 7de9b2ec..19c37ef5 100644
--- a/renderer/src/draw.cpp
+++ b/renderer/src/draw.cpp
@@ -9,7 +9,7 @@
 #include "rive_render_path.hpp"
 #include "rive_render_paint.hpp"
 #include "rive/math/wangs_formula.hpp"
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "shaders/constants.glsl"
 
 namespace rive::gpu
diff --git a/renderer/src/gl/pls_impl_framebuffer_fetch.cpp b/renderer/src/gl/pls_impl_framebuffer_fetch.cpp
index b5c02c40..6f9bb2fb 100644
--- a/renderer/src/gl/pls_impl_framebuffer_fetch.cpp
+++ b/renderer/src/gl/pls_impl_framebuffer_fetch.cpp
@@ -34,10 +34,10 @@ class RenderContextGLImpl::PLSImplFramebufferFetch
         return capabilities.QCOM_shader_framebuffer_fetch_noncoherent;
     }
 
-    void activatePixelLocalStorage(RenderContextGLImpl* plsContextImpl,
+    void activatePixelLocalStorage(RenderContextGLImpl* renderContextImpl,
                                    const FlushDescriptor& desc) override
     {
-        assert(plsContextImpl->m_capabilities.EXT_shader_framebuffer_fetch);
+        assert(renderContextImpl->m_capabilities.EXT_shader_framebuffer_fetch);
 
         auto renderTarget = static_cast<RenderTargetGL*>(desc.renderTarget);
         renderTarget->allocateInternalPLSTextures(desc.interlockMode);
@@ -106,7 +106,7 @@ class RenderContextGLImpl::PLSImplFramebufferFetch
         if (desc.interlockMode == gpu::InterlockMode::atomics &&
             !(desc.combinedShaderFeatures & gpu::ShaderFeatures::ENABLE_CLIP_RECT))
         {
-            plsContextImpl->state()->setBlendEquation(BlendMode::srcOver);
+            renderContextImpl->state()->setBlendEquation(BlendMode::srcOver);
         }
 
         if (desc.interlockMode == gpu::InterlockMode::atomics)
diff --git a/renderer/src/gl/pls_impl_rw_texture.cpp b/renderer/src/gl/pls_impl_rw_texture.cpp
index b9f6ac88..f987d0fa 100644
--- a/renderer/src/gl/pls_impl_rw_texture.cpp
+++ b/renderer/src/gl/pls_impl_rw_texture.cpp
@@ -41,7 +41,7 @@ class RenderContextGLImpl::PLSImplRWTexture : public RenderContextGLImpl::PixelL
         return true;
     }
 
-    void activatePixelLocalStorage(RenderContextGLImpl* plsContextImpl,
+    void activatePixelLocalStorage(RenderContextGLImpl* renderContextImpl,
                                    const FlushDescriptor& desc) override
     {
         auto renderTarget = static_cast<RenderTargetGL*>(desc.renderTarget);
@@ -50,7 +50,7 @@ class RenderContextGLImpl::PLSImplRWTexture : public RenderContextGLImpl::PixelL
         if (desc.interlockMode == gpu::InterlockMode::atomics &&
             needs_atomic_fixed_function_color_blend(desc))
         {
-            plsContextImpl->state()->setBlendEquation(BlendMode::srcOver);
+            renderContextImpl->state()->setBlendEquation(BlendMode::srcOver);
         }
         else if (auto framebufferRenderTarget =
                      lite_rtti_cast<FramebufferRenderTargetGL*>(renderTarget))
@@ -107,7 +107,7 @@ class RenderContextGLImpl::PLSImplRWTexture : public RenderContextGLImpl::PixelL
             case gpu::InterlockMode::rasterOrdering:
                 // rasterOrdering mode renders by storing to an image texture. Bind a framebuffer
                 // with no color attachments.
-                renderTarget->bindHeadlessFramebuffer(plsContextImpl->m_capabilities);
+                renderTarget->bindHeadlessFramebuffer(renderContextImpl->m_capabilities);
                 break;
             case gpu::InterlockMode::atomics:
                 renderTarget->bindDestinationFramebuffer(GL_FRAMEBUFFER);
@@ -124,7 +124,7 @@ class RenderContextGLImpl::PLSImplRWTexture : public RenderContextGLImpl::PixelL
                 {
                     // When rendering to an offscreen atomic texture, still bind the target
                     // framebuffer, but disable color writes until it's time to resolve.
-                    plsContextImpl->state()->setWriteMasks(false, true, 0xff);
+                    renderContextImpl->state()->setWriteMasks(false, true, 0xff);
                 }
                 break;
             default:
@@ -155,14 +155,14 @@ class RenderContextGLImpl::PLSImplRWTexture : public RenderContextGLImpl::PixelL
         return flags;
     }
 
-    void setupAtomicResolve(RenderContextGLImpl* plsContextImpl,
+    void setupAtomicResolve(RenderContextGLImpl* renderContextImpl,
                             const gpu::FlushDescriptor& desc) override
     {
         assert(desc.interlockMode == gpu::InterlockMode::atomics);
         if (needs_coalesced_atomic_resolve_and_transfer(desc))
         {
             // Turn the color mask back on now that we're about to resolve.
-            plsContextImpl->state()->setWriteMasks(true, true, 0xff);
+            renderContextImpl->state()->setWriteMasks(true, true, 0xff);
         }
     }
 
diff --git a/renderer/src/gl/pls_impl_webgl.cpp b/renderer/src/gl/pls_impl_webgl.cpp
index 6a72c234..1e01f0ce 100644
--- a/renderer/src/gl/pls_impl_webgl.cpp
+++ b/renderer/src/gl/pls_impl_webgl.cpp
@@ -172,7 +172,7 @@ class RenderContextGLImpl::PLSImplWebGL : public RenderContextGLImpl::PixelLocal
         return false;
     }
 
-    void activatePixelLocalStorage(RenderContextGLImpl* plsContextImpl,
+    void activatePixelLocalStorage(RenderContextGLImpl* renderContextImpl,
                                    const FlushDescriptor& desc) override
     {
         auto renderTarget = static_cast<RenderTargetGL*>(desc.renderTarget);
@@ -195,7 +195,7 @@ class RenderContextGLImpl::PLSImplWebGL : public RenderContextGLImpl::PixelLocal
         }
 
         // Begin pixel local storage.
-        renderTarget->bindHeadlessFramebuffer(plsContextImpl->m_capabilities);
+        renderTarget->bindHeadlessFramebuffer(renderContextImpl->m_capabilities);
         if (desc.colorLoadAction == LoadAction::clear)
         {
             float clearColor4f[4];
diff --git a/renderer/src/gl/render_context_gl_impl.cpp b/renderer/src/gl/render_context_gl_impl.cpp
index b2c6ef38..cbb6ed0d 100644
--- a/renderer/src/gl/render_context_gl_impl.cpp
+++ b/renderer/src/gl/render_context_gl_impl.cpp
@@ -7,7 +7,7 @@
 #include "rive/renderer/gl/render_buffer_gl_impl.hpp"
 #include "rive/renderer/gl/render_target_gl.hpp"
 #include "rive/renderer/draw.hpp"
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "shaders/constants.glsl"
 
 #include "generated/shaders/advanced_blend.glsl.hpp"
@@ -613,7 +613,7 @@ void RenderContextGLImpl::resizeTessellationTexture(uint32_t width, uint32_t hei
                            0);
 }
 
-RenderContextGLImpl::DrawShader::DrawShader(RenderContextGLImpl* plsContextImpl,
+RenderContextGLImpl::DrawShader::DrawShader(RenderContextGLImpl* renderContextImpl,
                                             GLenum shaderType,
                                             gpu::DrawType drawType,
                                             ShaderFeatures shaderFeatures,
@@ -629,9 +629,9 @@ RenderContextGLImpl::DrawShader::DrawShader(RenderContextGLImpl* plsContextImpl,
 #endif
 
     std::vector<const char*> defines;
-    if (plsContextImpl->m_plsImpl != nullptr)
+    if (renderContextImpl->m_plsImpl != nullptr)
     {
-        plsContextImpl->m_plsImpl->pushShaderDefines(interlockMode, &defines);
+        renderContextImpl->m_plsImpl->pushShaderDefines(interlockMode, &defines);
     }
     if (interlockMode == gpu::InterlockMode::atomics)
     {
@@ -650,7 +650,7 @@ RenderContextGLImpl::DrawShader::DrawShader(RenderContextGLImpl* plsContextImpl,
             assert((kVertexShaderFeaturesMask & feature) || shaderType == GL_FRAGMENT_SHADER);
             if (interlockMode == gpu::InterlockMode::depthStencil &&
                 feature == gpu::ShaderFeatures::ENABLE_ADVANCED_BLEND &&
-                plsContextImpl->m_capabilities.KHR_blend_equation_advanced_coherent)
+                renderContextImpl->m_capabilities.KHR_blend_equation_advanced_coherent)
             {
                 defines.push_back(GLSL_ENABLE_KHR_BLEND);
             }
@@ -673,7 +673,7 @@ RenderContextGLImpl::DrawShader::DrawShader(RenderContextGLImpl* plsContextImpl,
     {
         sources.push_back(glsl::advanced_blend);
     }
-    if (plsContextImpl->platformFeatures().avoidFlatVaryings)
+    if (renderContextImpl->platformFeatures().avoidFlatVaryings)
     {
         sources.push_back("#define " GLSL_OPTIONALLY_FLAT "\n");
     }
@@ -688,7 +688,8 @@ RenderContextGLImpl::DrawShader::DrawShader(RenderContextGLImpl* plsContextImpl,
             if (shaderType == GL_VERTEX_SHADER)
             {
                 defines.push_back(GLSL_ENABLE_INSTANCE_INDEX);
-                if (!plsContextImpl->m_capabilities.ANGLE_base_vertex_base_instance_shader_builtin)
+                if (!renderContextImpl->m_capabilities
+                         .ANGLE_base_vertex_base_instance_shader_builtin)
                 {
                     defines.push_back(GLSL_ENABLE_SPIRV_CROSS_BASE_INSTANCE);
                 }
@@ -736,11 +737,11 @@ RenderContextGLImpl::DrawShader::DrawShader(RenderContextGLImpl* plsContextImpl,
             assert(interlockMode == gpu::InterlockMode::atomics);
             RIVE_UNREACHABLE();
     }
-    if (plsContextImpl->m_capabilities.ARB_bindless_texture)
+    if (renderContextImpl->m_capabilities.ARB_bindless_texture)
     {
         defines.push_back(GLSL_ENABLE_BINDLESS_TEXTURES);
     }
-    if (!plsContextImpl->m_capabilities.ARB_shader_storage_buffer_object)
+    if (!renderContextImpl->m_capabilities.ARB_shader_storage_buffer_object)
     {
         defines.push_back(GLSL_DISABLE_SHADER_STORAGE_BUFFERS);
     }
@@ -750,21 +751,21 @@ RenderContextGLImpl::DrawShader::DrawShader(RenderContextGLImpl* plsContextImpl,
                                   defines.size(),
                                   sources.data(),
                                   sources.size(),
-                                  plsContextImpl->m_capabilities);
+                                  renderContextImpl->m_capabilities);
 }
 
-RenderContextGLImpl::DrawProgram::DrawProgram(RenderContextGLImpl* plsContextImpl,
+RenderContextGLImpl::DrawProgram::DrawProgram(RenderContextGLImpl* renderContextImpl,
                                               gpu::DrawType drawType,
                                               gpu::ShaderFeatures shaderFeatures,
                                               gpu::InterlockMode interlockMode,
                                               gpu::ShaderMiscFlags fragmentShaderMiscFlags) :
-    m_fragmentShader(plsContextImpl,
+    m_fragmentShader(renderContextImpl,
                      GL_FRAGMENT_SHADER,
                      drawType,
                      shaderFeatures,
                      interlockMode,
                      fragmentShaderMiscFlags),
-    m_state(plsContextImpl->m_state)
+    m_state(renderContextImpl->m_state)
 {
     // Not every vertex shader is unique. Cache them by just the vertex features and reuse when
     // possible.
@@ -773,9 +774,9 @@ RenderContextGLImpl::DrawProgram::DrawProgram(RenderContextGLImpl* plsContextImp
                                                     vertexShaderFeatures,
                                                     interlockMode,
                                                     gpu::ShaderMiscFlags::none);
-    const DrawShader& vertexShader = plsContextImpl->m_vertexShaders
+    const DrawShader& vertexShader = renderContextImpl->m_vertexShaders
                                          .try_emplace(vertexShaderKey,
-                                                      plsContextImpl,
+                                                      renderContextImpl,
                                                       GL_VERTEX_SHADER,
                                                       drawType,
                                                       vertexShaderFeatures,
@@ -800,7 +801,7 @@ RenderContextGLImpl::DrawProgram::DrawProgram(RenderContextGLImpl* plsContextImp
     }
     glUniform1i(glGetUniformLocation(m_id, GLSL_tessVertexTexture),
                 kPLSTexIdxOffset + TESS_VERTEX_TEXTURE_IDX);
-    if (!plsContextImpl->m_capabilities.ARB_shader_storage_buffer_object)
+    if (!renderContextImpl->m_capabilities.ARB_shader_storage_buffer_object)
     {
         // Our GL driver doesn't support storage buffers. We polyfill these buffers as textures.
         glUniform1i(glGetUniformLocation(m_id, GLSL_pathBuffer),
@@ -817,12 +818,12 @@ RenderContextGLImpl::DrawProgram::DrawProgram(RenderContextGLImpl* plsContextImp
                 kPLSTexIdxOffset + IMAGE_TEXTURE_IDX);
     if (interlockMode == gpu::InterlockMode::depthStencil &&
         (shaderFeatures & gpu::ShaderFeatures::ENABLE_ADVANCED_BLEND) &&
-        !plsContextImpl->m_capabilities.KHR_blend_equation_advanced_coherent)
+        !renderContextImpl->m_capabilities.KHR_blend_equation_advanced_coherent)
     {
         glUniform1i(glGetUniformLocation(m_id, GLSL_dstColorTexture),
                     kPLSTexIdxOffset + DST_COLOR_TEXTURE_IDX);
     }
-    if (!plsContextImpl->m_capabilities.ANGLE_base_vertex_base_instance_shader_builtin)
+    if (!renderContextImpl->m_capabilities.ANGLE_base_vertex_base_instance_shader_builtin)
     {
         // This uniform is specifically named "SPIRV_Cross_BaseInstance" for compatibility with
         // SPIRV-Cross sytems.
@@ -858,11 +859,11 @@ static void bind_storage_buffer(const GLCapabilities& capabilities,
 }
 
 void RenderContextGLImpl::PixelLocalStorageImpl::ensureRasterOrderingEnabled(
-    RenderContextGLImpl* plsContextImpl,
+    RenderContextGLImpl* renderContextImpl,
     const gpu::FlushDescriptor& desc,
     bool enabled)
 {
-    assert(!enabled || supportsRasterOrdering(plsContextImpl->m_capabilities));
+    assert(!enabled || supportsRasterOrdering(renderContextImpl->m_capabilities));
     auto rasterOrderState = enabled ? gpu::TriState::yes : gpu::TriState::no;
     if (m_rasterOrderingEnabled != rasterOrderState)
     {
@@ -1878,8 +1879,8 @@ std::unique_ptr<RenderContext> RenderContextGLImpl::MakeContext(
     GLCapabilities capabilities,
     std::unique_ptr<PixelLocalStorageImpl> plsImpl)
 {
-    auto plsContextImpl = std::unique_ptr<RenderContextGLImpl>(
+    auto renderContextImpl = std::unique_ptr<RenderContextGLImpl>(
         new RenderContextGLImpl(rendererString, capabilities, std::move(plsImpl)));
-    return std::make_unique<RenderContext>(std::move(plsContextImpl));
+    return std::make_unique<RenderContext>(std::move(renderContextImpl));
 }
 } // namespace rive::gpu
diff --git a/renderer/src/gl/render_target_gl.cpp b/renderer/src/gl/render_target_gl.cpp
index 2f813eda..9f1a01ec 100644
--- a/renderer/src/gl/render_target_gl.cpp
+++ b/renderer/src/gl/render_target_gl.cpp
@@ -187,7 +187,7 @@ void TextureRenderTargetGL::bindAsImageTextures(DrawBufferMask drawBufferMask)
 }
 
 RenderTargetGL::MSAAResolveAction TextureRenderTargetGL::bindMSAAFramebuffer(
-    RenderContextGLImpl* plsContextGL,
+    RenderContextGLImpl* renderContextImpl,
     int sampleCount,
     const IAABB* preserveBounds,
     bool* isFBO0)
@@ -211,7 +211,7 @@ RenderTargetGL::MSAAResolveAction TextureRenderTargetGL::bindMSAAFramebuffer(
 
         glBindFramebuffer(GL_FRAMEBUFFER, m_msaaFramebuffer);
 #ifndef RIVE_WEBGL
-        if (plsContextGL->capabilities().EXT_multisampled_render_to_texture)
+        if (renderContextImpl->capabilities().EXT_multisampled_render_to_texture)
         {
             glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER,
                                                 sampleCount,
@@ -259,7 +259,7 @@ RenderTargetGL::MSAAResolveAction TextureRenderTargetGL::bindMSAAFramebuffer(
 
     glBindFramebuffer(GL_FRAMEBUFFER, m_msaaFramebuffer);
 
-    if (plsContextGL->capabilities().EXT_multisampled_render_to_texture)
+    if (renderContextImpl->capabilities().EXT_multisampled_render_to_texture)
     {
         return MSAAResolveAction::automatic; // MSAA render-to-texture resolves automatically.
     }
@@ -269,9 +269,9 @@ RenderTargetGL::MSAAResolveAction TextureRenderTargetGL::bindMSAAFramebuffer(
         {
             // The MSAA render target is offscreen. In order to preserve, we need to draw the target
             // texture into the MSAA buffer. (glBlitFramebuffer() doesn't support texture -> MSAA.)
-            plsContextGL->blitTextureToFramebufferAsDraw(m_externalTextureID,
-                                                         *preserveBounds,
-                                                         height());
+            renderContextImpl->blitTextureToFramebufferAsDraw(m_externalTextureID,
+                                                              *preserveBounds,
+                                                              height());
         }
 
         return MSAAResolveAction::framebufferBlit; // Caller must resolve this framebuffer.
@@ -323,7 +323,7 @@ void FramebufferRenderTargetGL::bindAsImageTextures(DrawBufferMask drawBufferMas
 }
 
 RenderTargetGL::MSAAResolveAction FramebufferRenderTargetGL::bindMSAAFramebuffer(
-    RenderContextGLImpl* plsContextGL,
+    RenderContextGLImpl* renderContextImpl,
     int sampleCount,
     const IAABB* preserveBounds,
     bool* isFBO0)
@@ -357,13 +357,13 @@ RenderTargetGL::MSAAResolveAction FramebufferRenderTargetGL::bindMSAAFramebuffer
             glutils::BlitFramebuffer(*preserveBounds, height()); // Step 1.
                                                                  // Step 2 will happen when we bind.
         }
-        else if (plsContextGL->capabilities().EXT_multisampled_render_to_texture)
+        else if (renderContextImpl->capabilities().EXT_multisampled_render_to_texture)
         {
             // When we have EXT_multisampled_render_to_texture, the "msaa buffer" is just the target
             // texture.
             allocateOffscreenTargetTexture();
         }
-        m_textureRenderTarget.bindMSAAFramebuffer(plsContextGL,
+        m_textureRenderTarget.bindMSAAFramebuffer(renderContextImpl,
                                                   sampleCount,
                                                   preserveBounds,
                                                   isFBO0);
diff --git a/renderer/src/metal/render_context_metal_impl.mm b/renderer/src/metal/render_context_metal_impl.mm
index bd720b41..3f305705 100644
--- a/renderer/src/metal/render_context_metal_impl.mm
+++ b/renderer/src/metal/render_context_metal_impl.mm
@@ -6,7 +6,7 @@
 
 #include "background_shader_compiler.h"
 #include "rive/renderer/buffer_ring.hpp"
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "shaders/constants.glsl"
 #include <sstream>
 
@@ -275,9 +275,9 @@ void onUnmapAndSubmitBuffer(int bufferIdx, size_t mapSizeInBytes) override {}
 std::unique_ptr<RenderContext> RenderContextMetalImpl::MakeContext(
     id<MTLDevice> gpu, const ContextOptions& contextOptions)
 {
-    auto plsContextImpl =
+    auto renderContextImpl =
         std::unique_ptr<RenderContextMetalImpl>(new RenderContextMetalImpl(gpu, contextOptions));
-    return std::make_unique<RenderContext>(std::move(plsContextImpl));
+    return std::make_unique<RenderContext>(std::move(renderContextImpl));
 }
 
 RenderContextMetalImpl::RenderContextMetalImpl(id<MTLDevice> gpu,
diff --git a/renderer/src/pls.cpp b/renderer/src/pls.cpp
index e51772c6..bd6c5d27 100644
--- a/renderer/src/pls.cpp
+++ b/renderer/src/pls.cpp
@@ -6,7 +6,7 @@
 
 #include "rive/renderer/render_target.hpp"
 #include "shaders/constants.glsl"
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "rive_render_paint.hpp"
 
 #include "generated/shaders/draw_path.exports.h"
diff --git a/renderer/src/render_context.cpp b/renderer/src/render_context.cpp
index 59aaca40..28eb6c42 100644
--- a/renderer/src/render_context.cpp
+++ b/renderer/src/render_context.cpp
@@ -8,7 +8,7 @@
 #include "intersection_board.hpp"
 #include "rive_render_paint.hpp"
 #include "rive/renderer/draw.hpp"
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "rive/renderer/render_context_impl.hpp"
 #include "shaders/constants.glsl"
 
@@ -118,7 +118,7 @@ rcp<RenderBuffer> RenderContext::makeRenderBuffer(RenderBufferType type,
 rcp<RenderImage> RenderContext::decodeImage(Span<const uint8_t> encodedBytes)
 {
     rcp<Texture> texture = m_impl->decodeImageTexture(encodedBytes);
-    return texture != nullptr ? make_rcp<Image>(std::move(texture)) : nullptr;
+    return texture != nullptr ? make_rcp<RiveRenderImage>(std::move(texture)) : nullptr;
 }
 
 void RenderContext::releaseResources()
@@ -157,7 +157,7 @@ void RenderContext::LogicalFlush::rewind()
     m_complexGradients.clear();
     m_pendingComplexColorRampDraws.clear();
     m_clips.clear();
-    m_plsDraws.clear();
+    m_draws.clear();
     m_combinedDrawBounds = {std::numeric_limits<int32_t>::max(),
                             std::numeric_limits<int32_t>::max(),
                             std::numeric_limits<int32_t>::min(),
@@ -198,9 +198,9 @@ void RenderContext::LogicalFlush::resetContainers()
 {
     m_clips.clear();
     m_clips.shrink_to_fit();
-    m_plsDraws.clear();
-    m_plsDraws.shrink_to_fit();
-    m_plsDraws.reserve(kDefaultDrawCapacity);
+    m_draws.clear();
+    m_draws.shrink_to_fit();
+    m_draws.reserve(kDefaultDrawCapacity);
 
     m_simpleGradients.rehash(0);
     m_simpleGradients.reserve(kDefaultSimpleGradientCapacity);
@@ -362,8 +362,8 @@ bool RenderContext::LogicalFlush::pushDrawBatch(DrawUniquePtr draws[], size_t dr
 
     for (size_t i = 0; i < drawCount; ++i)
     {
-        m_plsDraws.push_back(std::move(draws[i]));
-        m_combinedDrawBounds = m_combinedDrawBounds.join(m_plsDraws.back()->pixelBounds());
+        m_draws.push_back(std::move(draws[i]));
+        m_combinedDrawBounds = m_combinedDrawBounds.join(m_draws.back()->pixelBounds());
     }
 
     m_resourceCounts = countsWithNewBatch;
@@ -888,18 +888,18 @@ void RenderContext::LogicalFlush::writeResources()
     // Write out all the data for our high level draws, and build up a low-level draw list.
     if (m_ctx->frameInterlockMode() == gpu::InterlockMode::rasterOrdering)
     {
-        for (const DrawUniquePtr& draw : m_plsDraws)
+        for (const DrawUniquePtr& draw : m_draws)
         {
             draw->pushToRenderContext(this);
         }
     }
     else
     {
-        assert(m_plsDraws.size() <= kMaxReorderedDrawCount);
+        assert(m_draws.size() <= kMaxReorderedDrawCount);
 
         // Sort the draw list to optimize batching, since we can only batch non-overlapping draws.
         std::vector<int64_t>& indirectDrawList = m_ctx->m_indirectDrawList;
-        indirectDrawList.resize(m_plsDraws.size());
+        indirectDrawList.resize(m_draws.size());
 
         if (m_ctx->m_intersectionBoard == nullptr)
         {
@@ -921,11 +921,11 @@ void RenderContext::LogicalFlush::writeResources()
         constexpr static int kDrawContentsShift = 16;
         constexpr static int64_t kDrawContentsMask = 0x3fllu << kDrawContentsShift;
         constexpr static int64_t kDrawIndexMask = 0xffff;
-        for (size_t i = 0; i < m_plsDraws.size(); ++i)
+        for (size_t i = 0; i < m_draws.size(); ++i)
         {
-            Draw* draw = m_plsDraws[i].get();
+            Draw* draw = m_draws[i].get();
 
-            int4 drawBounds = simd::load4i(&m_plsDraws[i]->pixelBounds());
+            int4 drawBounds = simd::load4i(&m_draws[i]->pixelBounds());
 
             // Add one extra pixel of padding to the draw bounds to make absolutely certain we get
             // no overlapping pixels, which destroy the atomic shader.
@@ -1040,7 +1040,7 @@ void RenderContext::LogicalFlush::writeResources()
             // order, but their z index should still remain positive.
             m_currentZIndex = math::lossless_numeric_cast<uint32_t>(
                 abs(key >> static_cast<int64_t>(kDrawGroupShift)));
-            m_plsDraws[key & kDrawIndexMask]->pushToRenderContext(this);
+            m_draws[key & kDrawIndexMask]->pushToRenderContext(this);
             priorKey = key;
         }
 
diff --git a/renderer/src/render_context_helper_impl.cpp b/renderer/src/render_context_helper_impl.cpp
index e8dafc9a..fd346044 100644
--- a/renderer/src/render_context_helper_impl.cpp
+++ b/renderer/src/render_context_helper_impl.cpp
@@ -4,7 +4,7 @@
 
 #include "rive/renderer/render_context_helper_impl.hpp"
 
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "shaders/constants.glsl"
 
 #ifdef RIVE_DECODERS
diff --git a/renderer/src/image.cpp b/renderer/src/rive_render_image.cpp
similarity index 86%
rename from renderer/src/image.cpp
rename to renderer/src/rive_render_image.cpp
index 87293eb5..dd5501ce 100644
--- a/renderer/src/image.cpp
+++ b/renderer/src/rive_render_image.cpp
@@ -2,7 +2,7 @@
  * Copyright 2022 Rive
  */
 
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 
 namespace rive::gpu
 {
diff --git a/renderer/src/rive_render_paint.cpp b/renderer/src/rive_render_paint.cpp
index 234fd2b0..ba54e27f 100644
--- a/renderer/src/rive_render_paint.cpp
+++ b/renderer/src/rive_render_paint.cpp
@@ -4,7 +4,7 @@
 
 #include "rive_render_paint.hpp"
 
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 
 namespace rive::gpu
 {
diff --git a/renderer/src/rive_render_path.cpp b/renderer/src/rive_render_path.cpp
index 373d482d..f37d6f9d 100644
--- a/renderer/src/rive_render_path.cpp
+++ b/renderer/src/rive_render_path.cpp
@@ -74,8 +74,8 @@ void RiveRenderPath::close()
 void RiveRenderPath::addRenderPath(RenderPath* path, const Mat2D& matrix)
 {
     assert(m_rawPathMutationLockCount == 0);
-    RiveRenderPath* plsPath = static_cast<RiveRenderPath*>(path);
-    RawPath::Iter transformedPathIter = m_rawPath.addPath(plsPath->m_rawPath, &matrix);
+    RiveRenderPath* riveRenderPath = static_cast<RiveRenderPath*>(path);
+    RawPath::Iter transformedPathIter = m_rawPath.addPath(riveRenderPath->m_rawPath, &matrix);
     if (matrix != Mat2D())
     {
         // Prune any segments that became empty after the transform.
diff --git a/renderer/src/rive_renderer.cpp b/renderer/src/rive_renderer.cpp
index cd7884fe..66ba0dc5 100644
--- a/renderer/src/rive_renderer.cpp
+++ b/renderer/src/rive_renderer.cpp
@@ -8,7 +8,7 @@
 #include "rive_render_path.hpp"
 #include "rive/math/math_types.hpp"
 #include "rive/math/simd.hpp"
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "shaders/constants.glsl"
 
 namespace rive::gpu
@@ -259,7 +259,7 @@ void RiveRenderer::clipPathImpl(const RiveRenderPath* path)
 
 void RiveRenderer::drawImage(const RenderImage* renderImage, BlendMode blendMode, float opacity)
 {
-    LITE_RTTI_CAST_OR_RETURN(image, const Image*, renderImage);
+    LITE_RTTI_CAST_OR_RETURN(image, const RiveRenderImage*, renderImage);
 
     // Scale the view matrix so we can draw this image as the rect [0, 0, 1, 1].
     save();
@@ -270,13 +270,13 @@ void RiveRenderer::drawImage(const RenderImage* renderImage, BlendMode blendMode
         // Fall back on ImageRectDraw if the current frame doesn't support drawing paths with image
         // paints.
         const Mat2D& m = m_stack.back().matrix;
-        auto plsImage = static_cast<const Image*>(renderImage);
+        auto riveRenderImage = static_cast<const RiveRenderImage*>(renderImage);
         clipAndPushDraw(DrawUniquePtr(
             m_context->make<ImageRectDraw>(m_context,
                                            m.mapBoundingBox(AABB{0, 0, 1, 1}).roundOut(),
                                            m,
                                            blendMode,
-                                           plsImage->refTexture(),
+                                           riveRenderImage->refTexture(),
                                            opacity)));
     }
     else
@@ -308,8 +308,8 @@ void RiveRenderer::drawImageMesh(const RenderImage* renderImage,
                                  BlendMode blendMode,
                                  float opacity)
 {
-    LITE_RTTI_CAST_OR_RETURN(image, const Image*, renderImage);
-    const Texture* plsTexture = image->getTexture();
+    LITE_RTTI_CAST_OR_RETURN(image, const RiveRenderImage*, renderImage);
+    const Texture* texture = image->getTexture();
 
     assert(vertices_f32);
     assert(uvCoords_f32);
@@ -318,7 +318,7 @@ void RiveRenderer::drawImageMesh(const RenderImage* renderImage,
     clipAndPushDraw(DrawUniquePtr(m_context->make<ImageMeshDraw>(Draw::kFullscreenPixelBounds,
                                                                  m_stack.back().matrix,
                                                                  blendMode,
-                                                                 ref_rcp(plsTexture),
+                                                                 ref_rcp(texture),
                                                                  std::move(vertices_f32),
                                                                  std::move(uvCoords_f32),
                                                                  std::move(indices_u16),
diff --git a/renderer/src/vulkan/render_context_vulkan_impl.cpp b/renderer/src/vulkan/render_context_vulkan_impl.cpp
index ccf785bd..7bd0c0a3 100644
--- a/renderer/src/vulkan/render_context_vulkan_impl.cpp
+++ b/renderer/src/vulkan/render_context_vulkan_impl.cpp
@@ -4,7 +4,7 @@
 
 #include "rive/renderer/vulkan/render_context_vulkan_impl.hpp"
 
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "shaders/constants.glsl"
 
 namespace spirv
@@ -1890,8 +1890,8 @@ constexpr static uint32_t kMaxDescriptorSets = 3 + kMaxImageTextureUpdates;
 } // namespace descriptor_pool_limits
 
 RenderContextVulkanImpl::DescriptorSetPool::DescriptorSetPool(
-    RenderContextVulkanImpl* plsImplVulkan) :
-    RenderingResource(plsImplVulkan->m_vk), m_plsImplVulkan(plsImplVulkan)
+    RenderContextVulkanImpl* renderContextImpl) :
+    RenderingResource(renderContextImpl->m_vk), m_renderContextImpl(renderContextImpl)
 {
     VkDescriptorPoolSize descriptorPoolSizes[] = {
         {
@@ -1967,12 +1967,13 @@ void RenderContextVulkanImpl::DescriptorSetPool::onRefCntReachedZero() const
 {
     constexpr static uint32_t kMaxDescriptorSetPoolsInPool = 64;
 
-    if (m_plsImplVulkan->m_descriptorSetPoolPool.size() < kMaxDescriptorSetPoolsInPool)
+    if (m_renderContextImpl->m_descriptorSetPoolPool.size() < kMaxDescriptorSetPoolsInPool)
     {
-        // Hang out in the plsContext's m_descriptorSetPoolPool until in-flight
+        // Hang out in the renderContext's m_descriptorSetPoolPool until in-flight
         // command buffers have finished using our descriptors.
-        m_plsImplVulkan->m_descriptorSetPoolPool.emplace_back(const_cast<DescriptorSetPool*>(this),
-                                                              m_vk->currentFrameIdx());
+        m_renderContextImpl->m_descriptorSetPoolPool.emplace_back(
+            const_cast<DescriptorSetPool*>(this),
+            m_vk->currentFrameIdx());
     }
     else
     {
diff --git a/renderer/src/webgpu/render_context_webgpu_impl.cpp b/renderer/src/webgpu/render_context_webgpu_impl.cpp
index c000e11f..64524e8d 100644
--- a/renderer/src/webgpu/render_context_webgpu_impl.cpp
+++ b/renderer/src/webgpu/render_context_webgpu_impl.cpp
@@ -4,7 +4,7 @@
 
 #include "rive/renderer/webgpu/render_context_webgpu_impl.hpp"
 
-#include "rive/renderer/image.hpp"
+#include "rive/renderer/rive_render_image.hpp"
 #include "shaders/constants.glsl"
 
 #include "generated/shaders/spirv/color_ramp.vert.h"
diff --git a/renderer/webgpu_player/webgpu_player.cpp b/renderer/webgpu_player/webgpu_player.cpp
index cc328425..069a735d 100644
--- a/renderer/webgpu_player/webgpu_player.cpp
+++ b/renderer/webgpu_player/webgpu_player.cpp
@@ -34,7 +34,7 @@ using namespace rive;
 using namespace rive::gpu;
 using PixelLocalStorageType = RenderContextWebGPUImpl::PixelLocalStorageType;
 
-static std::unique_ptr<RenderContext> s_plsContext;
+static std::unique_ptr<RenderContext> s_renderContext;
 static rcp<RenderTargetWebGPU> s_renderTarget;
 static std::unique_ptr<Renderer> s_renderer;
 
@@ -50,13 +50,13 @@ void riveInitPlayer(int w,
         .plsType = plsType,
         .disableStorageBuffers = maxVertexStorageBlocks < gpu::kMaxStorageBuffers,
     };
-    s_plsContext =
+    s_renderContext =
         RenderContextWebGPUImpl::MakeContext(gpu, queue, contextOptions, platformFeatures);
-    s_renderTarget = s_plsContext->static_impl_cast<RenderContextWebGPUImpl>()->makeRenderTarget(
+    s_renderTarget = s_renderContext->static_impl_cast<RenderContextWebGPUImpl>()->makeRenderTarget(
         wgpu::TextureFormat::BGRA8Unorm,
         w,
         h);
-    s_renderer = std::make_unique<RiveRenderer>(s_plsContext.get());
+    s_renderer = std::make_unique<RiveRenderer>(s_renderContext.get());
 }
 
 #ifdef RIVE_WEBGPU
@@ -100,7 +100,7 @@ extern "C"
             emscripten_webgpu_import_texture_view(s_textureViewHandle.get()));
         s_renderTarget->setTargetTextureView(targetTextureView);
 
-        s_plsContext->beginFrame({
+        s_renderContext->beginFrame({
             .renderTargetWidth = s_renderTarget->width(),
             .renderTargetHeight = s_renderTarget->height(),
             .loadAction = static_cast<gpu::LoadAction>(loadAction),
@@ -114,14 +114,14 @@ extern "C"
     void EMSCRIPTEN_KEEPALIVE RiveFlushRendering()
     {
         s_renderer->restore();
-        s_plsContext->flush({.renderTarget = s_renderTarget.get()});
+        s_renderContext->flush({.renderTarget = s_renderTarget.get()});
         s_textureViewHandle = EmJsHandle();
     }
 
     intptr_t EMSCRIPTEN_KEEPALIVE RiveLoadFile(intptr_t wasmBytesPtr, size_t length)
     {
         const uint8_t* bytes = reinterpret_cast<const uint8_t*>(wasmBytesPtr);
-        std::unique_ptr<File> file = File::import({bytes, length}, s_plsContext.get());
+        std::unique_ptr<File> file = File::import({bytes, length}, s_renderContext.get());
         return reinterpret_cast<intptr_t>(file.release());
     }
 
@@ -525,7 +525,7 @@ int main(int argc, const char** argv)
 
     std::ifstream rivStream("../../../gold/rivs/Santa_Claus.riv", std::ios::binary);
     std::vector<uint8_t> rivBytes(std::istreambuf_iterator<char>(rivStream), {});
-    std::unique_ptr<File> rivFile = File::import(rivBytes, s_plsContext.get());
+    std::unique_ptr<File> rivFile = File::import(rivBytes, s_renderContext.get());
     std::unique_ptr<ArtboardInstance> artboard = rivFile->artboardDefault();
     std::unique_ptr<Scene> scene = artboard->defaultScene();
     scene->advanceAndApply(0);
@@ -537,7 +537,7 @@ int main(int argc, const char** argv)
         double timestamp = glfwGetTime();
         s_renderTarget->setTargetTextureView(s_swapchain.GetCurrentTextureView());
 
-        s_plsContext->beginFrame({
+        s_renderContext->beginFrame({
             .renderTargetWidth = s_renderTarget->width(),
             .renderTargetHeight = s_renderTarget->height(),
             .clearColor = 0xff8030ff,
@@ -551,7 +551,7 @@ int main(int argc, const char** argv)
         scene->draw(s_renderer.get());
         s_renderer->restore();
 
-        s_plsContext->flush({.renderTarget = s_renderTarget.get()});
+        s_renderContext->flush({.renderTarget = s_renderTarget.get()});
         s_swapchain.Present();
         device.Tick();
         glfwPollEvents();