diff --git a/filament/src/driver/CommandStream.h b/filament/src/driver/CommandStream.h
index 4e334cd260..e0d00fc535 100644
--- a/filament/src/driver/CommandStream.h
+++ b/filament/src/driver/CommandStream.h
@@ -95,7 +95,7 @@ private:
 
 template<typename M, typename D, typename T, std::size_t... I>
 constexpr void trampoline(M&& m, D&& d, T&& t, std::index_sequence<I...>) {
-    (d.*m)(std::get<I>(std::move(t))...);
+    (d.*m)(std::move(std::get<I>(std::forward<T>(t)))...);
 }
 
 template<typename M, typename D, typename T>
@@ -211,19 +211,12 @@ public:
 #define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params)                         \
     inline RetType methodName(paramsDecl) {                                                     \
         DEBUG_COMMAND(methodName, params);                                                      \
-        RetType result = mDriver->methodName##Synchronous();                                    \
-        using CmdType = CommandType<decltype(&Driver::methodName)>;                             \
-        using Cmd = CmdType::Command<&Driver::methodName>;                                      \
+        RetType result = mDriver->methodName##S();                                              \
+        using CmdType = CommandType<decltype(&Driver::methodName##R)>;                          \
+        using Cmd = CmdType::Command<&Driver::methodName##R>;                                   \
         void* const p = allocateCommand(CommandBase::align(sizeof(Cmd)));                       \
         new(p) Cmd(mDispatcher->methodName##_, RetType(result), params);                        \
         return result;                                                                          \
-    }                                                                                           \
-    inline void methodName(RetType result, paramsDecl) {                                        \
-        DEBUG_COMMAND(methodName, params);                                                      \
-        using CmdType = CommandType<decltype(&Driver::methodName)>;                             \
-        using Cmd = CmdType::Command<&Driver::methodName>;                                      \
-        void* const p = allocateCommand(CommandBase::align(sizeof(Cmd)));                       \
-        new(p) Cmd(mDispatcher->methodName##_, result, params);                                 \
     }
 
 #include "driver/DriverAPI.inc"
diff --git a/filament/src/driver/CommandStreamDispatcher.h b/filament/src/driver/CommandStreamDispatcher.h
index 2a3c8b047c..4c72ff8609 100644
--- a/filament/src/driver/CommandStreamDispatcher.h
+++ b/filament/src/driver/CommandStreamDispatcher.h
@@ -69,10 +69,10 @@ private:
 #define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params)                         \
     static void methodName(Driver& driver, CommandBase* base, intptr_t* next) {                 \
         SYSTRACE()                                                                              \
-        using Type = CommandType<decltype(&Driver::methodName)>;                                \
-        using Cmd = typename Type::template Command<&Driver::methodName>;                       \
+        using Type = CommandType<decltype(&Driver::methodName##R)>;                             \
+        using Cmd = typename Type::template Command<&Driver::methodName##R>;                    \
         ConcreteDriver& concreteDriver = static_cast<ConcreteDriver&>(driver);                  \
-        Cmd::execute(&ConcreteDriver::methodName, concreteDriver, base, next);                  \
+        Cmd::execute(&ConcreteDriver::methodName##R, concreteDriver, base, next);               \
      }
 #include "driver/DriverAPI.inc"
 };
diff --git a/filament/src/driver/Driver.h b/filament/src/driver/Driver.h
index bb2e22567f..a7994cf79a 100644
--- a/filament/src/driver/Driver.h
+++ b/filament/src/driver/Driver.h
@@ -261,8 +261,8 @@ public:
     virtual RetType methodName(paramsDecl) = 0;
 
 #define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params) \
-    virtual RetType methodName##Synchronous() noexcept = 0; \
-    void methodName(RetType, paramsDecl) {}
+    virtual RetType methodName##S() noexcept = 0; \
+    void methodName##R(RetType, paramsDecl) {}
 
 #include "driver/DriverAPI.inc"
 };
diff --git a/filament/src/driver/metal/MetalDriver.h b/filament/src/driver/metal/MetalDriver.h
index 58d9df50c5..c62bf0b384 100644
--- a/filament/src/driver/metal/MetalDriver.h
+++ b/filament/src/driver/metal/MetalDriver.h
@@ -68,8 +68,8 @@ private:
     RetType methodName(paramsDecl) override;
 
 #define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params) \
-    RetType methodName##Synchronous() noexcept override; \
-    UTILS_ALWAYS_INLINE void methodName(RetType, paramsDecl);
+    RetType methodName##S() noexcept override; \
+    UTILS_ALWAYS_INLINE void methodName##R(RetType, paramsDecl);
 
 #include "driver/DriverAPI.inc"
 
diff --git a/filament/src/driver/metal/MetalDriver.mm b/filament/src/driver/metal/MetalDriver.mm
index 9aec2effd3..1d5e5b49e7 100644
--- a/filament/src/driver/metal/MetalDriver.mm
+++ b/filament/src/driver/metal/MetalDriver.mm
@@ -128,7 +128,7 @@ void MetalDriver::flush(int dummy) {
 
 }
 
-void MetalDriver::createVertexBuffer(Driver::VertexBufferHandle vbh, uint8_t bufferCount,
+void MetalDriver::createVertexBufferR(Driver::VertexBufferHandle vbh, uint8_t bufferCount,
         uint8_t attributeCount, uint32_t vertexCount, Driver::AttributeArray attributes,
         Driver::BufferUsage usage) {
     // TODO: Take BufferUsage into account when creating the buffer.
@@ -136,41 +136,41 @@ void MetalDriver::createVertexBuffer(Driver::VertexBufferHandle vbh, uint8_t buf
             attributeCount, vertexCount, attributes);
 }
 
-void MetalDriver::createIndexBuffer(Driver::IndexBufferHandle ibh, Driver::ElementType elementType,
+void MetalDriver::createIndexBufferR(Driver::IndexBufferHandle ibh, Driver::ElementType elementType,
         uint32_t indexCount, Driver::BufferUsage usage) {
     auto elementSize = (uint8_t) getElementTypeSize(elementType);
     construct_handle<MetalIndexBuffer>(mHandleMap, ibh, pImpl->mDevice, elementSize, indexCount);
 }
 
-void MetalDriver::createTexture(Driver::TextureHandle th, Driver::SamplerType target, uint8_t levels,
+void MetalDriver::createTextureR(Driver::TextureHandle th, Driver::SamplerType target, uint8_t levels,
         Driver::TextureFormat format, uint8_t samples, uint32_t width, uint32_t height,
         uint32_t depth, Driver::TextureUsage usage) {
     construct_handle<MetalTexture>(mHandleMap, th, pImpl->mDevice, target, levels, format, samples,
             width, height, depth, usage);
 }
 
-void MetalDriver::createSamplerBuffer(Driver::SamplerBufferHandle sbh, size_t size) {
+void MetalDriver::createSamplerBufferR(Driver::SamplerBufferHandle sbh, size_t size) {
     construct_handle<MetalSamplerBuffer>(mHandleMap, sbh, size);
 }
 
-void MetalDriver::createUniformBuffer(Driver::UniformBufferHandle ubh, size_t size,
+void MetalDriver::createUniformBufferR(Driver::UniformBufferHandle ubh, size_t size,
         Driver::BufferUsage usage) {
     construct_handle<MetalUniformBuffer>(mHandleMap, ubh, pImpl->mDevice, size);
 }
 
-void MetalDriver::createRenderPrimitive(Driver::RenderPrimitiveHandle rph, int dummy) {
+void MetalDriver::createRenderPrimitiveR(Driver::RenderPrimitiveHandle rph, int dummy) {
     construct_handle<MetalRenderPrimitive>(mHandleMap, rph);
 }
 
-void MetalDriver::createProgram(Driver::ProgramHandle rph, Program&& program) {
+void MetalDriver::createProgramR(Driver::ProgramHandle rph, Program&& program) {
     construct_handle<MetalProgram>(mHandleMap, rph, pImpl->mDevice, program);
 }
 
-void MetalDriver::createDefaultRenderTarget(Driver::RenderTargetHandle rth, int dummy) {
+void MetalDriver::createDefaultRenderTargetR(Driver::RenderTargetHandle rth, int dummy) {
     construct_handle<MetalRenderTarget>(mHandleMap, rth);
 }
 
-void MetalDriver::createRenderTarget(Driver::RenderTargetHandle rth,
+void MetalDriver::createRenderTargetR(Driver::RenderTargetHandle rth,
         Driver::TargetBufferFlags targetBufferFlags, uint32_t width, uint32_t height,
         uint8_t samples, Driver::TextureFormat format, Driver::TargetBufferInfo color,
         Driver::TargetBufferInfo depth, Driver::TargetBufferInfo stencil) {
@@ -202,65 +202,65 @@ void MetalDriver::createRenderTarget(Driver::RenderTargetHandle rth,
             "Stencil buffer not supported.");
 }
 
-void MetalDriver::createFence(Driver::FenceHandle, int dummy) {
+void MetalDriver::createFenceR(Driver::FenceHandle, int dummy) {
 
 }
 
-void MetalDriver::createSwapChain(Driver::SwapChainHandle sch, void* nativeWindow, uint64_t flags) {
+void MetalDriver::createSwapChainR(Driver::SwapChainHandle sch, void* nativeWindow, uint64_t flags) {
     auto* metalLayer = (CAMetalLayer*) nativeWindow;
     construct_handle<MetalSwapChain>(mHandleMap, sch, pImpl->mDevice, metalLayer);
 }
 
-void MetalDriver::createStreamFromTextureId(Driver::StreamHandle, intptr_t externalTextureId,
+void MetalDriver::createStreamFromTextureIdR(Driver::StreamHandle, intptr_t externalTextureId,
         uint32_t width, uint32_t height) {
 
 }
 
-Driver::VertexBufferHandle MetalDriver::createVertexBufferSynchronous() noexcept {
+Driver::VertexBufferHandle MetalDriver::createVertexBufferS() noexcept {
     return alloc_handle<MetalVertexBuffer, HwVertexBuffer>();
 }
 
-Driver::IndexBufferHandle MetalDriver::createIndexBufferSynchronous() noexcept {
+Driver::IndexBufferHandle MetalDriver::createIndexBufferS() noexcept {
     return alloc_handle<MetalIndexBuffer, HwIndexBuffer>();
 }
 
-Driver::TextureHandle MetalDriver::createTextureSynchronous() noexcept {
+Driver::TextureHandle MetalDriver::createTextureS() noexcept {
     return alloc_handle<MetalTexture, HwTexture>();
 }
 
-Driver::SamplerBufferHandle MetalDriver::createSamplerBufferSynchronous() noexcept {
+Driver::SamplerBufferHandle MetalDriver::createSamplerBufferS() noexcept {
     return alloc_handle<MetalSamplerBuffer, HwSamplerBuffer>();
 }
 
-Driver::UniformBufferHandle MetalDriver::createUniformBufferSynchronous() noexcept {
+Driver::UniformBufferHandle MetalDriver::createUniformBufferS() noexcept {
     return alloc_handle<MetalUniformBuffer, HwUniformBuffer>();
 }
 
-Driver::RenderPrimitiveHandle MetalDriver::createRenderPrimitiveSynchronous() noexcept {
+Driver::RenderPrimitiveHandle MetalDriver::createRenderPrimitiveS() noexcept {
     return alloc_handle<MetalRenderPrimitive, HwRenderPrimitive>();
 }
 
-Driver::ProgramHandle MetalDriver::createProgramSynchronous() noexcept {
+Driver::ProgramHandle MetalDriver::createProgramS() noexcept {
     return alloc_handle<MetalProgram, HwProgram>();
 }
 
-Driver::RenderTargetHandle MetalDriver::createDefaultRenderTargetSynchronous() noexcept {
+Driver::RenderTargetHandle MetalDriver::createDefaultRenderTargetS() noexcept {
     return alloc_handle<MetalRenderTarget, HwRenderTarget>();
 }
 
-Driver::RenderTargetHandle MetalDriver::createRenderTargetSynchronous() noexcept {
+Driver::RenderTargetHandle MetalDriver::createRenderTargetS() noexcept {
     return alloc_handle<MetalRenderTarget, HwRenderTarget>();
 }
 
-Driver::FenceHandle MetalDriver::createFenceSynchronous() noexcept {
+Driver::FenceHandle MetalDriver::createFenceS() noexcept {
     return {};
 }
 
-Driver::SwapChainHandle MetalDriver::createSwapChainSynchronous() noexcept {
+Driver::SwapChainHandle MetalDriver::createSwapChainS() noexcept {
     return alloc_handle<MetalSwapChain, HwSwapChain>();
 }
 
-Driver::StreamHandle MetalDriver::createStreamFromTextureIdSynchronous() noexcept {
+Driver::StreamHandle MetalDriver::createStreamFromTextureIdS() noexcept {
     return {};
 }
 
diff --git a/filament/src/driver/noop/NoopDriver.h b/filament/src/driver/noop/NoopDriver.h
index 3233b95fe8..6c78d32945 100644
--- a/filament/src/driver/noop/NoopDriver.h
+++ b/filament/src/driver/noop/NoopDriver.h
@@ -51,9 +51,9 @@ private:
     RetType methodName(paramsDecl) override { return RetType(true); }
 
 #define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params) \
-    RetType methodName##Synchronous() noexcept override { \
+    RetType methodName##S() noexcept override { \
         return RetType((RetType::HandleId)0xDEAD0000); } \
-    UTILS_ALWAYS_INLINE void methodName(RetType, paramsDecl) { }
+    UTILS_ALWAYS_INLINE void methodName##R(RetType, paramsDecl) { }
 
 #include "driver/DriverAPI.inc"
 };
diff --git a/filament/src/driver/opengl/OpenGLDriver.cpp b/filament/src/driver/opengl/OpenGLDriver.cpp
index 4034b5b8de..7498ee75b3 100644
--- a/filament/src/driver/opengl/OpenGLDriver.cpp
+++ b/filament/src/driver/opengl/OpenGLDriver.cpp
@@ -809,55 +809,55 @@ void OpenGLDriver::destruct(Handle<B>& handle, D const* p) noexcept {
     }
 }
 
-Handle<HwVertexBuffer> OpenGLDriver::createVertexBufferSynchronous() noexcept {
+Handle<HwVertexBuffer> OpenGLDriver::createVertexBufferS() noexcept {
     return Handle<HwVertexBuffer>( allocateHandle(sizeof(GLVertexBuffer)) );
 }
 
-Handle<HwIndexBuffer> OpenGLDriver::createIndexBufferSynchronous() noexcept {
+Handle<HwIndexBuffer> OpenGLDriver::createIndexBufferS() noexcept {
     return Handle<HwIndexBuffer>( allocateHandle(sizeof(GLIndexBuffer)) );
 }
 
-Handle<HwRenderPrimitive> OpenGLDriver::createRenderPrimitiveSynchronous() noexcept {
+Handle<HwRenderPrimitive> OpenGLDriver::createRenderPrimitiveS() noexcept {
     return Handle<HwRenderPrimitive>( allocateHandle(sizeof(GLRenderPrimitive)) );
 }
 
-Handle<HwProgram> OpenGLDriver::createProgramSynchronous() noexcept {
+Handle<HwProgram> OpenGLDriver::createProgramS() noexcept {
     return Handle<HwProgram>( allocateHandle(sizeof(OpenGLProgram)) );
 }
 
-Handle<HwSamplerBuffer> OpenGLDriver::createSamplerBufferSynchronous() noexcept {
+Handle<HwSamplerBuffer> OpenGLDriver::createSamplerBufferS() noexcept {
     return Handle<HwSamplerBuffer>( allocateHandle(sizeof(GLSamplerBuffer)) );
 }
 
-Handle<HwUniformBuffer> OpenGLDriver::createUniformBufferSynchronous() noexcept {
+Handle<HwUniformBuffer> OpenGLDriver::createUniformBufferS() noexcept {
     return Handle<HwUniformBuffer>( allocateHandle(sizeof(GLUniformBuffer)) );
 }
 
-Handle<HwTexture> OpenGLDriver::createTextureSynchronous() noexcept {
+Handle<HwTexture> OpenGLDriver::createTextureS() noexcept {
     return Handle<HwTexture>( allocateHandle(sizeof(GLTexture)) );
 }
 
-Handle<HwRenderTarget> OpenGLDriver::createDefaultRenderTargetSynchronous() noexcept {
+Handle<HwRenderTarget> OpenGLDriver::createDefaultRenderTargetS() noexcept {
     return Handle<HwRenderTarget>( allocateHandle(sizeof(GLRenderTarget)) );
 }
 
-Handle<HwRenderTarget> OpenGLDriver::createRenderTargetSynchronous() noexcept {
+Handle<HwRenderTarget> OpenGLDriver::createRenderTargetS() noexcept {
     return Handle<HwRenderTarget>( allocateHandle(sizeof(GLRenderTarget)) );
 }
 
-Handle<HwFence> OpenGLDriver::createFenceSynchronous() noexcept {
+Handle<HwFence> OpenGLDriver::createFenceS() noexcept {
     return Handle<HwFence>( allocateHandle(sizeof(HwFence)) );
 }
 
-Handle<HwSwapChain> OpenGLDriver::createSwapChainSynchronous() noexcept {
+Handle<HwSwapChain> OpenGLDriver::createSwapChainS() noexcept {
     return Handle<HwSwapChain>( allocateHandle(sizeof(HwSwapChain)) );
 }
 
-Handle<HwStream> OpenGLDriver::createStreamFromTextureIdSynchronous() noexcept {
+Handle<HwStream> OpenGLDriver::createStreamFromTextureIdS() noexcept {
     return Handle<HwStream>( allocateHandle(sizeof(GLStream)) );
 }
 
-void OpenGLDriver::createVertexBuffer(
+void OpenGLDriver::createVertexBufferR(
     Driver::VertexBufferHandle vbh,
     uint8_t bufferCount,
     uint8_t attributeCount,
@@ -888,7 +888,7 @@ void OpenGLDriver::createVertexBuffer(
     CHECK_GL_ERROR(utils::slog.e)
 }
 
-void OpenGLDriver::createIndexBuffer(
+void OpenGLDriver::createIndexBufferR(
         Driver::IndexBufferHandle ibh,
         Driver::ElementType elementType,
         uint32_t indexCount,
@@ -905,7 +905,7 @@ void OpenGLDriver::createIndexBuffer(
     CHECK_GL_ERROR(utils::slog.e)
 }
 
-void OpenGLDriver::createRenderPrimitive(Driver::RenderPrimitiveHandle rph, int) {
+void OpenGLDriver::createRenderPrimitiveR(Driver::RenderPrimitiveHandle rph, int) {
     DEBUG_MARKER()
 
     GLRenderPrimitive* rp = construct<GLRenderPrimitive>(rph);
@@ -913,20 +913,20 @@ void OpenGLDriver::createRenderPrimitive(Driver::RenderPrimitiveHandle rph, int)
     CHECK_GL_ERROR(utils::slog.e)
 }
 
-void OpenGLDriver::createProgram(Driver::ProgramHandle ph, Program&& program) {
+void OpenGLDriver::createProgramR(Driver::ProgramHandle ph, Program&& program) {
     DEBUG_MARKER()
 
     construct<OpenGLProgram>(ph, this, program);
     CHECK_GL_ERROR(utils::slog.e)
 }
 
-void OpenGLDriver::createSamplerBuffer(Driver::SamplerBufferHandle sbh, size_t size) {
+void OpenGLDriver::createSamplerBufferR(Driver::SamplerBufferHandle sbh, size_t size) {
     DEBUG_MARKER()
 
     construct<GLSamplerBuffer>(sbh, size);
 }
 
-void OpenGLDriver::createUniformBuffer(
+void OpenGLDriver::createUniformBufferR(
         Driver::UniformBufferHandle ubh,
         size_t size,
         Driver::BufferUsage usage) {
@@ -984,7 +984,7 @@ void OpenGLDriver::textureStorage(OpenGLDriver::GLTexture* t,
     t->depth = depth;
 }
 
-void OpenGLDriver::createTexture(Driver::TextureHandle th, SamplerType target, uint8_t levels,
+void OpenGLDriver::createTextureR(Driver::TextureHandle th, SamplerType target, uint8_t levels,
         TextureFormat format, uint8_t samples, uint32_t w, uint32_t h, uint32_t depth,
         TextureUsage usage) {
     DEBUG_MARKER()
@@ -1114,7 +1114,7 @@ GLuint OpenGLDriver::framebufferRenderbuffer(uint32_t width, uint32_t height, ui
     return rbo;
 }
 
-void OpenGLDriver::createDefaultRenderTarget(
+void OpenGLDriver::createDefaultRenderTargetR(
         Driver::RenderTargetHandle rth, int) {
     DEBUG_MARKER()
 
@@ -1131,7 +1131,7 @@ void OpenGLDriver::createDefaultRenderTarget(
     rt->gl.depth.rb = depthbuffer;  // FIXME: populate format
 }
 
-void OpenGLDriver::createRenderTarget(Driver::RenderTargetHandle rth,
+void OpenGLDriver::createRenderTargetR(Driver::RenderTargetHandle rth,
         Driver::TargetBufferFlags targets,
         uint32_t width,
         uint32_t height,
@@ -1223,21 +1223,21 @@ void OpenGLDriver::createRenderTarget(Driver::RenderTargetHandle rth,
     CHECK_GL_ERROR(utils::slog.e)
 }
 
-void OpenGLDriver::createFence(Driver::FenceHandle fh, int) {
+void OpenGLDriver::createFenceR(Driver::FenceHandle fh, int) {
     DEBUG_MARKER()
 
     HwFence* f = construct<HwFence>(fh);
     f->fence = mPlatform.createFence();
 }
 
-void OpenGLDriver::createSwapChain(Driver::SwapChainHandle sch, void* nativeWindow, uint64_t flags) {
+void OpenGLDriver::createSwapChainR(Driver::SwapChainHandle sch, void* nativeWindow, uint64_t flags) {
     DEBUG_MARKER()
 
     HwSwapChain* sc = construct<HwSwapChain>(sch);
     sc->swapChain = mPlatform.createSwapChain(nativeWindow, flags);
 }
 
-void OpenGLDriver::createStreamFromTextureId(Driver::StreamHandle sh,
+void OpenGLDriver::createStreamFromTextureIdR(Driver::StreamHandle sh,
         intptr_t externalTextureId, uint32_t width, uint32_t height) {
     DEBUG_MARKER()
 
diff --git a/filament/src/driver/opengl/OpenGLDriver.h b/filament/src/driver/opengl/OpenGLDriver.h
index 4a416c60b3..b214229376 100644
--- a/filament/src/driver/opengl/OpenGLDriver.h
+++ b/filament/src/driver/opengl/OpenGLDriver.h
@@ -204,8 +204,8 @@ private:
     RetType methodName(paramsDecl) override;
 
 #define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params) \
-    RetType methodName##Synchronous() noexcept override; \
-    UTILS_ALWAYS_INLINE void methodName(RetType, paramsDecl);
+    RetType methodName##S() noexcept override; \
+    UTILS_ALWAYS_INLINE void methodName##R(RetType, paramsDecl);
 
 #include "driver/DriverAPI.inc"
 
diff --git a/filament/src/driver/vulkan/VulkanDriver.cpp b/filament/src/driver/vulkan/VulkanDriver.cpp
index d8dc4590f2..581f58df00 100644
--- a/filament/src/driver/vulkan/VulkanDriver.cpp
+++ b/filament/src/driver/vulkan/VulkanDriver.cpp
@@ -248,49 +248,49 @@ void VulkanDriver::flush(int) {
     // Todo: equivalent of glFlush()
 }
 
-void VulkanDriver::createVertexBuffer(Driver::VertexBufferHandle vbh, uint8_t bufferCount,
+void VulkanDriver::createVertexBufferR(Driver::VertexBufferHandle vbh, uint8_t bufferCount,
         uint8_t attributeCount, uint32_t elementCount, Driver::AttributeArray attributes,
         Driver::BufferUsage usage) {
     construct_handle<VulkanVertexBuffer>(mHandleMap, vbh, mContext, mStagePool, bufferCount,
             attributeCount, elementCount, attributes);
 }
 
-void VulkanDriver::createIndexBuffer(Driver::IndexBufferHandle ibh, Driver::ElementType elementType,
+void VulkanDriver::createIndexBufferR(Driver::IndexBufferHandle ibh, Driver::ElementType elementType,
         uint32_t indexCount, Driver::BufferUsage usage) {
     auto elementSize = (uint8_t) getElementTypeSize(elementType);
     construct_handle<VulkanIndexBuffer>(mHandleMap, ibh, mContext, mStagePool, elementSize,
             indexCount);
 }
 
-void VulkanDriver::createTexture(Driver::TextureHandle th, SamplerType target, uint8_t levels,
+void VulkanDriver::createTextureR(Driver::TextureHandle th, SamplerType target, uint8_t levels,
         TextureFormat format, uint8_t samples, uint32_t w, uint32_t h, uint32_t depth,
         TextureUsage usage) {
     construct_handle<VulkanTexture>(mHandleMap, th, mContext, target, levels, format, samples,
             w, h, depth, usage, mStagePool);
 }
 
-void VulkanDriver::createSamplerBuffer(Driver::SamplerBufferHandle sbh, size_t count) {
+void VulkanDriver::createSamplerBufferR(Driver::SamplerBufferHandle sbh, size_t count) {
     construct_handle<VulkanSamplerBuffer>(mHandleMap, sbh, mContext, count);
 }
 
-void VulkanDriver::createUniformBuffer(Driver::UniformBufferHandle ubh, size_t size,
+void VulkanDriver::createUniformBufferR(Driver::UniformBufferHandle ubh, size_t size,
         Driver::BufferUsage usage) {
     construct_handle<VulkanUniformBuffer>(mHandleMap, ubh, mContext, mStagePool, size, usage);
 }
 
-void VulkanDriver::createRenderPrimitive(Driver::RenderPrimitiveHandle rph, int) {
+void VulkanDriver::createRenderPrimitiveR(Driver::RenderPrimitiveHandle rph, int) {
     construct_handle<VulkanRenderPrimitive>(mHandleMap, rph, mContext);
 }
 
-void VulkanDriver::createProgram(Driver::ProgramHandle ph, Program&& program) {
+void VulkanDriver::createProgramR(Driver::ProgramHandle ph, Program&& program) {
     construct_handle<VulkanProgram>(mHandleMap, ph, mContext, program);
 }
 
-void VulkanDriver::createDefaultRenderTarget(Driver::RenderTargetHandle rth, int) {
+void VulkanDriver::createDefaultRenderTargetR(Driver::RenderTargetHandle rth, int) {
     construct_handle<VulkanRenderTarget>(mHandleMap, rth, mContext);
 }
 
-void VulkanDriver::createRenderTarget(Driver::RenderTargetHandle rth,
+void VulkanDriver::createRenderTargetR(Driver::RenderTargetHandle rth,
         Driver::TargetBufferFlags targets, uint32_t width, uint32_t height, uint8_t samples,
         TextureFormat format, Driver::TargetBufferInfo color, Driver::TargetBufferInfo depth,
         Driver::TargetBufferInfo stencil) {
@@ -318,10 +318,10 @@ void VulkanDriver::createRenderTarget(Driver::RenderTargetHandle rth,
     }
 }
 
-void VulkanDriver::createFence(Driver::FenceHandle fh, int) {
+void VulkanDriver::createFenceR(Driver::FenceHandle fh, int) {
 }
 
-void VulkanDriver::createSwapChain(Driver::SwapChainHandle sch, void* nativeWindow,
+void VulkanDriver::createSwapChainR(Driver::SwapChainHandle sch, void* nativeWindow,
         uint64_t flags) {
     auto* swapChain = construct_handle<VulkanSwapChain>(mHandleMap, sch);
     VulkanSurfaceContext& sc = swapChain->surfaceContext;
@@ -340,55 +340,55 @@ void VulkanDriver::createSwapChain(Driver::SwapChainHandle sch, void* nativeWind
     }
 }
 
-void VulkanDriver::createStreamFromTextureId(Driver::StreamHandle sh, intptr_t externalTextureId,
+void VulkanDriver::createStreamFromTextureIdR(Driver::StreamHandle sh, intptr_t externalTextureId,
         uint32_t width, uint32_t height) {
 }
 
-Handle<HwVertexBuffer> VulkanDriver::createVertexBufferSynchronous() noexcept {
+Handle<HwVertexBuffer> VulkanDriver::createVertexBufferS() noexcept {
     return alloc_handle<VulkanVertexBuffer, HwVertexBuffer>();
 }
 
-Handle<HwIndexBuffer> VulkanDriver::createIndexBufferSynchronous() noexcept {
+Handle<HwIndexBuffer> VulkanDriver::createIndexBufferS() noexcept {
     return alloc_handle<VulkanIndexBuffer, HwIndexBuffer>();
 }
 
-Handle<HwTexture> VulkanDriver::createTextureSynchronous() noexcept {
+Handle<HwTexture> VulkanDriver::createTextureS() noexcept {
     return alloc_handle<VulkanTexture, HwTexture>();
 }
 
-Handle<HwSamplerBuffer> VulkanDriver::createSamplerBufferSynchronous() noexcept {
+Handle<HwSamplerBuffer> VulkanDriver::createSamplerBufferS() noexcept {
     return alloc_handle<VulkanSamplerBuffer, HwSamplerBuffer>();
 }
 
-Handle<HwUniformBuffer> VulkanDriver::createUniformBufferSynchronous() noexcept {
+Handle<HwUniformBuffer> VulkanDriver::createUniformBufferS() noexcept {
     return alloc_handle<VulkanUniformBuffer, HwUniformBuffer>();
 }
 
-Handle<HwRenderPrimitive> VulkanDriver::createRenderPrimitiveSynchronous() noexcept {
+Handle<HwRenderPrimitive> VulkanDriver::createRenderPrimitiveS() noexcept {
     return alloc_handle<VulkanRenderPrimitive, HwRenderPrimitive>();
 }
 
-Handle<HwProgram> VulkanDriver::createProgramSynchronous() noexcept {
+Handle<HwProgram> VulkanDriver::createProgramS() noexcept {
     return alloc_handle<VulkanProgram, HwProgram>();
 }
 
-Handle<HwRenderTarget> VulkanDriver::createDefaultRenderTargetSynchronous() noexcept {
+Handle<HwRenderTarget> VulkanDriver::createDefaultRenderTargetS() noexcept {
     return alloc_handle<VulkanRenderTarget, HwRenderTarget>();
 }
 
-Handle<HwRenderTarget> VulkanDriver::createRenderTargetSynchronous() noexcept {
+Handle<HwRenderTarget> VulkanDriver::createRenderTargetS() noexcept {
     return alloc_handle<VulkanRenderTarget, HwRenderTarget>();
 }
 
-Handle<HwFence> VulkanDriver::createFenceSynchronous() noexcept {
+Handle<HwFence> VulkanDriver::createFenceS() noexcept {
     return {};
 }
 
-Handle<HwSwapChain> VulkanDriver::createSwapChainSynchronous() noexcept {
+Handle<HwSwapChain> VulkanDriver::createSwapChainS() noexcept {
     return alloc_handle<VulkanSwapChain, HwSwapChain>();
 }
 
-Handle<HwStream> VulkanDriver::createStreamFromTextureIdSynchronous() noexcept {
+Handle<HwStream> VulkanDriver::createStreamFromTextureIdS() noexcept {
     return {};
 }
 
diff --git a/filament/src/driver/vulkan/VulkanDriver.h b/filament/src/driver/vulkan/VulkanDriver.h
index 674f8e603c..a721abb6ea 100644
--- a/filament/src/driver/vulkan/VulkanDriver.h
+++ b/filament/src/driver/vulkan/VulkanDriver.h
@@ -66,8 +66,8 @@ private:
     RetType methodName(paramsDecl) override;
 
 #define DECL_DRIVER_API_RETURN(RetType, methodName, paramsDecl, params) \
-    RetType methodName##Synchronous() noexcept override; \
-    UTILS_ALWAYS_INLINE void methodName(RetType, paramsDecl);
+    RetType methodName##S() noexcept override; \
+    UTILS_ALWAYS_INLINE void methodName##R(RetType, paramsDecl);
 
 #include "driver/DriverAPI.inc"