diff --git a/host/ColorBuffer.cpp b/host/ColorBuffer.cpp
index 06f2969..6a8f58d 100644
--- a/host/ColorBuffer.cpp
+++ b/host/ColorBuffer.cpp
@@ -375,6 +375,30 @@
     return true;
 }
 
+bool ColorBuffer::importNativeResource(void* nativeResource, uint32_t type, bool preserveContent) {
+    switch (type) {
+        case RESOURCE_TYPE_VK_EXT_MEMORY_HANDLE: {
+            if (mColorBufferGl) {
+                GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                    << "Native resource import type %s is invalid when GL emulation is active. "
+                    << "Use RESOURCE_TYPE_EGL_NATIVE_PIXMAP of RESOURCE_TYPE_EGL_IMAGE imports "
+                       "instead.";
+                return false;
+            } else if (!mColorBufferVk) {
+                GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                    << "Vulkan emulation must be available for RESOURCE_TYPE_VK_EXT_MEMORY_HANDLE "
+                       "import.";
+                return false;
+            }
+            return mColorBufferVk->importExtMemoryHandle(nativeResource, type, preserveContent);
+        }
+        default:
+            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                << "Unrecognized type for ColorBuffer::importNativeResource.";
+            return false;
+    }
+}
+
 bool ColorBuffer::glOpBlitFromCurrentReadBuffer() {
     if (!mColorBufferGl) {
         GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "ColorBufferGl not available.";
diff --git a/host/ColorBuffer.h b/host/ColorBuffer.h
index 47bf96c..f519fe7 100644
--- a/host/ColorBuffer.h
+++ b/host/ColorBuffer.h
@@ -84,6 +84,7 @@
     bool flushFromVkBytes(const void* bytes, size_t bytesSize);
     bool invalidateForGl();
     bool invalidateForVk();
+    bool importNativeResource(void* nativeResource, uint32_t type, bool preserveContent);
 
     GLuint glOpGetTexture();
     bool glOpBlitFromCurrentReadBuffer();
diff --git a/host/FrameBuffer.cpp b/host/FrameBuffer.cpp
index d69b7e6..f7f0016 100644
--- a/host/FrameBuffer.cpp
+++ b/host/FrameBuffer.cpp
@@ -3465,6 +3465,11 @@
             return colorBuffer->glOpImportEglNativePixmap(resource, preserveContent);
         case RESOURCE_TYPE_EGL_IMAGE:
             return colorBuffer->glOpImportEglImage(resource, preserveContent);
+
+        // Note: Additional non-EGL resource-types can be added here, and will
+        // be propagated through color-buffer import functionality
+        case RESOURCE_TYPE_VK_EXT_MEMORY_HANDLE:
+            return colorBuffer->importNativeResource(resource, type, preserveContent);
         default:
             ERR("Error: unsupported resource type: %u", type);
             return false;
diff --git a/host/include/gfxstream/virtio-gpu-gfxstream-renderer-unstable.h b/host/include/gfxstream/virtio-gpu-gfxstream-renderer-unstable.h
index 4276f15..429bfa5 100644
--- a/host/include/gfxstream/virtio-gpu-gfxstream-renderer-unstable.h
+++ b/host/include/gfxstream/virtio-gpu-gfxstream-renderer-unstable.h
@@ -75,6 +75,7 @@
 // types
 #define STREAM_RENDERER_PLATFORM_RESOURCE_TYPE_EGL_NATIVE_PIXMAP 0x01
 #define STREAM_RENDERER_PLATFORM_RESOURCE_TYPE_EGL_IMAGE 0x02
+#define STREAM_RENDERER_PLATFORM_RESOURCE_TYPE_VK_EXT_MEMORY_HANDLE 0x03
 
 // uses
 #define STREAM_RENDERER_PLATFORM_RESOURCE_USE_PRESERVE 0x10
diff --git a/host/tests/Vulkan_unittest.cpp b/host/tests/Vulkan_unittest.cpp
index 23d392a..b3cf5f7 100644
--- a/host/tests/Vulkan_unittest.cpp
+++ b/host/tests/Vulkan_unittest.cpp
@@ -472,10 +472,10 @@
 
 TEST_F(VulkanFrameBufferTest, VkColorBufferWithoutMemoryProperties) {
     // Create a color buffer without any memory properties restriction.
-    EXPECT_TRUE(setupVkColorBuffer(mWidth, mHeight, GL_RGBA, FRAMEWORK_FORMAT_GL_COMPATIBLE,
-                                   kArbitraryColorBufferHandle, true, /* vulkanOnly */
-                                   0                                  /* memoryProperty */
-                                   ));
+    EXPECT_TRUE(createVkColorBuffer(mWidth, mHeight, GL_RGBA, FRAMEWORK_FORMAT_GL_COMPATIBLE,
+                                    kArbitraryColorBufferHandle, true, /* vulkanOnly */
+                                    0                                  /* memoryProperty */
+                                    ));
     EXPECT_TRUE(teardownVkColorBuffer(kArbitraryColorBufferHandle));
 }
 
@@ -537,9 +537,9 @@
     }
 
     // Create a color buffer with the target memory property flags.
-    EXPECT_TRUE(setupVkColorBuffer(mWidth, mHeight, GL_RGBA, FRAMEWORK_FORMAT_GL_COMPATIBLE,
-                                   kArbitraryColorBufferHandle, true, /* vulkanOnly */
-                                   static_cast<uint32_t>(kTargetMemoryPropertyFlags)));
+    EXPECT_TRUE(createVkColorBuffer(mWidth, mHeight, GL_RGBA, FRAMEWORK_FORMAT_GL_COMPATIBLE,
+                                    kArbitraryColorBufferHandle, true, /* vulkanOnly */
+                                    static_cast<uint32_t>(kTargetMemoryPropertyFlags)));
 
     uint32_t allocatedTypeIndex = 0u;
     EXPECT_TRUE(getColorBufferAllocationInfo(kArbitraryColorBufferHandle, nullptr,
diff --git a/host/vulkan/ColorBufferVk.cpp b/host/vulkan/ColorBufferVk.cpp
index 72860c4..0d569b3 100644
--- a/host/vulkan/ColorBufferVk.cpp
+++ b/host/vulkan/ColorBufferVk.cpp
@@ -24,8 +24,8 @@
                                                      uint32_t height, GLenum format,
                                                      FrameworkFormat frameworkFormat,
                                                      bool vulkanOnly, uint32_t memoryProperty) {
-    if (!setupVkColorBuffer(width, height, format, frameworkFormat, handle, vulkanOnly,
-                            memoryProperty)) {
+    if (!createVkColorBuffer(width, height, format, frameworkFormat, handle, vulkanOnly,
+                             memoryProperty)) {
         GL_LOG("Failed to create ColorBufferVk:%d", handle);
         return nullptr;
     }
@@ -58,5 +58,14 @@
     return updateColorBufferFromBytes(mHandle, x, y, w, h, bytes);
 }
 
+bool ColorBufferVk::importExtMemoryHandle(void* nativeResource, uint32_t type,
+                                          bool preserveContent) {
+    // TODO: Any need to support preserveContent?
+    assert(!preserveContent);
+    VK_EXT_MEMORY_HANDLE extMemoryHandle =
+        *reinterpret_cast<VK_EXT_MEMORY_HANDLE*>(&nativeResource);
+    return importExtMemoryHandleToVkColorBuffer(mHandle, type, extMemoryHandle);
+}
+
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/host/vulkan/ColorBufferVk.h b/host/vulkan/ColorBufferVk.h
index c049bf3..8364c93 100644
--- a/host/vulkan/ColorBufferVk.h
+++ b/host/vulkan/ColorBufferVk.h
@@ -36,6 +36,8 @@
     bool updateFromBytes(const std::vector<uint8_t>& bytes);
     bool updateFromBytes(uint32_t x, uint32_t y, uint32_t w, uint32_t h, const void* bytes);
 
+    bool importExtMemoryHandle(void* nativeResource, uint32_t type, bool preserveContent);
+
    private:
     ColorBufferVk(uint32_t handle);
 
diff --git a/host/vulkan/VkAndroidNativeBuffer.cpp b/host/vulkan/VkAndroidNativeBuffer.cpp
index 26435d1..095d387 100644
--- a/host/vulkan/VkAndroidNativeBuffer.cpp
+++ b/host/vulkan/VkAndroidNativeBuffer.cpp
@@ -141,7 +141,8 @@
     auto emu = getGlobalVkEmulation();
 
     if (emu && emu->live) {
-        externalMemoryCompatible = emu->deviceInfo.supportsExternalMemory;
+        externalMemoryCompatible = emu->deviceInfo.supportsExternalMemoryImport &&
+                                   emu->deviceInfo.supportsExternalMemoryExport;
     }
 
     bool colorBufferExportedToGl = false;
diff --git a/host/vulkan/VkCommonOperations.cpp b/host/vulkan/VkCommonOperations.cpp
index 3a9fc12..a48d4e2 100644
--- a/host/vulkan/VkCommonOperations.cpp
+++ b/host/vulkan/VkCommonOperations.cpp
@@ -96,6 +96,7 @@
 
 static android::base::StaticLock sVkEmulationLock;
 
+#if !defined(__QNX__)
 VK_EXT_MEMORY_HANDLE dupExternalMemory(VK_EXT_MEMORY_HANDLE h) {
 #ifdef _WIN32
     auto myProcessHandle = GetCurrentProcess();
@@ -109,6 +110,7 @@
     return dup(h);
 #endif
 }
+#endif
 
 bool getStagingMemoryTypeIndex(VulkanDispatch* vk, VkDevice device,
                                const VkPhysicalDeviceMemoryProperties* memProps,
@@ -545,6 +547,8 @@
         VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME,
 #ifdef _WIN32
         VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME,
+#elif defined(__QNX__)
+        VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME,
 #else
         VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME,
 #endif
@@ -767,12 +771,18 @@
         ivk->vkEnumerateDeviceExtensionProperties(physdevs[i], nullptr, &deviceExtensionCount,
                                                   deviceExts.data());
 
-        deviceInfos[i].supportsExternalMemory = false;
+        deviceInfos[i].supportsExternalMemoryImport = false;
+        deviceInfos[i].supportsExternalMemoryExport = false;
         deviceInfos[i].glInteropSupported = 0;  // set later
 
         if (sVkEmulation->instanceSupportsExternalMemoryCapabilities) {
-            deviceInfos[i].supportsExternalMemory =
-                extensionsSupported(deviceExts, externalMemoryDeviceExtNames);
+            deviceInfos[i].supportsExternalMemoryExport =
+                deviceInfos[i].supportsExternalMemoryImport =
+                    extensionsSupported(deviceExts, externalMemoryDeviceExtNames);
+#if defined(__QNX__)
+            // External memory export not supported on QNX
+            deviceInfos[i].supportsExternalMemoryExport = false;
+#endif
             deviceInfos[i].supportsIdProperties =
                 sVkEmulation->getPhysicalDeviceProperties2Func != nullptr;
             deviceInfos[i].supportsDriverProperties =
@@ -847,10 +857,23 @@
                 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
             };
             vk_append_struct(&features2Chain, &samplerYcbcrConversionFeatures);
+#if defined(__QNX__)
+            VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX extMemScreenBufferFeatures = {
+                .sType =
+                    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
+            };
+            vk_append_struct(&features2Chain, &extMemScreenBufferFeatures);
+#endif
             sVkEmulation->getPhysicalDeviceFeatures2Func(physdevs[i], &features2);
 
             deviceInfos[i].supportsSamplerYcbcrConversion =
                 samplerYcbcrConversionFeatures.samplerYcbcrConversion == VK_TRUE;
+#if defined(__QNX__)
+            deviceInfos[i].supportsExternalMemoryImport =
+                extMemScreenBufferFeatures.screenBufferImport == VK_TRUE;
+        } else {
+            deviceInfos[i].supportsExternalMemoryImport = false;
+#endif
         }
 
         uint32_t queueFamilyCount = 0;
@@ -911,7 +934,9 @@
     for (uint32_t i = 0; i < physdevCount; ++i) {
         uint32_t deviceScore = 0;
         if (deviceInfos[i].hasGraphicsQueueFamily) deviceScore += 10000;
-        if (deviceInfos[i].supportsExternalMemory) deviceScore += 1000;
+        if (deviceInfos[i].supportsExternalMemoryImport ||
+            deviceInfos[i].supportsExternalMemoryExport)
+            deviceScore += 1000;
         if (deviceInfos[i].physdevProps.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU ||
             deviceInfos[i].physdevProps.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) {
             deviceScore += 100;
@@ -987,7 +1012,8 @@
 
     std::unordered_set<const char*> selectedDeviceExtensionNames_;
 
-    if (sVkEmulation->deviceInfo.supportsExternalMemory) {
+    if (sVkEmulation->deviceInfo.supportsExternalMemoryImport ||
+        sVkEmulation->deviceInfo.supportsExternalMemoryExport) {
         for (auto extension : externalMemoryDeviceExtNames) {
             selectedDeviceExtensionNames_.emplace(extension);
         }
@@ -1027,6 +1053,20 @@
                 });
         vk_append_struct(&deviceCiChain, samplerYcbcrConversionFeatures.get());
     }
+#if defined(__QNX__)
+    std::unique_ptr<VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX>
+        extMemScreenBufferFeaturesQNX = nullptr;
+    if (sVkEmulation->deviceInfo.supportsExternalMemoryImport) {
+        extMemScreenBufferFeaturesQNX = std::make_unique<
+            VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX>(
+            VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX{
+                .sType =
+                    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
+                .screenBufferImport = VK_TRUE,
+            });
+        vk_append_struct(&deviceCiChain, extMemScreenBufferFeaturesQNX.get());
+    }
+#endif
 
     ivk->vkCreateDevice(sVkEmulation->physdev, &dCi, nullptr, &sVkEmulation->device);
 
@@ -1051,7 +1091,7 @@
         }
     }
 
-    if (sVkEmulation->deviceInfo.supportsExternalMemory) {
+    if (sVkEmulation->deviceInfo.supportsExternalMemoryImport) {
         sVkEmulation->deviceInfo.getImageMemoryRequirements2Func =
             reinterpret_cast<PFN_vkGetImageMemoryRequirements2KHR>(
                 dvk->vkGetDeviceProcAddr(sVkEmulation->device, "vkGetImageMemoryRequirements2KHR"));
@@ -1066,6 +1106,8 @@
             VK_EMU_INIT_RETURN_OR_ABORT_ON_ERROR(ABORT_REASON_OTHER,
                                                  "Cannot find vkGetBufferMemoryRequirements2KHR");
         }
+    }
+    if (sVkEmulation->deviceInfo.supportsExternalMemoryExport) {
 #ifdef _WIN32
         sVkEmulation->deviceInfo.getMemoryHandleFunc =
             reinterpret_cast<PFN_vkGetMemoryWin32HandleKHR>(
@@ -1359,7 +1401,7 @@
 
     auto allocInfoChain = vk_make_chain_iterator(&allocInfo);
 
-    if (sVkEmulation->deviceInfo.supportsExternalMemory && actuallyExternal) {
+    if (sVkEmulation->deviceInfo.supportsExternalMemoryExport && actuallyExternal) {
         vk_append_struct(&allocInfoChain, &exportAi);
     }
 
@@ -1441,10 +1483,11 @@
         return false;
     }
 
-    if (!sVkEmulation->deviceInfo.supportsExternalMemory || !actuallyExternal) {
+    if (!sVkEmulation->deviceInfo.supportsExternalMemoryExport || !actuallyExternal) {
         return true;
     }
 
+    VkResult exportRes = VK_SUCCESS;
 #ifdef _WIN32
     VkMemoryGetWin32HandleInfoKHR getWin32HandleInfo = {
         VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
@@ -1452,28 +1495,26 @@
         info->memory,
         VK_EXT_MEMORY_HANDLE_TYPE_BIT,
     };
-    VkResult exportRes = sVkEmulation->deviceInfo.getMemoryHandleFunc(
-        sVkEmulation->device, &getWin32HandleInfo, &info->exportedHandle);
-#else
+    exportRes = sVkEmulation->deviceInfo.getMemoryHandleFunc(
+        sVkEmulation->device, &getWin32HandleInfo, &info->externalHandle);
+#elif !defined(__QNX__)
     VkMemoryGetFdInfoKHR getFdInfo = {
         VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
         0,
         info->memory,
         VK_EXT_MEMORY_HANDLE_TYPE_BIT,
     };
-    VkResult exportRes = sVkEmulation->deviceInfo.getMemoryHandleFunc(
-        sVkEmulation->device, &getFdInfo, &info->exportedHandle);
+    exportRes = sVkEmulation->deviceInfo.getMemoryHandleFunc(sVkEmulation->device, &getFdInfo,
+                                                             &info->externalHandle);
 #endif
 
-    if (exportRes != VK_SUCCESS) {
+    if (exportRes != VK_SUCCESS || VK_EXT_MEMORY_HANDLE_INVALID == info->externalHandle) {
         // LOG(VERBOSE) << "allocExternalMemory: Failed to get external memory "
         //                 "native handle: "
         //              << exportRes;
         return false;
     }
 
-    info->actuallyExternal = true;
-
     return true;
 }
 
@@ -1497,13 +1538,13 @@
 
     info->memory = VK_NULL_HANDLE;
 
-    if (info->exportedHandle != VK_EXT_MEMORY_HANDLE_INVALID) {
+    if (info->externalHandle != VK_EXT_MEMORY_HANDLE_INVALID) {
 #ifdef _WIN32
-        CloseHandle(info->exportedHandle);
-#else
-        close(info->exportedHandle);
+        CloseHandle(info->externalHandle);
+#elif !defined(__QNX__)
+        close(info->externalHandle);
 #endif
-        info->exportedHandle = VK_EXT_MEMORY_HANDLE_INVALID;
+        info->externalHandle = VK_EXT_MEMORY_HANDLE_INVALID;
     }
 }
 
@@ -1514,15 +1555,20 @@
         VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
         0,
         VK_EXT_MEMORY_HANDLE_TYPE_BIT,
-        info->exportedHandle,
+        info->externalHandle,
         0,
     };
+#elif defined(__QNX__)
+    VkImportScreenBufferInfoQNX importInfo = {
+        VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX,
+        info->externalHandle,
+    };
 #else
     VkImportMemoryFdInfoKHR importInfo = {
         VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
         0,
         VK_EXT_MEMORY_HANDLE_TYPE_BIT,
-        dupExternalMemory(info->exportedHandle),
+        dupExternalMemory(info->externalHandle),
     };
 #endif
     VkMemoryAllocateInfo allocInfo = {
@@ -1557,15 +1603,21 @@
         VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
         &dedicatedInfo,
         VK_EXT_MEMORY_HANDLE_TYPE_BIT,
-        info->exportedHandle,
+        info->externalHandle,
         0,
     };
+#elif defined(__QNX__)
+    VkImportScreenBufferInfoQNX importInfo = {
+        VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX,
+        &dedicatedInfo,
+        info->externalHandle,
+    };
 #else
     VkImportMemoryFdInfoKHR importInfo = {
         VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
         &dedicatedInfo,
         VK_EXT_MEMORY_HANDLE_TYPE_BIT,
-        info->exportedHandle,
+        info->externalHandle,
     };
 #endif
     VkMemoryAllocateInfo allocInfo = {
@@ -1794,6 +1846,43 @@
     return generateColorBufferVkImageCreateInfo_locked(format, width, height, tiling);
 }
 
+static bool updateExternalMemoryInfo(VK_EXT_MEMORY_HANDLE extMemHandle,
+                                     const VkMemoryRequirements* pMemReqs,
+                                     VkEmulation::ExternalMemoryInfo* pInfo) {
+    // Set externalHandle on the output info
+    pInfo->externalHandle = extMemHandle;
+
+#if defined(__QNX__)
+    VkScreenBufferPropertiesQNX screenBufferProps = {
+        VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX,
+        0,
+    };
+    auto vk = sVkEmulation->dvk;
+    VkResult queryRes =
+        vk->vkGetScreenBufferPropertiesQNX(sVkEmulation->device, extMemHandle, &screenBufferProps);
+    if (VK_SUCCESS != queryRes) {
+        VK_COMMON_ERROR("Failed to get QNX Screen Buffer properties, VK error: %d", queryRes);
+        return false;
+    }
+    if (!((1 << pInfo->typeIndex) & screenBufferProps.memoryTypeBits)) {
+        VK_COMMON_ERROR("QNX Screen buffer can not be imported to memory (typeIndex=%d): %d",
+                        pInfo->typeIndex);
+        return false;
+    }
+    if (screenBufferProps.allocationSize < pMemReqs->size) {
+        VK_COMMON_ERROR(
+            "QNX Screen buffer allocationSize (0x%lx) is not large enough for ColorBuffer image "
+            "size requirements (0x%lx)",
+            screenBufferProps.allocationSize, pMemReqs->size);
+        return false;
+    }
+    // Use the actual allocationSize for VkDeviceMemory object creation
+    pInfo->size = screenBufferProps.allocationSize;
+#endif
+
+    return true;
+}
+
 // TODO(liyl): Currently we can only specify required memoryProperty
 // for a color buffer.
 //
@@ -1810,27 +1899,37 @@
 // buffers of one type index for image and one type index for buffer
 // to begin with, via filtering from the host.
 
-bool setupVkColorBufferLocked(uint32_t width, uint32_t height, GLenum internalFormat,
-                              FrameworkFormat frameworkFormat, uint32_t colorBufferHandle,
-                              bool vulkanOnly, uint32_t memoryProperty) {
-    if (!isFormatVulkanCompatible(internalFormat)) {
-        VK_COMMON_VERBOSE("Failed to create Vk ColorBuffer: format:%d not compatible.",
-                          internalFormat);
+bool initializeVkColorBufferLocked(
+    uint32_t colorBufferHandle, VK_EXT_MEMORY_HANDLE extMemHandle = VK_EXT_MEMORY_HANDLE_INVALID) {
+    auto infoPtr = android::base::find(sVkEmulation->colorBuffers, colorBufferHandle);
+    // Not initialized
+    if (!infoPtr) {
         return false;
     }
-
-    auto infoPtr = android::base::find(sVkEmulation->colorBuffers, colorBufferHandle);
-
-    // Already setup
-    if (infoPtr) {
+    // Already initialized Vulkan memory and other related Vulkan objects
+    if (infoPtr->initialized) {
         return true;
     }
 
+    if (!isFormatVulkanCompatible(infoPtr->internalFormat)) {
+        VK_COMMON_VERBOSE("Failed to create Vk ColorBuffer: format:%d not compatible.",
+                          infoPtr->internalFormat);
+        return false;
+    }
+
+    if ((VK_EXT_MEMORY_HANDLE_INVALID != extMemHandle) &&
+        (!sVkEmulation->deviceInfo.supportsExternalMemoryImport)) {
+        VK_COMMON_ERROR(
+            "Failed to initialize Vk ColorBuffer -- extMemHandle provided, but device does "
+            "not support externalMemoryImport");
+        return false;
+    }
+
     VkFormat vkFormat;
-    bool glCompatible = (frameworkFormat == FRAMEWORK_FORMAT_GL_COMPATIBLE);
-    switch (frameworkFormat) {
+    bool glCompatible = (infoPtr->frameworkFormat == FRAMEWORK_FORMAT_GL_COMPATIBLE);
+    switch (infoPtr->frameworkFormat) {
         case FrameworkFormat::FRAMEWORK_FORMAT_GL_COMPATIBLE:
-            vkFormat = glFormat2VkFormat(internalFormat);
+            vkFormat = glFormat2VkFormat(infoPtr->internalFormat);
             break;
         case FrameworkFormat::FRAMEWORK_FORMAT_NV12:
             vkFormat = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
@@ -1843,24 +1942,16 @@
             vkFormat = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
             break;
         default:
-            VK_COMMON_ERROR("WARNING: unhandled framework format %d\n", frameworkFormat);
-            vkFormat = glFormat2VkFormat(internalFormat);
+            VK_COMMON_ERROR("WARNING: unhandled framework format %d\n", infoPtr->frameworkFormat);
+            vkFormat = glFormat2VkFormat(infoPtr->internalFormat);
             break;
     }
 
-    VkEmulation::ColorBufferInfo res;
-
-    res.handle = colorBufferHandle;
-
-    // TODO
-    res.frameworkFormat = frameworkFormat;
-    res.frameworkStride = 0;
-
-    VkImageTiling tiling = (memoryProperty & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
+    VkImageTiling tiling = (infoPtr->memoryProperty & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
                                ? VK_IMAGE_TILING_LINEAR
                                : VK_IMAGE_TILING_OPTIMAL;
-    std::unique_ptr<VkImageCreateInfo> imageCi =
-        generateColorBufferVkImageCreateInfo_locked(vkFormat, width, height, tiling);
+    std::unique_ptr<VkImageCreateInfo> imageCi = generateColorBufferVkImageCreateInfo_locked(
+        vkFormat, infoPtr->width, infoPtr->height, tiling);
     // pNext will be filled later.
     if (imageCi == nullptr) {
         // it can happen if the format is not supported
@@ -1880,7 +1971,8 @@
 
     VkExternalMemoryImageCreateInfo* extImageCiPtr = nullptr;
 
-    if (sVkEmulation->deviceInfo.supportsExternalMemory) {
+    if (sVkEmulation->deviceInfo.supportsExternalMemoryImport ||
+        sVkEmulation->deviceInfo.supportsExternalMemoryExport) {
         extImageCiPtr = &extImageCi;
     }
 
@@ -1889,18 +1981,19 @@
     auto vk = sVkEmulation->dvk;
 
     VkResult createRes =
-        vk->vkCreateImage(sVkEmulation->device, imageCi.get(), nullptr, &res.image);
+        vk->vkCreateImage(sVkEmulation->device, imageCi.get(), nullptr, &infoPtr->image);
     if (createRes != VK_SUCCESS) {
         // LOG(VERBOSE) << "Failed to create Vulkan image for ColorBuffer "
         //              << colorBufferHandle;
         return false;
     }
 
-    bool useDedicated = sVkEmulation->useDedicatedAllocations;
+    bool useDedicated =
+        sVkEmulation->useDedicatedAllocations || (VK_EXT_MEMORY_HANDLE_INVALID != extMemHandle);
 
-    res.imageCreateInfoShallow = vk_make_orphan_copy(*imageCi);
-    res.currentLayout = res.imageCreateInfoShallow.initialLayout;
-    res.currentQueueFamilyIndex = sVkEmulation->queueFamilyIndex;
+    infoPtr->imageCreateInfoShallow = vk_make_orphan_copy(*imageCi);
+    infoPtr->currentLayout = infoPtr->imageCreateInfoShallow.initialLayout;
+    infoPtr->currentQueueFamilyIndex = sVkEmulation->queueFamilyIndex;
 
     if (!useDedicated && vk->vkGetImageMemoryRequirements2KHR) {
         VkMemoryDedicatedRequirements dedicated_reqs{
@@ -1908,28 +2001,28 @@
         VkMemoryRequirements2 reqs{VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, &dedicated_reqs};
 
         VkImageMemoryRequirementsInfo2 info{VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
-                                            nullptr, res.image};
+                                            nullptr, infoPtr->image};
         vk->vkGetImageMemoryRequirements2KHR(sVkEmulation->device, &info, &reqs);
         useDedicated = dedicated_reqs.requiresDedicatedAllocation;
-        res.memReqs = reqs.memoryRequirements;
+        infoPtr->memReqs = reqs.memoryRequirements;
     } else {
-        vk->vkGetImageMemoryRequirements(sVkEmulation->device, res.image, &res.memReqs);
+        vk->vkGetImageMemoryRequirements(sVkEmulation->device, infoPtr->image, &infoPtr->memReqs);
     }
 
     // Currently we only care about two memory properties: DEVICE_LOCAL
     // and HOST_VISIBLE; other memory properties specified in
     // rcSetColorBufferVulkanMode2() call will be ignored for now.
-    memoryProperty = memoryProperty &
-                     (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+    infoPtr->memoryProperty = infoPtr->memoryProperty & (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
+                                                         VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
 
-    res.memory.size = res.memReqs.size;
+    infoPtr->memory.size = infoPtr->memReqs.size;
 
     // Determine memory type.
-    if (memoryProperty) {
-        res.memory.typeIndex =
-            lastGoodTypeIndexWithMemoryProperties(res.memReqs.memoryTypeBits, memoryProperty);
+    if (infoPtr->memoryProperty) {
+        infoPtr->memory.typeIndex = lastGoodTypeIndexWithMemoryProperties(
+            infoPtr->memReqs.memoryTypeBits, infoPtr->memoryProperty);
     } else {
-        res.memory.typeIndex = lastGoodTypeIndex(res.memReqs.memoryTypeBits);
+        infoPtr->memory.typeIndex = lastGoodTypeIndex(infoPtr->memReqs.memoryTypeBits);
     }
 
     // LOG(VERBOSE) << "ColorBuffer " << colorBufferHandle
@@ -1941,23 +2034,39 @@
     //                         .propertyFlags
     //              << ", requested memory property: " << memoryProperty;
 
-    bool isHostVisible = memoryProperty & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
-    Optional<uint64_t> deviceAlignment =
-        isHostVisible ? Optional<uint64_t>(res.memReqs.alignment) : kNullopt;
-    Optional<VkImage> dedicatedImage = useDedicated ? Optional<VkImage>(res.image) : kNullopt;
-    bool allocRes = allocExternalMemory(vk, &res.memory, true /*actuallyExternal*/, deviceAlignment,
-                                        kNullopt, dedicatedImage);
-
-    if (!allocRes) {
-        // LOG(VERBOSE) << "Failed to allocate ColorBuffer with Vulkan backing.";
-        return false;
+    Optional<VkImage> dedicatedImage = useDedicated ? Optional<VkImage>(infoPtr->image) : kNullopt;
+    if (VK_EXT_MEMORY_HANDLE_INVALID != extMemHandle) {
+        if (!updateExternalMemoryInfo(extMemHandle, &infoPtr->memReqs, &infoPtr->memory)) {
+            VK_COMMON_ERROR(
+                "Failed to update external memory info for ColorBuffer: %d\n",
+                colorBufferHandle);
+            return false;
+        }
+        if (!importExternalMemoryDedicatedImage(vk, sVkEmulation->device, &infoPtr->memory,
+                                                *dedicatedImage, &infoPtr->memory.memory)) {
+            VK_COMMON_ERROR(
+                "Failed to import external memory with dedicated Image for colorBuffer: %d\n",
+                colorBufferHandle);
+            return false;
+        }
+    } else {
+        bool isHostVisible = infoPtr->memoryProperty & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+        Optional<uint64_t> deviceAlignment =
+            isHostVisible ? Optional<uint64_t>(infoPtr->memReqs.alignment) : kNullopt;
+        bool allocRes = allocExternalMemory(vk, &infoPtr->memory, true /*actuallyExternal*/,
+                                            deviceAlignment, kNullopt, dedicatedImage);
+        if (!allocRes) {
+            // LOG(VERBOSE) << "Failed to allocate ColorBuffer with Vulkan backing.";
+            return false;
+        }
     }
 
-    res.memory.pageOffset = reinterpret_cast<uint64_t>(res.memory.mappedPtr) % kPageSize;
-    res.memory.bindOffset = res.memory.pageOffset ? kPageSize - res.memory.pageOffset : 0u;
+    infoPtr->memory.pageOffset = reinterpret_cast<uint64_t>(infoPtr->memory.mappedPtr) % kPageSize;
+    infoPtr->memory.bindOffset =
+        infoPtr->memory.pageOffset ? kPageSize - infoPtr->memory.pageOffset : 0u;
 
-    VkResult bindImageMemoryRes = vk->vkBindImageMemory(sVkEmulation->device, res.image,
-                                                        res.memory.memory, res.memory.bindOffset);
+    VkResult bindImageMemoryRes = vk->vkBindImageMemory(
+        sVkEmulation->device, infoPtr->image, infoPtr->memory.memory, infoPtr->memory.bindOffset);
 
     if (bindImageMemoryRes != VK_SUCCESS) {
         fprintf(stderr, "%s: Failed to bind image memory. %d\n", __func__, bindImageMemoryRes);
@@ -1968,9 +2077,9 @@
         .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
         .pNext = nullptr,
         .flags = 0,
-        .image = res.image,
+        .image = infoPtr->image,
         .viewType = VK_IMAGE_VIEW_TYPE_2D,
-        .format = res.imageCreateInfoShallow.format,
+        .format = infoPtr->imageCreateInfoShallow.format,
         .components =
             {
                 .r = VK_COMPONENT_SWIZZLE_IDENTITY,
@@ -1987,7 +2096,8 @@
                 .layerCount = 1,
             },
     };
-    createRes = vk->vkCreateImageView(sVkEmulation->device, &imageViewCi, nullptr, &res.imageView);
+    createRes =
+        vk->vkCreateImageView(sVkEmulation->device, &imageViewCi, nullptr, &infoPtr->imageView);
     if (createRes != VK_SUCCESS) {
         // LOG(VERBOSE) << "Failed to create Vulkan image for ColorBuffer "
         //              << colorBufferHandle;
@@ -1996,15 +2106,39 @@
 
 #if defined(VK_MVK_moltenvk) && defined(__APPLE__)
     if (sVkEmulation->instanceSupportsMoltenVK) {
-        sVkEmulation->getMTLTextureFunc(res.image, &res.mtlTexture);
-        if (!res.mtlTexture) {
+        sVkEmulation->getMTLTextureFunc(infoPtr->image, &infoPtr->mtlTexture);
+        if (!infoPtr->mtlTexture) {
             fprintf(stderr, "%s: Failed to get MTLTexture.\n", __func__);
         }
 
-        CFRetain(res.mtlTexture);
+        CFRetain(infoPtr->mtlTexture);
     }
 #endif
 
+    infoPtr->initialized = true;
+
+    return true;
+}
+
+bool createVkColorBufferLocked(uint32_t width, uint32_t height, GLenum internalFormat,
+                               FrameworkFormat frameworkFormat, uint32_t colorBufferHandle,
+                               bool vulkanOnly, uint32_t memoryProperty) {
+    auto infoPtr = android::base::find(sVkEmulation->colorBuffers, colorBufferHandle);
+    // Already initialized
+    if (infoPtr) {
+        return true;
+    }
+
+    VkEmulation::ColorBufferInfo res;
+
+    res.handle = colorBufferHandle;
+    res.width = width;
+    res.height = height;
+    res.memoryProperty = memoryProperty;
+    res.internalFormat = internalFormat;
+    res.frameworkFormat = frameworkFormat;
+    res.frameworkStride = 0;
+
     if (vulkanOnly) {
         res.vulkanMode = VkEmulation::VulkanMode::VulkanOnly;
     }
@@ -2013,16 +2147,30 @@
     return true;
 }
 
-bool setupVkColorBuffer(uint32_t width, uint32_t height, GLenum internalFormat,
-                        FrameworkFormat frameworkFormat, uint32_t colorBufferHandle,
-                        bool vulkanOnly, uint32_t memoryProperty) {
+bool createVkColorBuffer(uint32_t width, uint32_t height, GLenum internalFormat,
+                         FrameworkFormat frameworkFormat, uint32_t colorBufferHandle,
+                         bool vulkanOnly, uint32_t memoryProperty) {
     if (!sVkEmulation || !sVkEmulation->live) {
         GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "VkEmulation not available.";
     }
 
     AutoLock lock(sVkEmulationLock);
-    return setupVkColorBufferLocked(width, height, internalFormat, frameworkFormat,
-                                    colorBufferHandle, vulkanOnly, memoryProperty);
+    if (!createVkColorBufferLocked(width, height, internalFormat, frameworkFormat,
+                                   colorBufferHandle, vulkanOnly, memoryProperty)) {
+        return false;
+    }
+
+    const auto& deviceInfo = sVkEmulation->deviceInfo;
+    if (!deviceInfo.supportsExternalMemoryExport && deviceInfo.supportsExternalMemoryImport) {
+        /* Returns, deferring initialization of the Vulkan components themselves.
+         * Platforms that support import but not export of external memory must
+         * use importExtMemoryHandleToVkColorBuffer(). Otherwise, the colorBuffer
+         * memory can not be externalized.
+         */
+        return true;
+    }
+
+    return initializeVkColorBufferLocked(colorBufferHandle);
 }
 
 std::optional<VkColorBufferMemoryExport> exportColorBufferMemory(uint32_t colorBufferHandle) {
@@ -2033,7 +2181,8 @@
     AutoLock lock(sVkEmulationLock);
 
     const auto& deviceInfo = sVkEmulation->deviceInfo;
-    if (!deviceInfo.supportsExternalMemory || !deviceInfo.glInteropSupported) {
+    if ((!(deviceInfo.supportsExternalMemoryExport || !deviceInfo.supportsExternalMemoryImport)) ||
+        (!deviceInfo.glInteropSupported)) {
         return std::nullopt;
     }
 
@@ -2046,7 +2195,8 @@
         return std::nullopt;
     }
 
-    ManagedDescriptor descriptor(dupExternalMemory(info->memory.exportedHandle));
+#if !defined(__QNX__)
+    ManagedDescriptor descriptor(dupExternalMemory(info->memory.externalHandle));
 
     info->glExported = true;
 
@@ -2056,6 +2206,9 @@
         .linearTiling = info->imageCreateInfoShallow.tiling == VK_IMAGE_TILING_LINEAR,
         .dedicatedAllocation = info->memory.dedicatedAllocation,
     };
+#else
+    return std::nullopt;
+#endif
 }
 
 bool teardownVkColorBufferLocked(uint32_t colorBufferHandle) {
@@ -2067,20 +2220,22 @@
 
     if (!infoPtr) return false;
 
-    auto& info = *infoPtr;
-    {
-        android::base::AutoLock lock(*sVkEmulation->queueLock);
-        VK_CHECK(vk->vkQueueWaitIdle(sVkEmulation->queue));
-    }
-    vk->vkDestroyImageView(sVkEmulation->device, info.imageView, nullptr);
-    vk->vkDestroyImage(sVkEmulation->device, info.image, nullptr);
-    freeExternalMemoryLocked(vk, &info.memory);
+    if (infoPtr->initialized) {
+        auto& info = *infoPtr;
+        {
+            android::base::AutoLock lock(*sVkEmulation->queueLock);
+            VK_CHECK(vk->vkQueueWaitIdle(sVkEmulation->queue));
+        }
+        vk->vkDestroyImageView(sVkEmulation->device, info.imageView, nullptr);
+        vk->vkDestroyImage(sVkEmulation->device, info.image, nullptr);
+        freeExternalMemoryLocked(vk, &info.memory);
 
 #ifdef __APPLE__
-    if (info.mtlTexture) {
-        CFRelease(info.mtlTexture);
-    }
+        if (info.mtlTexture) {
+            CFRelease(info.mtlTexture);
+        }
 #endif
+    }
 
     sVkEmulation->colorBuffers.erase(colorBufferHandle);
 
@@ -2094,6 +2249,21 @@
     return teardownVkColorBufferLocked(colorBufferHandle);
 }
 
+bool importExtMemoryHandleToVkColorBuffer(uint32_t colorBufferHandle, uint32_t type,
+                                          VK_EXT_MEMORY_HANDLE extMemHandle) {
+    if (!sVkEmulation || !sVkEmulation->live) {
+        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "VkEmulation not available.";
+    }
+    if (VK_EXT_MEMORY_HANDLE_INVALID == extMemHandle) {
+        return false;
+    }
+
+    AutoLock lock(sVkEmulationLock);
+    // Initialize the colorBuffer with the external memory handle
+    // Note that this will fail if the colorBuffer memory was previously initialized.
+    return initializeVkColorBufferLocked(colorBufferHandle, extMemHandle);
+}
+
 VkEmulation::ColorBufferInfo getColorBufferInfo(uint32_t colorBufferHandle) {
     VkEmulation::ColorBufferInfo res;
 
@@ -2528,7 +2698,7 @@
         return VK_EXT_MEMORY_HANDLE_INVALID;
     }
 
-    return infoPtr->memory.exportedHandle;
+    return infoPtr->memory.externalHandle;
 }
 
 bool setColorBufferVulkanMode(uint32_t colorBuffer, uint32_t vulkanMode) {
@@ -2684,7 +2854,8 @@
     };
 
     VkExternalMemoryBufferCreateInfo* extBufferCiPtr = nullptr;
-    if (sVkEmulation->deviceInfo.supportsExternalMemory) {
+    if (sVkEmulation->deviceInfo.supportsExternalMemoryImport ||
+        sVkEmulation->deviceInfo.supportsExternalMemoryExport) {
         extBufferCiPtr = &extBufferCi;
     }
 
@@ -2818,7 +2989,7 @@
         return VK_EXT_MEMORY_HANDLE_INVALID;
     }
 
-    return infoPtr->memory.exportedHandle;
+    return infoPtr->memory.externalHandle;
 }
 
 bool readBufferToBytes(uint32_t bufferHandle, uint64_t offset, uint64_t size, void* outBytes) {
@@ -3021,6 +3192,15 @@
         res &= ~VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA;
         res |= VK_EXT_MEMORY_HANDLE_TYPE_BIT;
     }
+
+#if defined(__QNX__)
+    // QNX only: Replace DMA_BUF_BIT_EXT with SCREEN_BUFFER_BIT_QNX for host calls
+    if (bits & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT) {
+        res &= ~VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
+        res |= VK_EXT_MEMORY_HANDLE_TYPE_BIT;
+    }
+#endif
+
     return res;
 }
 
@@ -3316,12 +3496,16 @@
     constexpr const uint32_t kArbitraryWidth = 64;
     constexpr const uint32_t kArbitraryHeight = 64;
     constexpr const uint32_t kArbitraryHandle = std::numeric_limits<uint32_t>::max();
-    if (!setupVkColorBufferLocked(kArbitraryWidth, kArbitraryHeight, GL_RGBA8,
-                                  FrameworkFormat::FRAMEWORK_FORMAT_GL_COMPATIBLE, kArbitraryHandle,
-                                  true, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) {
+    if (!createVkColorBufferLocked(kArbitraryWidth, kArbitraryHeight, GL_RGBA8,
+                                   FrameworkFormat::FRAMEWORK_FORMAT_GL_COMPATIBLE,
+                                   kArbitraryHandle, true, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) {
         ERR("Failed to setup memory type index test ColorBuffer.");
         return std::nullopt;
     }
+    if (!initializeVkColorBufferLocked(kArbitraryHandle)) {
+        ERR("Failed to initialize memory type index test ColorBuffer.");
+        return std::nullopt;
+    }
 
     uint32_t memoryTypeIndex = 0;
     if (!getColorBufferAllocationInfoLocked(kArbitraryHandle, nullptr, &memoryTypeIndex, nullptr,
diff --git a/host/vulkan/VkCommonOperations.h b/host/vulkan/VkCommonOperations.h
index 958a57f..ae81350 100644
--- a/host/vulkan/VkCommonOperations.h
+++ b/host/vulkan/VkCommonOperations.h
@@ -52,13 +52,20 @@
 typedef void* HANDLE;
 #endif
 
-// External memory objects are HANDLE on Windows and fd's on POSIX systems.
-#ifdef _WIN32
+#if defined(_WIN32)
+// External memory objects are HANDLE on Windows
 typedef HANDLE VK_EXT_MEMORY_HANDLE;
 // corresponds to INVALID_HANDLE_VALUE
 #define VK_EXT_MEMORY_HANDLE_INVALID (VK_EXT_MEMORY_HANDLE)(uintptr_t)(-1)
 #define VK_EXT_MEMORY_HANDLE_TYPE_BIT VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
+#elif defined(__QNX__)
+#include <screen/screen.h>
+// External memory objects are screen_buffer_t handles on QNX
+typedef screen_buffer_t VK_EXT_MEMORY_HANDLE;
+#define VK_EXT_MEMORY_HANDLE_INVALID (VK_EXT_MEMORY_HANDLE) nullptr
+#define VK_EXT_MEMORY_HANDLE_TYPE_BIT VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX
 #else
+// External memory objects are fd's on other POSIX systems
 typedef int VK_EXT_MEMORY_HANDLE;
 #define VK_EXT_MEMORY_HANDLE_INVALID (-1)
 #define VK_EXT_MEMORY_HANDLE_TYPE_BIT VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
@@ -174,7 +181,8 @@
     struct DeviceSupportInfo {
         bool hasGraphicsQueueFamily = false;
         bool hasComputeQueueFamily = false;
-        bool supportsExternalMemory = false;
+        bool supportsExternalMemoryImport = false;
+        bool supportsExternalMemoryExport = false;
         bool supportsIdProperties = false;
         bool supportsDriverProperties = false;
         bool hasSamplerYcbcrConversionExtension = false;
@@ -226,8 +234,8 @@
         // guest physical address.
         uintptr_t gpa = 0u;
 
-        VK_EXT_MEMORY_HANDLE exportedHandle = VK_EXT_MEMORY_HANDLE_INVALID;
-        bool actuallyExternal = false;
+        VK_EXT_MEMORY_HANDLE externalHandle = VK_EXT_MEMORY_HANDLE_INVALID;
+
         bool dedicatedAllocation = false;
     };
 
@@ -286,8 +294,14 @@
 
         uint32_t handle;
 
+        /* Set in create(), before initialize() */
+        uint32_t width;
+        uint32_t height;
+        GLenum internalFormat;
+        uint32_t memoryProperty;
         int frameworkFormat;
         int frameworkStride;
+        bool initialized = false;
 
         VkImage image = VK_NULL_HANDLE;
         VkImageView imageView = VK_NULL_HANDLE;
@@ -435,12 +449,15 @@
                                                                         uint32_t height,
                                                                         VkImageTiling tiling);
 
-bool setupVkColorBuffer(uint32_t width, uint32_t height, GLenum format,
-                        FrameworkFormat frameworkFormat, uint32_t colorBufferHandle,
-                        bool vulkanOnly, uint32_t memoryProperty);
+bool createVkColorBuffer(uint32_t width, uint32_t height, GLenum format,
+                         FrameworkFormat frameworkFormat, uint32_t colorBufferHandle,
+                         bool vulkanOnly, uint32_t memoryProperty);
 
 bool teardownVkColorBuffer(uint32_t colorBufferHandle);
 
+bool importExtMemoryHandleToVkColorBuffer(uint32_t colorBufferHandle, uint32_t type,
+                                          VK_EXT_MEMORY_HANDLE extMemHandle);
+
 VkEmulation::ColorBufferInfo getColorBufferInfo(uint32_t colorBufferHandle);
 VK_EXT_MEMORY_HANDLE getColorBufferExtMemoryHandle(uint32_t colorBufferHandle);
 
diff --git a/host/vulkan/VkDecoderGlobalState.cpp b/host/vulkan/VkDecoderGlobalState.cpp
index 065c9b6..765e17b 100644
--- a/host/vulkan/VkDecoderGlobalState.cpp
+++ b/host/vulkan/VkDecoderGlobalState.cpp
@@ -127,6 +127,31 @@
     }
 }
 
+#if defined(_WIN32)
+// External sync objects are HANDLE on Windows
+typedef HANDLE VK_EXT_SYNC_HANDLE;
+// corresponds to INVALID_HANDLE_VALUE
+#define VK_EXT_SYNC_HANDLE_INVALID (VK_EXT_SYNC_HANDLE)(uintptr_t)(-1)
+#else
+// External sync objects are fd's on other POSIX systems
+typedef int VK_EXT_SYNC_HANDLE;
+#define VK_EXT_SYNC_HANDLE_INVALID (-1)
+#endif
+
+VK_EXT_SYNC_HANDLE dupExternalSync(VK_EXT_SYNC_HANDLE h) {
+#ifdef _WIN32
+    auto myProcessHandle = GetCurrentProcess();
+    VK_EXT_SYNC_HANDLE res;
+    DuplicateHandle(myProcessHandle, h,     // source process and handle
+                    myProcessHandle, &res,  // target process and pointer to handle
+                    0 /* desired access (ignored) */, true /* inherit */,
+                    DUPLICATE_SAME_ACCESS /* same access option */);
+    return res;
+#else
+    return dup(h);
+#endif
+}
+
 // A list of device extensions that should not be passed to the host driver.
 // These will mainly include Vulkan features that we emulate ourselves.
 static constexpr const char* const kEmulatedDeviceExtensions[] = {
@@ -142,6 +167,10 @@
     VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME,
     VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME,
     VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME,
+#if defined(__QNX__)
+    VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME,
+    VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME,
+#endif
 };
 
 // A list of instance extensions that should not be passed to the host driver.
@@ -2086,7 +2115,7 @@
             return VK_ERROR_INVALID_EXTERNAL_HANDLE;
         }
 
-        VK_EXT_MEMORY_HANDLE handle = dupExternalMemory(infoPtr->externalHandle);
+        VK_EXT_SYNC_HANDLE handle = dupExternalSync(infoPtr->externalHandle);
 
         VkImportSemaphoreWin32HandleInfoKHR win32ImportInfo = {
             VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
@@ -2117,7 +2146,7 @@
             pGetFdInfo->semaphore,
             VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
         };
-        VK_EXT_MEMORY_HANDLE handle;
+        VK_EXT_SYNC_HANDLE handle;
         VkResult result = vk->vkGetSemaphoreWin32HandleKHR(device, &getWin32, &handle);
         if (result != VK_SUCCESS) {
             return result;
@@ -2146,7 +2175,7 @@
 #ifndef _WIN32
         const auto& ite = mSemaphoreInfo.find(semaphore);
         if (ite != mSemaphoreInfo.end() &&
-            (ite->second.externalHandle != VK_EXT_MEMORY_HANDLE_INVALID)) {
+            (ite->second.externalHandle != VK_EXT_SYNC_HANDLE_INVALID)) {
             close(ite->second.externalHandle);
         }
 #endif
@@ -3409,6 +3438,12 @@
             VK_EXT_MEMORY_HANDLE_INVALID,
             L"",
         };
+#elif defined(__QNX__)
+        VkImportScreenBufferInfoQNX importInfo{
+            VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX,
+            0,
+            VK_EXT_MEMORY_HANDLE_INVALID,
+        };
 #else
         VkImportMemoryFdInfoKHR importInfo{
             VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
@@ -3454,6 +3489,9 @@
                     return VK_ERROR_OUT_OF_DEVICE_MEMORY;
                 }
 
+#if defined(__QNX__)
+                importInfo.buffer = cbExtMemoryHandle;
+#else
                 externalMemoryHandle = ManagedDescriptor(dupExternalMemory(cbExtMemoryHandle));
 
 #ifdef _WIN32
@@ -3461,6 +3499,7 @@
 #else
                 importInfo.fd = externalMemoryHandle.get().value_or(-1);
 #endif
+#endif
                 vk_append_struct(&structChainIter, &importInfo);
             }
         }
@@ -3489,6 +3528,9 @@
                     return VK_ERROR_OUT_OF_DEVICE_MEMORY;
                 }
 
+#if defined(__QNX__)
+                importInfo.buffer = bufferExtMemoryHandle;
+#else
                 bufferExtMemoryHandle = dupExternalMemory(bufferExtMemoryHandle);
 
 #ifdef _WIN32
@@ -3496,6 +3538,7 @@
 #else
                 importInfo.fd = bufferExtMemoryHandle;
 #endif
+#endif
                 vk_append_struct(&structChainIter, &importInfo);
             }
         }
@@ -3577,7 +3620,7 @@
                 ERR("Failed vkAllocateMemory: missing descriptor info.");
                 return VK_ERROR_OUT_OF_DEVICE_MEMORY;
             }
-#if defined(__linux__) || defined(__QNX__)
+#if defined(__linux__)
             importInfo.fd = rawDescriptor;
 #endif
 
@@ -3832,7 +3875,6 @@
         const auto& props = emu->deviceInfo.physdevProps;
 
         res.supportsVulkan1_1 = props.apiVersion >= VK_API_VERSION_1_1;
-        res.supportsExternalMemory = emu->deviceInfo.supportsExternalMemory;
         res.useDeferredCommands = emu->useDeferredCommands;
         res.useCreateResourcesWithRequirements = emu->useCreateResourcesWithRequirements;
 
@@ -5795,6 +5837,12 @@
         if (hasDeviceExtension(properties, VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME)) {
             res.push_back(VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME);
         }
+#elif defined(__QNX__)
+        // Note: VK_QNX_external_memory_screen_buffer is not supported in API translation,
+        // decoding, etc. However, push name to indicate external memory support to guest
+        if (hasDeviceExtension(properties, VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME)) {
+            res.push_back(VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME);
+        }
 #elif __unix__
         if (hasDeviceExtension(properties, VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME)) {
             res.push_back(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
@@ -6532,7 +6580,7 @@
     struct SemaphoreInfo {
         VkDevice device;
         int externalHandleId = 0;
-        VK_EXT_MEMORY_HANDLE externalHandle = VK_EXT_MEMORY_HANDLE_INVALID;
+        VK_EXT_SYNC_HANDLE externalHandle = VK_EXT_SYNC_HANDLE_INVALID;
     };
 
     struct DescriptorSetLayoutInfo {
diff --git a/host/vulkan/VkDecoderGlobalState.h b/host/vulkan/VkDecoderGlobalState.h
index b8cb5be..4b2d0dc 100644
--- a/host/vulkan/VkDecoderGlobalState.h
+++ b/host/vulkan/VkDecoderGlobalState.h
@@ -406,7 +406,6 @@
     struct HostFeatureSupport {
         bool supportsVulkan = false;
         bool supportsVulkan1_1 = false;
-        bool supportsExternalMemory = false;
         bool useDeferredCommands = false;
         bool useCreateResourcesWithRequirements = false;
         uint32_t apiVersion = 0;
diff --git a/host/vulkan/cereal/common/vk_struct_id.h b/host/vulkan/cereal/common/vk_struct_id.h
index fc321ec..0953a43 100644
--- a/host/vulkan/cereal/common/vk_struct_id.h
+++ b/host/vulkan/cereal/common/vk_struct_id.h
@@ -71,4 +71,10 @@
 REGISTER_VK_STRUCT_ID(VkMemoryOpaqueCaptureAddressAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO);
 REGISTER_VK_STRUCT_ID(VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT)
 
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX,
+                      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX);
+REGISTER_VK_STRUCT_ID(VkImportScreenBufferInfoQNX, VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX);
+#endif
+
 #undef REGISTER_VK_STRUCT_ID
diff --git a/host/vulkan/cereal/meson.build b/host/vulkan/cereal/meson.build
index d9f917d..b59d839 100644
--- a/host/vulkan/cereal/meson.build
+++ b/host/vulkan/cereal/meson.build
@@ -15,6 +15,10 @@
   '-DVK_GOOGLE_address_space',
 ]
 
+if host_machine.system() == 'qnx'
+  cereal_cpp_args += '-DVK_USE_PLATFORM_SCREEN_QNX'
+endif
+
 lib_vulkan_cereal = static_library(
   'cereal',
   files_lib_cereal,