diff --git a/BUILD.md b/BUILD.md
index 098ce88..69bc8b4 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -172,6 +172,7 @@
 | BUILD_WSI_XLIB_SUPPORT | Linux | `ON` | Build the loader with the Xlib entry points enabled. Without this, the X11 headers should not be needed, but the extension `VK_KHR_xlib_surface` won't be available. |
 | BUILD_WSI_WAYLAND_SUPPORT | Linux | `ON` | Build the loader with the Wayland entry points enabled. Without this, the Wayland headers should not be needed, but the extension `VK_KHR_wayland_surface` won't be available. |
 | BUILD_WSI_DIRECTFB_SUPPORT | Linux | `OFF` | Build the loader with the DirectFB entry points enabled. Without this, the DirectFB headers should not be needed, but the extension `VK_EXT_directfb_surface` won't be available. |
+| BUILD_WSI_SCREEN_SUPPORT | QNX | `OFF` | Build the loader with the QNX Screen entry points enabled. Without this the extension `VK_QNX_screen_surface` won't be available. |
 | ENABLE_WIN10_ONECORE | Windows | `OFF` | Link the loader to the [OneCore](https://msdn.microsoft.com/en-us/library/windows/desktop/mt654039.aspx) umbrella library, instead of the standard Win32 ones. |
 | USE_CCACHE | Linux | `OFF` | Enable caching with the CCache program. |
 | USE_MASM | Windows | `ON` | Controls whether to build assembly files with MS assembler, else fallback to C code |
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a26e384..3dadc63 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -122,6 +122,7 @@
     option(BUILD_WSI_XLIB_SUPPORT "Build Xlib WSI support" ON)
     option(BUILD_WSI_WAYLAND_SUPPORT "Build Wayland WSI support" ON)
     option(BUILD_WSI_DIRECTFB_SUPPORT "Build DirectFB WSI support" OFF)
+    option(BUILD_WSI_SCREEN_SUPPORT "Build QNX Screen WSI support" OFF)
 
     if(BUILD_WSI_XCB_SUPPORT)
         find_package(XCB REQUIRED)
@@ -140,6 +141,10 @@
         find_package(DirectFB REQUIRED)
         include_directories(SYSTEM ${DIRECTFB_INCLUDE_DIR})
     endif()
+
+    if(BUILD_WSI_SCREEN_SUPPORT)
+        # Part of OS, no additional include directories are required
+    endif()
 endif()
 
 if(WIN32)
diff --git a/build-qnx/common.mk b/build-qnx/common.mk
new file mode 100644
index 0000000..c5aa587
--- /dev/null
+++ b/build-qnx/common.mk
@@ -0,0 +1,44 @@
+ifndef QCONFIG
+QCONFIG=qconfig.mk
+endif
+include $(QCONFIG)
+
+define PINFO
+PINFO DESCRIPTION = "Vulkan ICD Loader"
+endef
+
+ICD_ROOT=$(CURDIR)/../../../..
+
+EXTRA_INCVPATH+=$(ICD_ROOT)/build_qnx
+
+EXTRA_SRCVPATH+=$(ICD_ROOT)/loader
+EXTRA_SRCVPATH+=$(ICD_ROOT)/loader/generated
+
+SO_VERSION=1
+NAME=vulkan
+
+# Make the library
+
+SRCS = cJSON.c debug_utils.c dev_ext_trampoline.c loader.c murmurhash.c \
+	phys_dev_ext.c trampoline.c unknown_ext_chain.c wsi.c \
+	extension_manual.c
+
+LDFLAGS += -Wl,--unresolved-symbols=report-all -Wl,--no-undefined -Wl,-fPIC
+
+include $(MKFILES_ROOT)/qtargets.mk
+
+CCFLAGS += -DVK_USE_PLATFORM_SCREEN_QNX=1 -Dvulkan_EXPORTS
+CCFLAGS += -Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers
+CCFLAGS += -fno-strict-aliasing -fno-builtin-memcmp -Wno-stringop-truncation
+CCFLAGS += -Wno-stringop-overflow -Wimplicit-fallthrough=0 -fvisibility=hidden
+CCFLAGS += -Wpointer-arith -fPIC
+
+# Enable this if required
+# CCFLAGS += -DVK_ENABLE_BETA_EXTENSIONS
+
+CXXFLAGS += $(CCFLAGS)
+
+# cJSON requires math library for pow() function
+LIBS += m
+
+INSTALLDIR=usr/lib
diff --git a/build-qnx/loader_cmake_config.h b/build-qnx/loader_cmake_config.h
new file mode 100644
index 0000000..37d318f
--- /dev/null
+++ b/build-qnx/loader_cmake_config.h
@@ -0,0 +1,2 @@
+#undef HAVE_SECURE_GETENV
+#undef HAVE___SECURE_GETENV
diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt
index db1ad78..7c07efc 100644
--- a/loader/CMakeLists.txt
+++ b/loader/CMakeLists.txt
@@ -57,6 +57,10 @@
     if(BUILD_WSI_DIRECTFB_SUPPORT)
         set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_DIRECTFB_EXT)
     endif()
+
+    if(BUILD_WSI_SCREEN_SUPPORT)
+        set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_SCREEN_QNX)
+    endif()
 else()
     message(FATAL_ERROR "Unsupported Platform!")
 endif()
@@ -284,6 +288,7 @@
             ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan_xcb.h
             ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan_xlib.h
             ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan_xlib_xrandr.h
+            ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan_screen.h
             ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan.h
             ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan.hpp)
         if(BUILD_STATIC_LOADER)
diff --git a/loader/LoaderAndLayerInterface.md b/loader/LoaderAndLayerInterface.md
index 257deee..98d8d9b 100644
--- a/loader/LoaderAndLayerInterface.md
+++ b/loader/LoaderAndLayerInterface.md
@@ -697,6 +697,7 @@
 | Linux (Wayland) | VK_KHR_wayland_surface |
 | Linux (X11) |  VK_KHR_xcb_surface and VK_KHR_xlib_surface |
 | macOS (MoltenVK) | VK_MVK_macos_surface |
+| QNX (Screen) | VK_QNX_screen_surface |
 
 It is important to understand that while the loader may support the various
 entry points for these extensions, there is a handshake required to actually
@@ -2553,9 +2554,9 @@
 ### Handling KHR Surface Objects in WSI Extensions
 
 Normally, ICDs handle object creation and destruction for various Vulkan
-objects. The WSI surface extensions for Linux, Windows, and macOS
+objects. The WSI surface extensions for Linux, Windows, macOS, and QNX
 ("VK\_KHR\_win32\_surface", "VK\_KHR\_xcb\_surface", "VK\_KHR\_xlib\_surface",
-"VK\_KHR\_wayland\_surface", "VK\_MVK\_macos\_surface"
+"VK\_KHR\_wayland\_surface", "VK\_MVK\_macos\_surface", "VK\_QNX\_screen\_surface"
 and "VK\_KHR\_surface")
 are handled differently.  For these extensions, the `VkSurfaceKHR` object
 creation and destruction may be handled by either the loader  or an ICD.
@@ -2571,6 +2572,7 @@
       * Windows
       * Android
       * MacOS (`vkCreateMacOSSurfaceMVK`)
+      * QNX (`vkCreateScreenSurfaceQNX`)
  2. The loader creates a `VkIcdSurfaceXXX` object for the corresponding
 `vkCreateXXXSurfaceKHR` call.
     * The `VkIcdSurfaceXXX` structures are defined in `include/vulkan/vk_icd.h`.
@@ -2578,7 +2580,7 @@
     `VkIcdSurfaceXXX` structure.
  4. The first field of all the `VkIcdSurfaceXXX` structures is a
 `VkIcdSurfaceBase` enumerant that indicates whether the
-    surface object is Win32, XCB, Xlib, or Wayland.
+    surface object is Win32, XCB, Xlib, Wayland, or Screen.
 
 The ICD may choose to handle `VkSurfaceKHR` object creation instead.  If an ICD
 desires to handle creating and destroying it must do the following:
diff --git a/loader/loader.c b/loader/loader.c
index 6a60ee7..e12b24d 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -253,7 +253,7 @@
 }
 
 // Environment variables
-#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__)
+#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__) || defined(__QNXNTO__)
 
 static inline bool IsHighIntegrity() {
     return geteuid() != getuid() || getegid() != getgid();
@@ -3940,7 +3940,7 @@
     if (xdgdatadirs == NULL) {
         xdgdata_alloc = false;
     }
-#if !defined(__Fuchsia__)
+#if !defined(__Fuchsia__) && !defined(__QNXNTO__)
     if (xdgconfdirs == NULL || xdgconfdirs[0] == '\0') {
         xdgconfdirs = FALLBACK_CONFIG_DIRS;
     }
diff --git a/loader/loader.h b/loader/loader.h
index ea0c976..2182f18 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -348,6 +348,9 @@
 #ifdef VK_USE_PLATFORM_FUCHSIA
     bool wsi_imagepipe_surface_enabled;
 #endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    bool wsi_screen_surface_enabled;
+#endif
     bool wsi_display_enabled;
     bool wsi_display_props2_enabled;
 };
diff --git a/loader/vk_loader_platform.h b/loader/vk_loader_platform.h
index abf078c..437b3c3 100644
--- a/loader/vk_loader_platform.h
+++ b/loader/vk_loader_platform.h
@@ -35,7 +35,7 @@
 #include "vulkan/vk_platform.h"
 #include "vulkan/vk_sdk_platform.h"
 
-#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__)
+#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__) || defined(__QNXNTO__)
 /* Linux-specific common code: */
 
 // Headers:
@@ -124,7 +124,31 @@
 }
 #elif defined(__Fuchsia__)
 static inline char *loader_platform_executable_path(char *buffer, size_t size) { return NULL; }
-#endif  // defined (__APPLE__)
+#elif defined(__QNXNTO__)
+
+#define SYSCONFDIR "/etc"
+
+#include <fcntl.h>
+#include <sys/stat.h>
+
+static inline char *loader_platform_executable_path(char *buffer, size_t size) {
+    int fd = open("/proc/self/exefile", O_RDONLY);
+    size_t rdsize;
+
+    if (fd == -1 ) {
+        return NULL;
+    }
+
+    rdsize = read(fd, buffer, size);
+    if (rdsize == size) {
+        return NULL;
+    }
+    buffer[rdsize] = 0x00;
+    close(fd);
+
+    return buffer;
+}
+#endif  // defined (__QNXNTO__)
 
 // Compatability with compilers that don't support __has_feature
 #ifndef __has_feature
diff --git a/loader/wsi.c b/loader/wsi.c
index 756225a..7e87776 100644
--- a/loader/wsi.c
+++ b/loader/wsi.c
@@ -75,6 +75,9 @@
 #ifdef VK_USE_PLATFORM_METAL_EXT
     ptr_instance->wsi_metal_surface_enabled = false;
 #endif // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    ptr_instance->wsi_screen_surface_enabled = false;
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) {
@@ -151,6 +154,12 @@
             continue;
         }
 #endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_QNX_SCREEN_SURFACE_EXTENSION_NAME) == 0) {
+            ptr_instance->wsi_screen_surface_enabled = true;
+            continue;
+        }
+#endif // VK_USE_PLATFORM_SCREEN_QNX
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_display_enabled = true;
             continue;
@@ -184,6 +193,9 @@
 #ifndef VK_USE_PLATFORM_DIRECTFB_EXT
     if (!strcmp(ext_prop->extensionName, "VK_EXT_directfb_surface")) return true;
 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
+#ifndef VK_USE_PLATFORM_SCREEN_QNX
+    if (!strcmp(ext_prop->extensionName, "VK_QNX_screen_surface")) return true;
+#endif  // VK_USE_PLATFORM_WAYLAND_KHR
 
     return false;
 }
@@ -1469,6 +1481,120 @@
 
 #endif
 
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+
+// This is the trampoline entrypoint for CreateScrenSurfaceQNX
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance,
+                                                                       const VkScreenSurfaceCreateInfoQNX *pCreateInfo,
+                                                                       const VkAllocationCallbacks *pAllocator,
+                                                                       VkSurfaceKHR *pSurface) {
+    const VkLayerInstanceDispatchTable *disp;
+    disp = loader_get_instance_layer_dispatch(instance);
+    VkResult res;
+
+    res = disp->CreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface);
+    return res;
+}
+
+// This is the instance chain terminator function for CreateScreenSurfaceQNX
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateScreenSurfaceQNX(VkInstance instance,
+                                                                  const VkScreenSurfaceCreateInfoQNX *pCreateInfo,
+                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
+    VkResult vkRes = VK_SUCCESS;
+    VkIcdSurface *pIcdSurface = NULL;
+    uint32_t i = 0;
+
+    // First, check to ensure the appropriate extension was enabled:
+    struct loader_instance *ptr_instance = loader_get_instance(instance);
+    if (!ptr_instance->wsi_screen_surface_enabled) {
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+                   "VK_QNX_screen_surface extension not enabled.  vkCreateScreenSurfaceQNX not executed!\n");
+        vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
+        goto out;
+    }
+
+    // Next, if so, proceed with the implementation of this function:
+    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->screen_surf.base), sizeof(pIcdSurface->screen_surf));
+    if (pIcdSurface == NULL) {
+        vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
+        goto out;
+    }
+
+    pIcdSurface->screen_surf.base.platform = VK_ICD_WSI_PLATFORM_SCREEN;
+    pIcdSurface->screen_surf.context = pCreateInfo->context;
+    pIcdSurface->screen_surf.window = pCreateInfo->window;
+
+    // Loop through each ICD and determine if they need to create a surface
+    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
+            if (NULL != icd_term->dispatch.CreateScreenSurfaceQNX) {
+                vkRes = icd_term->dispatch.CreateScreenSurfaceQNX(icd_term->instance, pCreateInfo, pAllocator,
+                                                                   &pIcdSurface->real_icd_surfaces[i]);
+                if (VK_SUCCESS != vkRes) {
+                    goto out;
+                }
+            }
+        }
+    }
+
+    *pSurface = (VkSurfaceKHR)pIcdSurface;
+
+out:
+
+    if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
+        if (NULL != pIcdSurface->real_icd_surfaces) {
+            i = 0;
+            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
+                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) {
+                    icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
+                }
+            }
+            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
+        }
+        loader_instance_heap_free(ptr_instance, pIcdSurface);
+    }
+
+    return vkRes;
+}
+
+// This is the trampoline entrypoint for
+// GetPhysicalDeviceScreenPresentationSupportQNX
+LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
+                                                                                              uint32_t queueFamilyIndex,
+                                                                                              struct _screen_window *window) {
+    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
+    const VkLayerInstanceDispatchTable *disp;
+    disp = loader_get_instance_layer_dispatch(physicalDevice);
+    VkBool32 res = disp->GetPhysicalDeviceScreenPresentationSupportQNX(unwrapped_phys_dev, queueFamilyIndex, window);
+    return res;
+}
+
+// This is the instance chain terminator function for
+// GetPhysicalDeviceScreenPresentationSupportQNX
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
+                                                                                         uint32_t queueFamilyIndex,
+                                                                                         struct _screen_window *window) {
+    // First, check to ensure the appropriate extension was enabled:
+    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
+    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
+    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
+    if (!ptr_instance->wsi_screen_surface_enabled) {
+        loader_log(
+            ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+            "VK_QNX_screen_surface extension not enabled.  vkGetPhysicalDeviceScreenPresentationSupportQNX not executed!\n");
+        return VK_SUCCESS;
+    }
+
+    if (NULL == icd_term->dispatch.GetPhysicalDeviceScreenPresentationSupportQNX) {
+        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceScreenPresentationSupportQNX!\n");
+        assert(false && "loader: null GetPhysicalDeviceScreenPresentationSupportQNX ICD pointer");
+    }
+
+    return icd_term->dispatch.GetPhysicalDeviceScreenPresentationSupportQNX(phys_dev_term->phys_dev, queueFamilyIndex, window);
+}
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+
 // Functions for the VK_KHR_display instance extension:
 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
                                                                                      uint32_t *pPropertyCount,
@@ -2468,6 +2594,19 @@
     }
 #endif // VK_USE_PLATFORM_METAL_EXT
 
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+
+    // Functions for the VK_QNX_screen_surface extension:
+    if (!strcmp("vkCreateScreenSurfaceQNX", name)) {
+        *addr = ptr_instance->wsi_screen_surface_enabled ? (void *)vkCreateScreenSurfaceQNX : NULL;
+        return true;
+    }
+    if (!strcmp("vkGetPhysicalDeviceScreenPresentationSupportQNX", name)) {
+        *addr = ptr_instance->wsi_screen_surface_enabled ? (void *)vkGetPhysicalDeviceScreenPresentationSupportQNX : NULL;
+        return true;
+    }
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+
     // Functions for VK_KHR_display extension:
     if (!strcmp("vkGetPhysicalDeviceDisplayPropertiesKHR", name)) {
         *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPropertiesKHR : NULL;
diff --git a/loader/wsi.h b/loader/wsi.h
index cad0d45..fbeeb2e 100644
--- a/loader/wsi.h
+++ b/loader/wsi.h
@@ -54,6 +54,9 @@
 #ifdef VK_USE_PLATFORM_METAL_EXT
         VkIcdSurfaceMetal metal_surf;
 #endif // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+        VkIcdSurfaceScreen screen_surf;
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
         VkIcdSurfaceDisplay display_surf;
         VkIcdSurfaceHeadless headless_surf;
     };
@@ -155,6 +158,14 @@
 VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT *pCreateInfo,
                                                                 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
 #endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateScreenSurfaceQNX(VkInstance instance,
+                                                                  const VkScreenSurfaceCreateInfoQNX *pCreateInfo,
+                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
+VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
+                                                                                         uint32_t queueFamilyIndex,
+                                                                                         struct _screen_window *window);
+#endif // VK_USE_PLATFORM_SCREEN_QNX
 VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
                                                                                 uint32_t *pPropertyCount,
                                                                                 VkDisplayPropertiesKHR *pProperties);
diff --git a/scripts/loader_extension_generator.py b/scripts/loader_extension_generator.py
index e8c4ac6..421dc84 100644
--- a/scripts/loader_extension_generator.py
+++ b/scripts/loader_extension_generator.py
@@ -44,7 +44,8 @@
                  'VK_KHR_swapchain',
                  'VK_KHR_display_swapchain',
                  'VK_KHR_get_display_properties2',
-                 'VK_KHR_get_surface_capabilities2']
+                 'VK_KHR_get_surface_capabilities2',
+                 'VK_QNX_screen_surface']
 
 ADD_INST_CMDS = ['vkCreateInstance',
                  'vkEnumerateInstanceExtensionProperties',
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7e6d4fd..fe8d965 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -45,6 +45,10 @@
     if(BUILD_WSI_WAYLAND_SUPPORT)
         add_definitions(-DVK_USE_PLATFORM_WAYLAND_KHR)
     endif()
+
+    if(BUILD_WSI_SCREEN_SUPPORT)
+        add_definitions(-DVK_USE_PLATFORM_SCREEN_QNX)
+    endif()
 else()
     message(FATAL_ERROR "Unsupported Platform!")
 endif()
diff --git a/tests/layers/wrap_objects.cpp b/tests/layers/wrap_objects.cpp
index f25ff27..4317fde 100644
--- a/tests/layers/wrap_objects.cpp
+++ b/tests/layers/wrap_objects.cpp
@@ -1104,6 +1104,25 @@
 }
 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
 
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
+{
+    wrapped_inst_obj *inst;
+    auto vk_inst = unwrap_instance(instance, &inst);
+    VkResult result = inst->layer_disp.CreateScreenSurfaceQNX(vk_inst, pCreateInfo, pAllocator, pSurface);
+    return result;
+}
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window)
+{
+    wrapped_phys_dev_obj *phys_dev;
+    auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev);
+    VkBool32 result = phys_dev->inst->layer_disp.GetPhysicalDeviceScreenPresentationSupportQNX(vk_phys_dev, queueFamilyIndex, window);
+    return result;
+}
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+
 VKAPI_ATTR VkResult VKAPI_CALL
 vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
                              const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {