diff --git a/filament/backend/src/vulkan/VulkanBlitter.cpp b/filament/backend/src/vulkan/VulkanBlitter.cpp
index 23e80821fb9..e3bbe4231e6 100644
--- a/filament/backend/src/vulkan/VulkanBlitter.cpp
+++ b/filament/backend/src/vulkan/VulkanBlitter.cpp
@@ -16,7 +16,9 @@
 
 #include "VulkanBlitter.h"
 #include "VulkanContext.h"
+#include "VulkanFboCache.h"
 #include "VulkanHandles.h"
+#include "VulkanSamplerCache.h"
 
 #include <utils/FixedCapacityVector.h>
 #include <utils/Panic.h>
diff --git a/filament/backend/src/vulkan/VulkanCommands.cpp b/filament/backend/src/vulkan/VulkanCommands.cpp
index 324de0ae0d5..70cad45185a 100644
--- a/filament/backend/src/vulkan/VulkanCommands.cpp
+++ b/filament/backend/src/vulkan/VulkanCommands.cpp
@@ -23,7 +23,6 @@
 
 #include "VulkanConstants.h"
 #include "VulkanContext.h"
-#include "VulkanDriver.h"
 
 #include <utils/Log.h>
 #include <utils/Panic.h>
diff --git a/filament/backend/src/vulkan/VulkanCommands.h b/filament/backend/src/vulkan/VulkanCommands.h
index 811796c31da..4461f7fbe9f 100644
--- a/filament/backend/src/vulkan/VulkanCommands.h
+++ b/filament/backend/src/vulkan/VulkanCommands.h
@@ -19,6 +19,8 @@
 
 #include <bluevk/BlueVK.h>
 
+#include "DriverBase.h"
+
 #include "VulkanConstants.h"
 
 #include <utils/Condition.h>
diff --git a/filament/backend/src/vulkan/VulkanDriver.cpp b/filament/backend/src/vulkan/VulkanDriver.cpp
index 14215434975..f506ae59be6 100644
--- a/filament/backend/src/vulkan/VulkanDriver.cpp
+++ b/filament/backend/src/vulkan/VulkanDriver.cpp
@@ -148,7 +148,7 @@ VulkanDriver::VulkanDriver(VulkanPlatform* platform, VulkanContext const& contex
       mAllocator(createAllocator(mPlatform->getInstance(), mPlatform->getPhysicalDevice(),
               mPlatform->getDevice())),
       mContext(context),
-      mHandleAllocator("Handles", driverConfig.handleArenaSize),
+      mHandleAllocator(driverConfig.handleArenaSize),
       mBlitter(mStagePool, mPipelineCache, mFramebufferCache, mSamplerCache),
       mReadPixels(mPlatform->getDevice()) {
 
@@ -300,36 +300,36 @@ void VulkanDriver::finish(int dummy) {
 }
 
 void VulkanDriver::createSamplerGroupR(Handle<HwSamplerGroup> sbh, uint32_t count) {
-    construct<VulkanSamplerGroup>(sbh, count);
+    mHandleAllocator.construct<VulkanSamplerGroup>(sbh, count);
 }
 
 void VulkanDriver::createRenderPrimitiveR(Handle<HwRenderPrimitive> rph,
         Handle<HwVertexBuffer> vbh, Handle<HwIndexBuffer> ibh,
         PrimitiveType pt, uint32_t offset,
         uint32_t minIndex, uint32_t maxIndex, uint32_t count) {
-    construct<VulkanRenderPrimitive>(rph);
+    mHandleAllocator.construct<VulkanRenderPrimitive>(rph);
     VulkanDriver::setRenderPrimitiveBuffer(rph, vbh, ibh);
     VulkanDriver::setRenderPrimitiveRange(rph, pt, offset, minIndex, maxIndex, count);
 }
 
 void VulkanDriver::destroyRenderPrimitive(Handle<HwRenderPrimitive> rph) {
     if (rph) {
-        destruct<VulkanRenderPrimitive>(rph);
+        mHandleAllocator.destruct<VulkanRenderPrimitive>(rph);
     }
 }
 
 void VulkanDriver::createVertexBufferR(Handle<HwVertexBuffer> vbh, uint8_t bufferCount,
         uint8_t attributeCount, uint32_t elementCount, AttributeArray attributes) {
-    auto vertexBuffer = construct<VulkanVertexBuffer>(vbh, mContext, mStagePool,
+    auto vertexBuffer = mHandleAllocator.construct<VulkanVertexBuffer>(vbh, mContext, mStagePool,
             bufferCount, attributeCount, elementCount, attributes);
-    mDisposer.createDisposable(vertexBuffer, [this, vbh] () {
-        destruct<VulkanVertexBuffer>(vbh);
+    mDisposer.createDisposable(vertexBuffer, [this, vbh]() {
+        mHandleAllocator.destruct<VulkanVertexBuffer>(vbh);
     });
 }
 
 void VulkanDriver::destroyVertexBuffer(Handle<HwVertexBuffer> vbh) {
     if (vbh) {
-        auto vertexBuffer = handle_cast<VulkanVertexBuffer*>(vbh);
+        auto vertexBuffer = mHandleAllocator.handle_cast<VulkanVertexBuffer*>(vbh);
         mDisposer.removeReference(vertexBuffer);
     }
 }
@@ -337,30 +337,30 @@ void VulkanDriver::destroyVertexBuffer(Handle<HwVertexBuffer> vbh) {
 void VulkanDriver::createIndexBufferR(Handle<HwIndexBuffer> ibh, ElementType elementType,
         uint32_t indexCount, BufferUsage usage) {
     auto elementSize = (uint8_t) getElementTypeSize(elementType);
-    auto indexBuffer = construct<VulkanIndexBuffer>(ibh, mAllocator, mCommands.get(), mStagePool,
-            elementSize, indexCount);
+    auto indexBuffer = mHandleAllocator.construct<VulkanIndexBuffer>(ibh, mAllocator,
+            mCommands.get(), mStagePool, elementSize, indexCount);
     mDisposer.createDisposable(indexBuffer,
-            [this, ibh]() { destructBuffer<VulkanIndexBuffer>(ibh); });
+            [this, ibh]() { mHandleAllocator.destruct<VulkanIndexBuffer>(ibh); });
 }
 
 void VulkanDriver::destroyIndexBuffer(Handle<HwIndexBuffer> ibh) {
     if (ibh) {
-        auto indexBuffer = handle_cast<VulkanIndexBuffer*>(ibh);
+        auto indexBuffer = mHandleAllocator.handle_cast<VulkanIndexBuffer*>(ibh);
         mDisposer.removeReference(indexBuffer);
     }
 }
 
 void VulkanDriver::createBufferObjectR(Handle<HwBufferObject> boh, uint32_t byteCount,
         BufferObjectBinding bindingType, BufferUsage usage) {
-    auto bufferObject = construct<VulkanBufferObject>(boh, mAllocator, mCommands.get(), mStagePool,
-            byteCount, bindingType, usage);
+    auto bufferObject = mHandleAllocator.construct<VulkanBufferObject>(boh, mAllocator,
+            mCommands.get(), mStagePool, byteCount, bindingType, usage);
     mDisposer.createDisposable(bufferObject,
-            [this, boh]() { destructBuffer<VulkanBufferObject>(boh); });
+            [this, boh]() { mHandleAllocator.destruct<VulkanBufferObject>(boh); });
 }
 
 void VulkanDriver::destroyBufferObject(Handle<HwBufferObject> boh) {
     if (boh) {
-       auto bufferObject = handle_cast<VulkanBufferObject*>(boh);
+       auto bufferObject = mHandleAllocator.handle_cast<VulkanBufferObject*>(boh);
        if (bufferObject->bindingType == BufferObjectBinding::UNIFORM) {
            mPipelineCache.unbindUniformBuffer(bufferObject->buffer.getGpuBuffer());
            // Decrement the refcount of the uniform buffer, but schedule it for destruction a few
@@ -375,10 +375,11 @@ void VulkanDriver::destroyBufferObject(Handle<HwBufferObject> boh) {
 void VulkanDriver::createTextureR(Handle<HwTexture> th, SamplerType target, uint8_t levels,
         TextureFormat format, uint8_t samples, uint32_t w, uint32_t h, uint32_t depth,
         TextureUsage usage) {
-    auto vktexture = construct<VulkanTexture>(th, mPlatform->getDevice(),
+    auto vktexture = mHandleAllocator.construct<VulkanTexture>(th, mPlatform->getDevice(),
             mPlatform->getPhysicalDevice(), mContext, mAllocator, mCommands.get(), target, levels,
             format, samples, w, h, depth, usage, mStagePool);
-    mDisposer.createDisposable(vktexture, [this, th]() { destruct<VulkanTexture>(th); });
+    mDisposer.createDisposable(vktexture,
+            [this, th]() { mHandleAllocator.destruct<VulkanTexture>(th); });
 }
 
 void VulkanDriver::createTextureSwizzledR(Handle<HwTexture> th, SamplerType target, uint8_t levels,
@@ -387,11 +388,11 @@ void VulkanDriver::createTextureSwizzledR(Handle<HwTexture> th, SamplerType targ
         TextureSwizzle r, TextureSwizzle g, TextureSwizzle b, TextureSwizzle a) {
     TextureSwizzle swizzleArray[] = {r, g, b, a};
     const VkComponentMapping swizzleMap = getSwizzleMap(swizzleArray);
-    auto vktexture = construct<VulkanTexture>(th, mPlatform->getDevice(),
+    auto vktexture = mHandleAllocator.construct<VulkanTexture>(th, mPlatform->getDevice(),
             mPlatform->getPhysicalDevice(), mContext, mAllocator, mCommands.get(), target, levels,
             format, samples, w, h, depth, usage, mStagePool, swizzleMap);
     mDisposer.createDisposable(vktexture, [this, th]() {
-        destruct<VulkanTexture>(th);
+        mHandleAllocator.destruct<VulkanTexture>(th);
     });
 }
 
@@ -404,31 +405,31 @@ void VulkanDriver::importTextureR(Handle<HwTexture> th, intptr_t id,
 
 void VulkanDriver::destroyTexture(Handle<HwTexture> th) {
     if (th) {
-        auto texture = handle_cast<VulkanTexture*>(th);
+        auto texture = mHandleAllocator.handle_cast<VulkanTexture*>(th);
         mPipelineCache.unbindImageView(texture->getPrimaryImageView());
         mDisposer.removeReference(texture);
     }
 }
 
 void VulkanDriver::createProgramR(Handle<HwProgram> ph, Program&& program) {
-    auto vkprogram = construct<VulkanProgram>(ph, mPlatform->getDevice(), program);
+    auto vkprogram = mHandleAllocator.construct<VulkanProgram>(ph, mPlatform->getDevice(), program);
     mDisposer.createDisposable(vkprogram, [this, ph] () {
-        destruct<VulkanProgram>(ph);
+        mHandleAllocator.destruct<VulkanProgram>(ph);
     });
 }
 
 void VulkanDriver::destroyProgram(Handle<HwProgram> ph) {
     if (ph) {
-        mDisposer.removeReference(handle_cast<VulkanProgram*>(ph));
+        mDisposer.removeReference(mHandleAllocator.handle_cast<VulkanProgram*>(ph));
     }
 }
 
 void VulkanDriver::createDefaultRenderTargetR(Handle<HwRenderTarget> rth, int) {
     assert_invariant(mDefaultRenderTarget == nullptr);
-    VulkanRenderTarget* renderTarget = construct<VulkanRenderTarget>(rth);
+    VulkanRenderTarget* renderTarget = mHandleAllocator.construct<VulkanRenderTarget>(rth);
     mDefaultRenderTarget = renderTarget;
     mDisposer.createDisposable(renderTarget, [this, rth] () {
-        destruct<VulkanRenderTarget>(rth);
+        mHandleAllocator.destruct<VulkanRenderTarget>(rth);
     });
 }
 
@@ -443,7 +444,7 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
     for (int i = 0; i < MRT::MAX_SUPPORTED_RENDER_TARGET_COUNT; i++) {
         if (color[i].handle) {
             colorTargets[i] = {
-                .texture = handle_cast<VulkanTexture*>(color[i].handle),
+                .texture = mHandleAllocator.handle_cast<VulkanTexture*>(color[i].handle),
                 .level = color[i].level,
                 .layer = color[i].layer,
             };
@@ -457,7 +458,7 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
     VulkanAttachment depthStencil[2] = {};
     if (depth.handle) {
         depthStencil[0] = {
-            .texture = handle_cast<VulkanTexture*>(depth.handle),
+            .texture = mHandleAllocator.handle_cast<VulkanTexture*>(depth.handle),
             .level = depth.level,
             .layer = depth.layer,
         };
@@ -469,7 +470,7 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
 
     if (stencil.handle) {
         depthStencil[1] = {
-            .texture = handle_cast<VulkanTexture*>(stencil.handle),
+            .texture = mHandleAllocator.handle_cast<VulkanTexture*>(stencil.handle),
             .level = stencil.level,
             .layer = stencil.layer,
         };
@@ -485,15 +486,16 @@ void VulkanDriver::createRenderTargetR(Handle<HwRenderTarget> rth,
     assert_invariant(tmin == tmax);
     assert_invariant(tmin.x >= width && tmin.y >= height);
 
-    auto renderTarget = construct<VulkanRenderTarget>(rth, mPlatform->getDevice(),
+    auto renderTarget = mHandleAllocator.construct<VulkanRenderTarget>(rth, mPlatform->getDevice(),
             mPlatform->getPhysicalDevice(), mContext, mAllocator, mCommands.get(), width, height,
             samples, colorTargets, depthStencil, mStagePool);
-    mDisposer.createDisposable(renderTarget, [this, rth]() { destruct<VulkanRenderTarget>(rth); });
+    mDisposer.createDisposable(renderTarget,
+            [this, rth]() { mHandleAllocator.destruct<VulkanRenderTarget>(rth); });
 }
 
 void VulkanDriver::destroyRenderTarget(Handle<HwRenderTarget> rth) {
     if (rth) {
-        VulkanRenderTarget* rt = handle_cast<VulkanRenderTarget*>(rth);
+        VulkanRenderTarget* rt = mHandleAllocator.handle_cast<VulkanRenderTarget*>(rth);
         if (UTILS_UNLIKELY(rt == mDefaultRenderTarget)) {
             mDefaultRenderTarget = nullptr;
         }
@@ -503,18 +505,17 @@ void VulkanDriver::destroyRenderTarget(Handle<HwRenderTarget> rth) {
 
 void VulkanDriver::createFenceR(Handle<HwFence> fh, int) {
     VulkanCommandBuffer const& commandBuffer = mCommands->get();
-    construct<VulkanFence>(fh, commandBuffer.fence);
+    mHandleAllocator.construct<VulkanFence>(fh, commandBuffer.fence);
 }
 
 void VulkanDriver::createSwapChainR(Handle<HwSwapChain> sch, void* nativeWindow, uint64_t flags) {
-    if ((flags & backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0 &&
-        !isSRGBSwapChainSupported()) {
+    if ((flags & backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE) != 0 && !isSRGBSwapChainSupported()) {
         utils::slog.w << "sRGB swapchain requested, but Platform does not support it"
                       << utils::io::endl;
         flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
     }
-    construct<VulkanSwapChain>(sch, mPlatform, mContext, mAllocator, mCommands.get(), mStagePool,
-            nativeWindow, flags);
+    mHandleAllocator.construct<VulkanSwapChain>(sch, mPlatform, mContext, mAllocator,
+            mCommands.get(), mStagePool, nativeWindow, flags);
 }
 
 void VulkanDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch, uint32_t width,
@@ -526,8 +527,8 @@ void VulkanDriver::createSwapChainHeadlessR(Handle<HwSwapChain> sch, uint32_t wi
         flags = flags | ~(backend::SWAP_CHAIN_CONFIG_SRGB_COLORSPACE);
     }
     assert_invariant(width > 0 && height > 0 && "Vulkan requires non-zero swap chain dimensions.");
-    construct<VulkanSwapChain>(sch, mPlatform, mContext, mAllocator, mCommands.get(), mStagePool,
-            nullptr, flags, VkExtent2D{width, height});
+    mHandleAllocator.construct<VulkanSwapChain>(sch, mPlatform, mContext, mAllocator,
+            mCommands.get(), mStagePool, nullptr, flags, VkExtent2D{width, height});
 }
 
 void VulkanDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {
@@ -535,68 +536,69 @@ void VulkanDriver::createTimerQueryR(Handle<HwTimerQuery> tqh, int) {
 }
 
 Handle<HwVertexBuffer> VulkanDriver::createVertexBufferS() noexcept {
-    return allocHandle<VulkanVertexBuffer>();
+    return mHandleAllocator.allocHandle<VulkanVertexBuffer>();
 }
 
 Handle<HwIndexBuffer> VulkanDriver::createIndexBufferS() noexcept {
-    return allocHandle<VulkanIndexBuffer>();
+    return mHandleAllocator.allocHandle<VulkanIndexBuffer>();
 }
 
 Handle<HwBufferObject> VulkanDriver::createBufferObjectS() noexcept {
-    return allocHandle<VulkanBufferObject>();
+    return mHandleAllocator.allocHandle<VulkanBufferObject>();
 }
 
 Handle<HwTexture> VulkanDriver::createTextureS() noexcept {
-    return allocHandle<VulkanTexture>();
+    return mHandleAllocator.allocHandle<VulkanTexture>();
 }
 
 Handle<HwTexture> VulkanDriver::createTextureSwizzledS() noexcept {
-    return allocHandle<VulkanTexture>();
+    return mHandleAllocator.allocHandle<VulkanTexture>();
 }
 
 Handle<HwTexture> VulkanDriver::importTextureS() noexcept {
-    return allocHandle<VulkanTexture>();
+    return mHandleAllocator.allocHandle<VulkanTexture>();
 }
 
 Handle<HwSamplerGroup> VulkanDriver::createSamplerGroupS() noexcept {
-    return allocHandle<VulkanSamplerGroup>();
+    return mHandleAllocator.allocHandle<VulkanSamplerGroup>();
 }
 
 Handle<HwRenderPrimitive> VulkanDriver::createRenderPrimitiveS() noexcept {
-    return allocHandle<VulkanRenderPrimitive>();
+    return mHandleAllocator.allocHandle<VulkanRenderPrimitive>();
 }
 
 Handle<HwProgram> VulkanDriver::createProgramS() noexcept {
-    return allocHandle<VulkanProgram>();
+    return mHandleAllocator.allocHandle<VulkanProgram>();
 }
 
 Handle<HwRenderTarget> VulkanDriver::createDefaultRenderTargetS() noexcept {
-    return allocHandle<VulkanRenderTarget>();
+    return mHandleAllocator.allocHandle<VulkanRenderTarget>();
 }
 
 Handle<HwRenderTarget> VulkanDriver::createRenderTargetS() noexcept {
-    return allocHandle<VulkanRenderTarget>();
+    return mHandleAllocator.allocHandle<VulkanRenderTarget>();
 }
 
 Handle<HwFence> VulkanDriver::createFenceS() noexcept {
-    return initHandle<VulkanFence>();
+    return mHandleAllocator.initHandle<VulkanFence>();
 }
 
 Handle<HwSwapChain> VulkanDriver::createSwapChainS() noexcept {
-    return allocHandle<VulkanSwapChain>();
+    return mHandleAllocator.allocHandle<VulkanSwapChain>();
 }
 
 Handle<HwSwapChain> VulkanDriver::createSwapChainHeadlessS() noexcept {
-    return allocHandle<VulkanSwapChain>();
+    return mHandleAllocator.allocHandle<VulkanSwapChain>();
 }
 
 Handle<HwTimerQuery> VulkanDriver::createTimerQueryS() noexcept {
     // The handle must be constructed here, as a synchronous call to getTimerQueryValue might happen
     // before createTimerQueryR is executed.
-    Handle<HwTimerQuery> tqh = initHandle<VulkanTimerQuery>(mTimestamps->getNextQuery());
-    auto query = handle_cast<VulkanTimerQuery*>(tqh);
+    Handle<HwTimerQuery> tqh
+            = mHandleAllocator.initHandle<VulkanTimerQuery>(mTimestamps->getNextQuery());
+    auto query = mHandleAllocator.handle_cast<VulkanTimerQuery*>(tqh);
     mDisposer.createDisposable(query, [this, tqh] () {
-        destruct<VulkanTimerQuery>(tqh);
+        mHandleAllocator.destruct<VulkanTimerQuery>(tqh);
     });
     return tqh;
 }
@@ -607,23 +609,23 @@ void VulkanDriver::destroySamplerGroup(Handle<HwSamplerGroup> sbh) {
         // not map to any Vulkan objects. To handle destruction, the only thing we need to do is
         // ensure that the next draw call doesn't try to access a zombie sampler buffer. Therefore,
         // simply replace all weak references with null.
-        auto* hwsb = handle_cast<VulkanSamplerGroup*>(sbh);
+        auto* hwsb = mHandleAllocator.handle_cast<VulkanSamplerGroup*>(sbh);
         for (auto& binding : mSamplerBindings) {
             if (binding == hwsb) {
                 binding = nullptr;
             }
         }
-        destruct<VulkanSamplerGroup>(sbh);
+        mHandleAllocator.destruct<VulkanSamplerGroup>(sbh);
     }
 }
 
 void VulkanDriver::destroySwapChain(Handle<HwSwapChain> sch) {
     if (sch) {
-        VulkanSwapChain& swapChain = *handle_cast<VulkanSwapChain*>(sch);
+        VulkanSwapChain& swapChain = *mHandleAllocator.handle_cast<VulkanSwapChain*>(sch);
         if (mCurrentSwapChain == &swapChain) {
             mCurrentSwapChain = nullptr;
         }
-        destruct<VulkanSwapChain>(sch);
+        mHandleAllocator.destruct<VulkanSwapChain>(sch);
     }
 }
 
@@ -632,7 +634,7 @@ void VulkanDriver::destroyStream(Handle<HwStream> sh) {
 
 void VulkanDriver::destroyTimerQuery(Handle<HwTimerQuery> tqh) {
     if (tqh) {
-        mDisposer.removeReference(handle_cast<VulkanTimerQuery*>(tqh));
+        mDisposer.removeReference(mHandleAllocator.handle_cast<VulkanTimerQuery*>(tqh));
     }
 }
 
@@ -659,11 +661,11 @@ void VulkanDriver::updateStreams(CommandStream* driver) {
 }
 
 void VulkanDriver::destroyFence(Handle<HwFence> fh) {
-    destruct<VulkanFence>(fh);
+    mHandleAllocator.destruct<VulkanFence>(fh);
 }
 
 FenceStatus VulkanDriver::wait(Handle<HwFence> fh, uint64_t timeout) {
-    auto& cmdfence = handle_cast<VulkanFence*>(fh)->fence;
+    auto& cmdfence = mHandleAllocator.handle_cast<VulkanFence*>(fh)->fence;
     if (!cmdfence) {
         // If wait is called before a fence actually exists, we return timeout.  This matches the
         // current behavior in OpenGLDriver, but we should eventually reconsider a different error
@@ -836,15 +838,15 @@ size_t VulkanDriver::getMaxUniformBufferSize() {
 
 void VulkanDriver::setVertexBufferObject(Handle<HwVertexBuffer> vbh, uint32_t index,
         Handle<HwBufferObject> boh) {
-    auto& vb = *handle_cast<VulkanVertexBuffer*>(vbh);
-    auto& bo = *handle_cast<VulkanBufferObject*>(boh);
+    auto& vb = *mHandleAllocator.handle_cast<VulkanVertexBuffer*>(vbh);
+    auto& bo = *mHandleAllocator.handle_cast<VulkanBufferObject*>(boh);
     assert_invariant(bo.bindingType == BufferObjectBinding::VERTEX);
     vb.buffers[index] = &bo.buffer;
 }
 
 void VulkanDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor&& p,
         uint32_t byteOffset) {
-    auto ib = handle_cast<VulkanIndexBuffer*>(ibh);
+    auto ib = mHandleAllocator.handle_cast<VulkanIndexBuffer*>(ibh);
     ib->buffer.loadFromCpu(p.buffer, byteOffset, p.size);
     mDisposer.acquire(ib);
     scheduleDestroy(std::move(p));
@@ -852,7 +854,7 @@ void VulkanDriver::updateIndexBuffer(Handle<HwIndexBuffer> ibh, BufferDescriptor
 
 void VulkanDriver::updateBufferObject(Handle<HwBufferObject> boh, BufferDescriptor&& bd,
         uint32_t byteOffset) {
-    auto bo = handle_cast<VulkanBufferObject*>(boh);
+    auto bo = mHandleAllocator.handle_cast<VulkanBufferObject*>(boh);
     bo->buffer.loadFromCpu(bd.buffer, byteOffset, bd.size);
     mDisposer.acquire(bo);
     scheduleDestroy(std::move(bd));
@@ -860,7 +862,7 @@ void VulkanDriver::updateBufferObject(Handle<HwBufferObject> boh, BufferDescript
 
 void VulkanDriver::updateBufferObjectUnsynchronized(Handle<HwBufferObject> boh,
         BufferDescriptor&& bd, uint32_t byteOffset) {
-    auto bo = handle_cast<VulkanBufferObject*>(boh);
+    auto bo = mHandleAllocator.handle_cast<VulkanBufferObject*>(boh);
     // TODO: implement unsynchronized version
     bo->buffer.loadFromCpu(bd.buffer, byteOffset, bd.size);
     mDisposer.acquire(bo);
@@ -877,15 +879,13 @@ void VulkanDriver::resetBufferObject(Handle<HwBufferObject> boh) {
 }
 
 void VulkanDriver::setMinMaxLevels(Handle<HwTexture> th, uint32_t minLevel, uint32_t maxLevel) {
-    handle_cast<VulkanTexture*>(th)->setPrimaryRange(minLevel, maxLevel);
+    mHandleAllocator.handle_cast<VulkanTexture*>(th)->setPrimaryRange(minLevel, maxLevel);
 }
 
-void VulkanDriver::update3DImage(
-        Handle<HwTexture> th,
-        uint32_t level, uint32_t xoffset, uint32_t yoffset, uint32_t zoffset,
-        uint32_t width, uint32_t height, uint32_t depth,
+void VulkanDriver::update3DImage(Handle<HwTexture> th, uint32_t level, uint32_t xoffset,
+        uint32_t yoffset, uint32_t zoffset, uint32_t width, uint32_t height, uint32_t depth,
         PixelBufferDescriptor&& data) {
-    handle_cast<VulkanTexture*>(th)->updateImage(data, width, height, depth,
+    mHandleAllocator.handle_cast<VulkanTexture*>(th)->updateImage(data, width, height, depth,
             xoffset, yoffset, zoffset, level);
     scheduleDestroy(std::move(data));
 }
@@ -894,7 +894,7 @@ void VulkanDriver::setupExternalImage(void* image) {
 }
 
 bool VulkanDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint64_t* elapsedTime) {
-    VulkanTimerQuery* vtq = handle_cast<VulkanTimerQuery*>(tqh);
+    VulkanTimerQuery* vtq = mHandleAllocator.handle_cast<VulkanTimerQuery*>(tqh);
     if (!vtq->isCompleted()) {
         return false;
     }
@@ -938,7 +938,7 @@ bool VulkanDriver::canGenerateMipmaps() {
 
 void VulkanDriver::updateSamplerGroup(Handle<HwSamplerGroup> sbh,
         BufferDescriptor&& data) {
-    auto* sb = handle_cast<VulkanSamplerGroup*>(sbh);
+    auto* sb = mHandleAllocator.handle_cast<VulkanSamplerGroup*>(sbh);
 
     // FIXME: we shouldn't be using SamplerGroup here, instead the backend should create
     //        a descriptor or any internal data-structure that represents the textures/samplers.
@@ -960,7 +960,7 @@ void VulkanDriver::compilePrograms(CompilerPriorityQueue priority,
 }
 
 void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassParams& params) {
-    VulkanRenderTarget* const rt = handle_cast<VulkanRenderTarget*>(rth);
+    VulkanRenderTarget* const rt = mHandleAllocator.handle_cast<VulkanRenderTarget*>(rth);
     const VkExtent2D extent = rt->getExtent();
     assert_invariant(extent.width > 0 && extent.height > 0);
 
@@ -1002,7 +1002,8 @@ void VulkanDriver::beginRenderPass(Handle<HwRenderTarget> rth, const RenderPassP
         for (size_t i = 0; i < sb->getSize(); i++) {
             SamplerDescriptor const* boundSampler = sb->data() + i;
             if (UTILS_LIKELY(boundSampler->t)) {
-                VulkanTexture* texture = handle_cast<VulkanTexture*>(boundSampler->t);
+                VulkanTexture* texture
+                        = mHandleAllocator.handle_cast<VulkanTexture*>(boundSampler->t);
                 if (!any(texture->usage & TextureUsage::DEPTH_ATTACHMENT)) {
                     continue;
                 }
@@ -1279,15 +1280,15 @@ void VulkanDriver::nextSubpass(int) {
 
 void VulkanDriver::setRenderPrimitiveBuffer(Handle<HwRenderPrimitive> rph,
         Handle<HwVertexBuffer> vbh, Handle<HwIndexBuffer> ibh) {
-    auto primitive = handle_cast<VulkanRenderPrimitive*>(rph);
-    primitive->setBuffers(handle_cast<VulkanVertexBuffer*>(vbh),
-            handle_cast<VulkanIndexBuffer*>(ibh));
+    auto primitive = mHandleAllocator.handle_cast<VulkanRenderPrimitive*>(rph);
+    primitive->setBuffers(mHandleAllocator.handle_cast<VulkanVertexBuffer*>(vbh),
+            mHandleAllocator.handle_cast<VulkanIndexBuffer*>(ibh));
 }
 
 void VulkanDriver::setRenderPrimitiveRange(Handle<HwRenderPrimitive> rph,
         PrimitiveType pt, uint32_t offset,
         uint32_t minIndex, uint32_t maxIndex, uint32_t count) {
-    auto& primitive = *handle_cast<VulkanRenderPrimitive*>(rph);
+    auto& primitive = *mHandleAllocator.handle_cast<VulkanRenderPrimitive*>(rph);
     primitive.setPrimitiveType(pt);
     primitive.offset = offset * primitive.indexBuffer->elementSize;
     primitive.count = count;
@@ -1298,7 +1299,7 @@ void VulkanDriver::setRenderPrimitiveRange(Handle<HwRenderPrimitive> rph,
 void VulkanDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain> readSch) {
     ASSERT_PRECONDITION_NON_FATAL(drawSch == readSch,
                                   "Vulkan driver does not support distinct draw/read swap chains.");
-    VulkanSwapChain* swapChain = mCurrentSwapChain = handle_cast<VulkanSwapChain*>(drawSch);
+    VulkanSwapChain* swapChain = mCurrentSwapChain = mHandleAllocator.handle_cast<VulkanSwapChain*>(drawSch);
 
     bool resized = false;
     swapChain->acquire(resized);
@@ -1313,7 +1314,7 @@ void VulkanDriver::makeCurrent(Handle<HwSwapChain> drawSch, Handle<HwSwapChain>
 }
 
 void VulkanDriver::commit(Handle<HwSwapChain> sch) {
-    VulkanSwapChain* swapChain = handle_cast<VulkanSwapChain*>(sch);
+    VulkanSwapChain* swapChain = mHandleAllocator.handle_cast<VulkanSwapChain*>(sch);
 
     if (mCommands->flush()) {
         collectGarbage();
@@ -1324,7 +1325,7 @@ void VulkanDriver::commit(Handle<HwSwapChain> sch) {
 }
 
 void VulkanDriver::bindUniformBuffer(uint32_t index, Handle<HwBufferObject> boh) {
-    auto* bo = handle_cast<VulkanBufferObject*>(boh);
+    auto* bo = mHandleAllocator.handle_cast<VulkanBufferObject*>(boh);
     const VkDeviceSize offset = 0;
     const VkDeviceSize size = VK_WHOLE_SIZE;
     mPipelineCache.bindUniformBuffer((uint32_t) index, bo->buffer.getGpuBuffer(), offset, size);
@@ -1338,7 +1339,7 @@ void VulkanDriver::bindBufferRange(BufferObjectBinding bindingType, uint32_t ind
 
     // TODO: implement BufferObjectBinding::SHADER_STORAGE case
 
-    auto* bo = handle_cast<VulkanBufferObject*>(boh);
+    auto* bo = mHandleAllocator.handle_cast<VulkanBufferObject*>(boh);
     mPipelineCache.bindUniformBuffer((uint32_t)index, bo->buffer.getGpuBuffer(), offset, size);
 }
 
@@ -1347,7 +1348,7 @@ void VulkanDriver::unbindBuffer(BufferObjectBinding bindingType, uint32_t index)
 }
 
 void VulkanDriver::bindSamplers(uint32_t index, Handle<HwSamplerGroup> sbh) {
-    auto* hwsb = handle_cast<VulkanSamplerGroup*>(sbh);
+    auto* hwsb = mHandleAllocator.handle_cast<VulkanSamplerGroup*>(sbh);
     mSamplerBindings[index] = hwsb;
 }
 
@@ -1378,7 +1379,7 @@ void VulkanDriver::stopCapture(int) {}
 
 void VulkanDriver::readPixels(Handle<HwRenderTarget> src, uint32_t x, uint32_t y, uint32_t width,
         uint32_t height, PixelBufferDescriptor&& pbd) {
-    VulkanRenderTarget* srcTarget = handle_cast<VulkanRenderTarget*>(src);
+    VulkanRenderTarget* srcTarget = mHandleAllocator.handle_cast<VulkanRenderTarget*>(src);
     mCommands->flush();
     mReadPixels.run(
             srcTarget, x, y, width, height, mPlatform->getGraphicsQueueFamilyIndex(),
@@ -1410,8 +1411,8 @@ void VulkanDriver::blit(TargetBufferFlags buffers, Handle<HwRenderTarget> dst, V
         return;
     }
 
-    VulkanRenderTarget* dstTarget = handle_cast<VulkanRenderTarget*>(dst);
-    VulkanRenderTarget* srcTarget = handle_cast<VulkanRenderTarget*>(src);
+    VulkanRenderTarget* dstTarget = mHandleAllocator.handle_cast<VulkanRenderTarget*>(dst);
+    VulkanRenderTarget* srcTarget = mHandleAllocator.handle_cast<VulkanRenderTarget*>(src);
 
     VkFilter vkfilter = filter == SamplerMagFilter::NEAREST ? VK_FILTER_NEAREST : VK_FILTER_LINEAR;
 
@@ -1444,14 +1445,14 @@ void VulkanDriver::draw(PipelineState pipelineState, Handle<HwRenderPrimitive> r
         const uint32_t instanceCount) {
     VulkanCommandBuffer const* commands = &mCommands->get();
     VkCommandBuffer cmdbuffer = commands->cmdbuffer;
-    const VulkanRenderPrimitive& prim = *handle_cast<VulkanRenderPrimitive*>(rph);
+    const VulkanRenderPrimitive& prim = *mHandleAllocator.handle_cast<VulkanRenderPrimitive*>(rph);
 
     Handle<HwProgram> programHandle = pipelineState.program;
     RasterState rasterState = pipelineState.rasterState;
     PolygonOffset depthOffset = pipelineState.polygonOffset;
     const Viewport& scissorBox = pipelineState.scissor;
 
-    auto* program = handle_cast<VulkanProgram*>(programHandle);
+    auto* program = mHandleAllocator.handle_cast<VulkanProgram*>(programHandle);
     mDisposer.acquire(program);
     mDisposer.acquire(prim.indexBuffer);
     mDisposer.acquire(prim.vertexBuffer);
@@ -1565,7 +1566,7 @@ void VulkanDriver::draw(PipelineState pipelineState, Handle<HwRenderPrimitive> r
             samplerIdx++;
 
             if (UTILS_LIKELY(boundSampler->t)) {
-                VulkanTexture* texture = handle_cast<VulkanTexture*>(boundSampler->t);
+                VulkanTexture* texture = mHandleAllocator.handle_cast<VulkanTexture*>(boundSampler->t);
                 mDisposer.acquire(texture);
 
                 // TODO: can this uninitialized check be checked in a higher layer?
@@ -1652,12 +1653,12 @@ void VulkanDriver::dispatchCompute(Handle<HwProgram> program, math::uint3 workGr
 }
 
 void VulkanDriver::beginTimerQuery(Handle<HwTimerQuery> tqh) {
-    VulkanTimerQuery* vtq = handle_cast<VulkanTimerQuery*>(tqh);
+    VulkanTimerQuery* vtq = mHandleAllocator.handle_cast<VulkanTimerQuery*>(tqh);
     mTimestamps->beginQuery(&(mCommands->get()), vtq);
 }
 
 void VulkanDriver::endTimerQuery(Handle<HwTimerQuery> tqh) {
-    VulkanTimerQuery* vtq = handle_cast<VulkanTimerQuery*>(tqh);
+    VulkanTimerQuery* vtq = mHandleAllocator.handle_cast<VulkanTimerQuery*>(tqh);
     mTimestamps->endQuery(&(mCommands->get()), vtq);
 }
 
diff --git a/filament/backend/src/vulkan/VulkanDriver.h b/filament/backend/src/vulkan/VulkanDriver.h
index 75673f6ec86..0b2d441d2ab 100644
--- a/filament/backend/src/vulkan/VulkanDriver.h
+++ b/filament/backend/src/vulkan/VulkanDriver.h
@@ -17,37 +17,92 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANDRIVER_H
 #define TNT_FILAMENT_BACKEND_VULKANDRIVER_H
 
-#include "VulkanPipelineCache.h"
 #include "VulkanBlitter.h"
-#include "VulkanDisposer.h"
 #include "VulkanConstants.h"
 #include "VulkanContext.h"
+#include "VulkanDisposer.h"
 #include "VulkanFboCache.h"
+#include "VulkanHandles.h"
+#include "VulkanPipelineCache.h"
 #include "VulkanReadPixels.h"
 #include "VulkanSamplerCache.h"
 #include "VulkanStagePool.h"
 #include "VulkanUtility.h"
 
+#include "DriverBase.h"
 #include "private/backend/Driver.h"
 #include "private/backend/HandleAllocator.h"
-#include "DriverBase.h"
 
-#include <utils/compiler.h>
 #include <utils/Allocator.h>
+#include <utils/compiler.h>
 
 namespace filament::backend {
 
 class VulkanPlatform;
 struct VulkanSamplerGroup;
 
+class VulkanHandleAllocator {
+public:
+    VulkanHandleAllocator(size_t arenaSize)
+        : mHandleAllocatorImpl("Handles", arenaSize) {}
+
+    template<typename D, typename... ARGS>
+    inline Handle<D> initHandle(ARGS&&... args) noexcept {
+        return mHandleAllocatorImpl.allocateAndConstruct<D>(std::forward<ARGS>(args)...);
+    }
+
+    template<typename D>
+    inline Handle<D> allocHandle() noexcept {
+        return mHandleAllocatorImpl.allocate<D>();
+    }
+
+    template<typename D, typename B, typename... ARGS>
+    inline typename std::enable_if<std::is_base_of<B, D>::value, D>::type* construct(
+            Handle<B> const& handle, ARGS&&... args) noexcept {
+        return mHandleAllocatorImpl.construct<D, B>(handle, std::forward<ARGS>(args)...);
+    }
+
+    template<typename B, typename D,
+            typename = typename std::enable_if<std::is_base_of<B, D>::value, D>::type>
+    inline void destruct(Handle<B> handle, D const* p) noexcept {
+        return mHandleAllocatorImpl.deallocate(handle, p);
+    }
+
+    template<typename Dp, typename B>
+    inline typename std::enable_if_t<
+            std::is_pointer_v<Dp> && std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
+    handle_cast(Handle<B>& handle) noexcept {
+        return mHandleAllocatorImpl.handle_cast<Dp, B>(handle);
+    }
+
+    template<typename Dp, typename B>
+    inline typename std::enable_if_t<
+            std::is_pointer_v<Dp> && std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
+    handle_cast(Handle<B> const& handle) noexcept {
+        return mHandleAllocatorImpl.handle_cast<Dp, B>(handle);
+    }
+
+    template<typename D, typename B>
+    inline void destruct(Handle<B> handle) noexcept {
+        if constexpr (std::is_base_of_v<VulkanIndexBuffer, D>
+                      || std::is_base_of_v<VulkanBufferObject, D>) {
+            auto ptr = handle_cast<D*>(handle);
+            ptr->terminate();
+        }
+        destruct(handle, handle_cast<D const*>(handle));
+    }
+
+    HandleAllocatorVK mHandleAllocatorImpl;
+};
+
 class VulkanDriver final : public DriverBase {
 public:
     static Driver* create(VulkanPlatform* platform, VulkanContext const& context,
             Platform::DriverConfig const& driverConfig) noexcept;
 
 private:
-
-    void debugCommandBegin(CommandStream* cmds, bool synchronous, const char* methodName) noexcept override;
+    void debugCommandBegin(CommandStream* cmds, bool synchronous,
+            const char* methodName) noexcept override;
 
     inline VulkanDriver(VulkanPlatform* platform, VulkanContext const& context,
             Platform::DriverConfig const& driverConfig) noexcept;
@@ -61,77 +116,24 @@ class VulkanDriver final : public DriverBase {
     template<typename T>
     friend class ConcreteDispatcher;
 
-#define DECL_DRIVER_API(methodName, paramsDecl, params) \
+#define DECL_DRIVER_API(methodName, paramsDecl, params)                                            \
     UTILS_ALWAYS_INLINE inline void methodName(paramsDecl);
 
-#define DECL_DRIVER_API_SYNCHRONOUS(RetType, methodName, paramsDecl, params) \
+#define DECL_DRIVER_API_SYNCHRONOUS(RetType, methodName, paramsDecl, params)                       \
     RetType methodName(paramsDecl) override;
 
-#define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params) \
-    RetType methodName##S() noexcept override; \
+#define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params)                            \
+    RetType methodName##S() noexcept override;                                                     \
     UTILS_ALWAYS_INLINE inline void methodName##R(RetType, paramsDecl);
 
 #include "private/backend/DriverAPI.inc"
 
     VulkanDriver(VulkanDriver const&) = delete;
-    VulkanDriver& operator = (VulkanDriver const&) = delete;
+    VulkanDriver& operator=(VulkanDriver const&) = delete;
 
 private:
-
-    template<typename D, typename ... ARGS>
-    Handle<D> initHandle(ARGS&& ... args) noexcept {
-        return mHandleAllocator.allocateAndConstruct<D>(std::forward<ARGS>(args) ...);
-    }
-
-    template<typename D>
-    Handle<D> allocHandle() noexcept {
-        return mHandleAllocator.allocate<D>();
-    }
-
-    template<typename D, typename B, typename ... ARGS>
-    typename std::enable_if<std::is_base_of<B, D>::value, D>::type*
-    construct(Handle<B> const& handle, ARGS&& ... args) noexcept {
-        return mHandleAllocator.construct<D, B>(handle, std::forward<ARGS>(args) ...);
-    }
-
-    template<typename B, typename D,
-            typename = typename std::enable_if<std::is_base_of<B, D>::value, D>::type>
-    void destruct(Handle<B> handle, D const* p) noexcept {
-        return mHandleAllocator.deallocate(handle, p);
-    }
-
-    template<typename Dp, typename B>
-    typename std::enable_if_t<
-            std::is_pointer_v<Dp> &&
-            std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
-    handle_cast(Handle<B>& handle) noexcept {
-        return mHandleAllocator.handle_cast<Dp, B>(handle);
-    }
-
-    template<typename Dp, typename B>
-    inline typename std::enable_if_t<
-            std::is_pointer_v<Dp> &&
-            std::is_base_of_v<B, typename std::remove_pointer_t<Dp>>, Dp>
-    handle_cast(Handle<B> const& handle) noexcept {
-        return mHandleAllocator.handle_cast<Dp, B>(handle);
-    }
-
-    template<typename D, typename B>
-    void destruct(Handle<B> handle) noexcept {
-        destruct(handle, handle_cast<D const*>(handle));
-    }
-
-    // This version of destruct takes a VulkanContext and calls a terminate(VulkanContext&)
-    // on the handle before calling the dtor
-    template<typename Dp, typename B>
-    void destructBuffer(Handle<B> handle) noexcept {
-        auto ptr = handle_cast<Dp*>(handle);
-        ptr->terminate();
-        mHandleAllocator.deallocate(handle, ptr);
-    }
-
-    inline void setRenderPrimitiveBuffer(Handle<HwRenderPrimitive> rph,
-            Handle<HwVertexBuffer> vbh, Handle<HwIndexBuffer> ibh);
+    inline void setRenderPrimitiveBuffer(Handle<HwRenderPrimitive> rph, Handle<HwVertexBuffer> vbh,
+            Handle<HwIndexBuffer> ibh);
 
     inline void setRenderPrimitiveRange(Handle<HwRenderPrimitive> rph, PrimitiveType pt,
             uint32_t offset, uint32_t minIndex, uint32_t maxIndex, uint32_t count);
@@ -151,7 +153,7 @@ class VulkanDriver final : public DriverBase {
     VkDebugUtilsMessengerEXT mDebugMessenger = VK_NULL_HANDLE;
 
     VulkanContext mContext = {};
-    HandleAllocatorVK mHandleAllocator;
+    VulkanHandleAllocator mHandleAllocator;
     VulkanPipelineCache mPipelineCache;
     VulkanDisposer mDisposer;
     VulkanStagePool mStagePool;
diff --git a/filament/backend/src/vulkan/VulkanHandles.h b/filament/backend/src/vulkan/VulkanHandles.h
index fe5fc2227e0..5f2d2ee5bd9 100644
--- a/filament/backend/src/vulkan/VulkanHandles.h
+++ b/filament/backend/src/vulkan/VulkanHandles.h
@@ -14,10 +14,12 @@
  * limitations under the License.
  */
 
- #ifndef TNT_FILAMENT_BACKEND_VULKANHANDLES_H
- #define TNT_FILAMENT_BACKEND_VULKANHANDLES_H
+#ifndef TNT_FILAMENT_BACKEND_VULKANHANDLES_H
+#define TNT_FILAMENT_BACKEND_VULKANHANDLES_H
+
+// This needs to be at the top
+#include "DriverBase.h"
 
-#include "VulkanDriver.h"
 #include "VulkanPipelineCache.h"
 #include "VulkanBuffer.h"
 #include "VulkanSwapChain.h"
@@ -26,7 +28,7 @@
 
 #include "private/backend/SamplerGroup.h"
 
-#include "utils/Mutex.h"
+#include <utils/Mutex.h>
 
 namespace filament::backend {
 
diff --git a/filament/backend/src/vulkan/VulkanSwapChain.h b/filament/backend/src/vulkan/VulkanSwapChain.h
index e89d75f5985..681f4a1e1dc 100644
--- a/filament/backend/src/vulkan/VulkanSwapChain.h
+++ b/filament/backend/src/vulkan/VulkanSwapChain.h
@@ -17,8 +17,9 @@
 #ifndef TNT_FILAMENT_BACKEND_VULKANSWAPCHAIN_H
 #define TNT_FILAMENT_BACKEND_VULKANSWAPCHAIN_H
 
+#include "DriverBase.h"
+
 #include "VulkanContext.h"
-#include "VulkanDriver.h"
 
 #include <backend/platforms/VulkanPlatform.h>
 
diff --git a/filament/backend/src/vulkan/VulkanTexture.h b/filament/backend/src/vulkan/VulkanTexture.h
index 05eafae6b58..d56f2f3539d 100644
--- a/filament/backend/src/vulkan/VulkanTexture.h
+++ b/filament/backend/src/vulkan/VulkanTexture.h
@@ -17,7 +17,8 @@
  #ifndef TNT_FILAMENT_BACKEND_VULKANTEXTURE_H
  #define TNT_FILAMENT_BACKEND_VULKANTEXTURE_H
 
-#include "VulkanDriver.h"
+#include "DriverBase.h"
+
 #include "VulkanBuffer.h"
 #include "VulkanImageUtility.h"