diff --git a/sycl/CMakeLists.txt b/sycl/CMakeLists.txt
index 3445350325e0a..b2a033ef7c6d2 100644
--- a/sycl/CMakeLists.txt
+++ b/sycl/CMakeLists.txt
@@ -290,13 +290,6 @@ if (WIN32)
   if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
     list(APPEND SYCL_RT_LIBS sycl${SYCL_MAJOR_VERSION}-preview)
   endif()
-  # Do we really support non-MSVC ABI on WIN?
-  if (MSVC)
-    list(APPEND SYCL_RT_LIBS sycl${SYCL_MAJOR_VERSION}d)
-    if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
-      list(APPEND SYCL_RT_LIBS sycl${SYCL_MAJOR_VERSION}-previewd)
-    endif()
-  endif()
 else()
   set(SYCL_RT_LIBS sycl)
   if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
@@ -366,11 +359,7 @@ if(SYCL_ENABLE_XPTI_TRACING AND
 endif()
 
 if (SYCL_ENABLE_XPTI_TRACING)
-  if (MSVC)
-    set(XPTIFW_LIBS xpti xptid xptifw xptifwd)
-  else()
-    set(XPTIFW_LIBS xpti xptifw)
-  endif()
+  set(XPTIFW_LIBS xpti xptifw)
 endif()
 
 # SYCL toolchain builds all components: compiler, libraries, headers, etc.
@@ -408,7 +397,7 @@ add_custom_target( sycl-toolchain ALL
 )
 
 if (WIN32)
-  add_dependencies(sycl-toolchain ur_win_proxy_loader unified-runtimed-build)
+  add_dependencies(sycl-toolchain ur_win_proxy_loader)
 endif()
 
 if("cuda" IN_LIST SYCL_ENABLE_BACKENDS)
diff --git a/sycl/cmake/modules/AddSYCLUnitTest.cmake b/sycl/cmake/modules/AddSYCLUnitTest.cmake
index 677c7358da0f6..001a84aa77853 100644
--- a/sycl/cmake/modules/AddSYCLUnitTest.cmake
+++ b/sycl/cmake/modules/AddSYCLUnitTest.cmake
@@ -10,13 +10,8 @@ macro(add_sycl_unittest test_dirname link_variant)
   get_target_property(SYCL_BINARY_DIR sycl-toolchain BINARY_DIR)
 
   string(TOLOWER "${CMAKE_BUILD_TYPE}" build_type_lower)
-  if (MSVC AND build_type_lower MATCHES "debug")
-    set(sycl_obj_target "sycld_object")
-    set(sycl_so_target "sycld")
-  else()
-    set(sycl_obj_target "sycl_object")
-    set(sycl_so_target "sycl")
-  endif()
+  set(sycl_obj_target "sycl_object")
+  set(sycl_so_target "sycl")
 
   if ("${link_variant}" MATCHES "SHARED")
     set(SYCL_LINK_LIBS ${sycl_so_target})
diff --git a/sycl/cmake/modules/FetchUnifiedRuntime.cmake b/sycl/cmake/modules/FetchUnifiedRuntime.cmake
index e96eec28be350..7de5b9ed0e8ba 100644
--- a/sycl/cmake/modules/FetchUnifiedRuntime.cmake
+++ b/sycl/cmake/modules/FetchUnifiedRuntime.cmake
@@ -317,113 +317,6 @@ if("native_cpu" IN_LIST SYCL_ENABLE_BACKENDS)
   endif()
 endif()
 
-if(CMAKE_SYSTEM_NAME STREQUAL Windows)
-  # On Windows, also build/install debug libraries with the d suffix that are
-  # compiled with /MDd so users can link against these in debug builds.
-  include(ExternalProject)
-  set(URD_BINARY_DIR ${CMAKE_BINARY_DIR}/unified-runtimed)
-  set(URD_INSTALL_DIR ${URD_BINARY_DIR}/install)
-
-  # This creates a subbuild which can be used in dependencies with the
-  # unified-runtimed target. It invokes the install-unified-runtime-libraries
-  # target to install the UR runtime libraries.
-  ExternalProject_Add(unified-runtimed
-    SOURCE_DIR ${UNIFIED_RUNTIME_SOURCE_DIR}
-    BINARY_DIR ${URD_BINARY_DIR}
-    INSTALL_DIR ${URD_INSTALL_DIR}
-    INSTALL_COMMAND ${CMAKE_COMMAND}
-      --build <BINARY_DIR> --config Debug
-      --target install-unified-runtime-libraries
-    CMAKE_CACHE_ARGS
-      -DCMAKE_BUILD_TYPE:STRING=Debug
-      -DCMAKE_INSTALL_PREFIX:STRING=<INSTALL_DIR>
-      # Enable d suffix on libraries
-      -DUR_USE_DEBUG_POSTFIX:BOOL=ON
-      # Don't build unnecessary targets in subbuild.
-      -DUR_BUILD_EXAMPLES:BOOL=OFF
-      -DUR_BUILD_TESTS:BOOL=OFF
-      -DUR_BUILD_TOOLS:BOOL=OFF
-      # Sanitizer layer is not supported on Windows.
-      -DUR_ENABLE_SYMBOLIZER:BOOL=OFF
-      # Inherit settings from parent build.
-      -DUR_ENABLE_TRACING:BOOL=${UR_ENABLE_TRACING}
-      -DUR_ENABLE_COMGR:BOOL=${UR_ENABLE_COMGR}
-      -DUR_BUILD_ADAPTER_L0:BOOL=${UR_BUILD_ADAPTER_L0}
-      -DUR_BUILD_ADAPTER_L0_V2:BOOL=${UR_BUILD_ADAPTER_L0_V2}
-      -DUR_BUILD_ADAPTER_OPENCL:BOOL=${UR_BUILD_ADAPTER_OPENCL}
-      -DUR_BUILD_ADAPTER_CUDA:BOOL=${UR_BUILD_ADAPTER_CUDA}
-      -DUR_BUILD_ADAPTER_HIP:BOOL=${UR_BUILD_ADAPTER_HIP}
-      -DUR_BUILD_ADAPTER_NATIVE_CPU:BOOL=${UR_BUILD_ADAPTER_NATIVE_CPU}
-      -DUMF_BUILD_EXAMPLES:BOOL=${UMF_BUILD_EXAMPLES}
-      -DUMF_BUILD_SHARED_LIBRARY:BOOL=${UMF_BUILD_SHARED_LIBRARY}
-      -DUMF_LINK_HWLOC_STATICALLY:BOOL=${UMF_LINK_HWLOC_STATICALLY}
-      -DUMF_DISABLE_HWLOC:BOOL=${UMF_DISABLE_HWLOC}
-      # Enable d suffix in UMF
-      -DUMF_USE_DEBUG_POSTFIX:BOOL=ON
-  )
-
-  # Copy the debug UR runtime libraries to <build>/bin & <build>/lib for use in
-  # the parent build, e.g. integration testing.
-  set(URD_COPY_FILES)
-  macro(urd_copy_library_to_build library shared)
-    if(${shared})
-      list(APPEND URD_COPY_FILES
-        ${LLVM_BINARY_DIR}/bin/${library}.dll
-      )
-      add_custom_command(
-        OUTPUT
-          ${LLVM_BINARY_DIR}/bin/${library}.dll
-        COMMAND ${CMAKE_COMMAND} -E copy
-          ${URD_INSTALL_DIR}/bin/${library}.dll
-          ${LLVM_BINARY_DIR}/bin/${library}.dll
-      )
-    endif()
-
-    list(APPEND URD_COPY_FILES
-      ${LLVM_BINARY_DIR}/lib/${library}.lib
-    )
-    add_custom_command(
-      OUTPUT
-        ${LLVM_BINARY_DIR}/lib/${library}.lib
-      COMMAND ${CMAKE_COMMAND} -E copy
-        ${URD_INSTALL_DIR}/lib/${library}.lib
-        ${LLVM_BINARY_DIR}/lib/${library}.lib
-    )
-  endmacro()
-
-  urd_copy_library_to_build(ur_loaderd "NOT;${UR_STATIC_LOADER}")
-  foreach(adatper ${SYCL_ENABLE_BACKENDS})
-    if(adapter MATCHES "level_zero")
-      set(shared "NOT;${UR_STATIC_ADAPTER_L0}")
-    else()
-      set(shared TRUE)
-    endif()
-    urd_copy_library_to_build(ur_adapter_${adatper}d "${shared}")
-  endforeach()
-  # Also copy umfd.dll/umfd.lib
-  urd_copy_library_to_build(umfd ${UMF_BUILD_SHARED_LIBRARY})
-
-  add_custom_target(unified-runtimed-build ALL DEPENDS ${URD_COPY_FILES})
-  add_dependencies(unified-runtimed-build unified-runtimed)
-
-  # Add the debug UR runtime libraries to the parent install.
-  install(
-    FILES ${URD_INSTALL_DIR}/bin/ur_loaderd.dll
-    DESTINATION "bin" COMPONENT unified-runtime-loader)
-  foreach(adapter ${SYCL_ENABLE_BACKENDS})
-    install(
-      FILES ${URD_INSTALL_DIR}/bin/ur_adapter_${adapter}d.dll
-      DESTINATION "bin" COMPONENT ur_adapter_${adapter})
-    add_dependencies(install-sycl-ur-adapter-${adapter} unified-runtimed)
-  endforeach()
-  if(UMF_BUILD_SHARED_LIBRARY)
-    # Also install umfd.dll
-    install(
-      FILES ${URD_INSTALL_DIR}/bin/umfd.dll
-      DESTINATION "bin" COMPONENT unified-memory-framework)
-  endif()
-endif()
-
 install(TARGETS umf
   LIBRARY DESTINATION "lib${LLVM_LIBDIR_SUFFIX}" COMPONENT unified-memory-framework
   ARCHIVE DESTINATION "lib${LLVM_LIBDIR_SUFFIX}" COMPONENT unified-memory-framework
diff --git a/sycl/cmake/modules/SYCLUtils.cmake b/sycl/cmake/modules/SYCLUtils.cmake
index f469b26047605..b5bae23b2e539 100644
--- a/sycl/cmake/modules/SYCLUtils.cmake
+++ b/sycl/cmake/modules/SYCLUtils.cmake
@@ -4,17 +4,18 @@ include(CheckLinkerFlag)
 # add_stripped_pdb(TARGET_NAME)
 #
 # Will add option for generating stripped PDB file and install the generated
-# file as ${ARG_TARGET_NAME}.pdb in bin folder.
+# file as ${ARG_TARGET_NAME}{d}.pdb in bin folder.
 # NOTE: LLD does not currently support /PDBSTRIPPED so the PDB file is optional.
 macro(add_stripped_pdb ARG_TARGET_NAME)
-  check_linker_flag(CXX "LINKER:/PDBSTRIPPED:${ARG_TARGET_NAME}.stripped.pdb"
+  set(PDB_FILENAME "${ARG_TARGET_NAME}$<$<CONFIG:Debug>:d>")
+  check_linker_flag(CXX "LINKER:/PDBSTRIPPED:${PDB_FILENAME}.stripped.pdb"
                          LINKER_SUPPORTS_PDBSTRIPPED)
   if(LINKER_SUPPORTS_PDBSTRIPPED)
     target_link_options(${ARG_TARGET_NAME}
-                        PRIVATE "LINKER:/PDBSTRIPPED:${ARG_TARGET_NAME}.stripped.pdb")
-    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${ARG_TARGET_NAME}.stripped.pdb"
+                        PRIVATE "LINKER:/PDBSTRIPPED:${PDB_FILENAME}.stripped.pdb")
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${PDB_FILENAME}.stripped.pdb"
             DESTINATION ${CMAKE_INSTALL_PREFIX}/bin
-            RENAME "${ARG_TARGET_NAME}.pdb"
+            RENAME "${PDB_FILENAME}.pdb"
             COMPONENT ${ARG_TARGET_NAME}
             OPTIONAL)
   endif()
diff --git a/sycl/source/CMakeLists.txt b/sycl/source/CMakeLists.txt
index dac4e71af45af..2b9a8400c2a7d 100644
--- a/sycl/source/CMakeLists.txt
+++ b/sycl/source/CMakeLists.txt
@@ -16,10 +16,10 @@ if (SYCL_ENABLE_XPTI_TRACING)
   include_directories(${LLVM_EXTERNAL_XPTI_SOURCE_DIR}/include)
 endif()
 
-function(add_sycl_rt_library LIB_NAME LIB_OBJ_NAME)
+function(add_sycl_rt_library LIB_TARGET_NAME LIB_OBJ_NAME LIB_OUTPUT_NAME)
   # Add an optional argument so we can get the library name to
   # link with for Windows Debug version
-  cmake_parse_arguments(ARG "" "XPTI_LIB;IMPLIB_NAME" "COMPILE_OPTIONS;SOURCES" ${ARGN})
+  cmake_parse_arguments(ARG "" "XPTI_LIB;IMPLIB_OUTPUT_NAME" "COMPILE_OPTIONS;SOURCES" ${ARGN})
 
   add_library(${LIB_OBJ_NAME} OBJECT ${ARG_SOURCES})
 
@@ -74,13 +74,13 @@ function(add_sycl_rt_library LIB_NAME LIB_OBJ_NAME)
 
   # Common link step setup
 
-  add_library(${LIB_NAME} SHARED
+  add_library(${LIB_TARGET_NAME} SHARED
               $<TARGET_OBJECTS:${LIB_OBJ_NAME}>
               ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
 
   find_package(Threads REQUIRED)
 
-  target_link_libraries(${LIB_NAME}
+  target_link_libraries(${LIB_TARGET_NAME}
     PRIVATE
       ${CMAKE_DL_LIBS}
       ${CMAKE_THREAD_LIBS_INIT}
@@ -95,22 +95,22 @@ function(add_sycl_rt_library LIB_NAME LIB_OBJ_NAME)
   if (SYCL_ENABLE_STACK_PRINTING)
     if(NOT MSVC OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ARG_COMPILE_OPTIONS MATCHES ".*MDd.*") OR
       (NOT CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT ARG_COMPILE_OPTIONS MATCHES ".*MDd.*"))
-        add_dependencies(${LIB_NAME} LLVMSupport)
+        add_dependencies(${LIB_TARGET_NAME} LLVMSupport)
         target_compile_definitions(${LIB_OBJ_NAME} PUBLIC ENABLE_STACK_TRACE)
-        target_link_libraries(${LIB_NAME} PRIVATE LLVMSupport)
+        target_link_libraries(${LIB_TARGET_NAME} PRIVATE LLVMSupport)
     endif()
   endif()
 
   # TODO: Enabled for MSVC
   if (NOT MSVC AND SYCL_LIB_WITH_DEBUG_SYMBOLS)
     separate_arguments(CMAKE_CXX_FLAGS_DEBUG_SEPARATED UNIX_COMMAND "${CMAKE_CXX_FLAGS_DEBUG}")
-    target_compile_options(${LIB_NAME} PRIVATE ${CMAKE_CXX_FLAGS_DEBUG_SEPARATED})
+    target_compile_options(${LIB_TARGET_NAME} PRIVATE ${CMAKE_CXX_FLAGS_DEBUG_SEPARATED})
   endif()
 
   # To facilitate better tracing and profiling except on release builds.
   check_cxx_compiler_flag("-fno-omit-frame-pointer" CXX_HAS_NO_OMIT_FRAME_POINTER)
   if (CXX_HAS_NO_OMIT_FRAME_POINTER)
-    target_compile_options(${LIB_NAME} PUBLIC
+    target_compile_options(${LIB_TARGET_NAME} PUBLIC
       $<$<CONFIG:Debug,RelWithDebInfo>:-fno-omit-frame-pointer>
       )
     target_compile_options(${LIB_OBJ_NAME} PUBLIC
@@ -122,10 +122,10 @@ function(add_sycl_rt_library LIB_NAME LIB_OBJ_NAME)
     target_compile_options(${LIB_OBJ_NAME} PUBLIC
       -fprofile-instr-generate -fcoverage-mapping
     )
-    target_compile_options(${LIB_NAME} PUBLIC
+    target_compile_options(${LIB_TARGET_NAME} PUBLIC
       -fprofile-instr-generate -fcoverage-mapping
     )
-    target_link_options(${LIB_NAME} PUBLIC
+    target_link_options(${LIB_TARGET_NAME} PUBLIC
       -fprofile-instr-generate -fcoverage-mapping
     )
   endif()
@@ -134,61 +134,55 @@ function(add_sycl_rt_library LIB_NAME LIB_OBJ_NAME)
     sycl-headers
   )
 
-  set_target_properties(${LIB_NAME} PROPERTIES LINKER_LANGUAGE CXX)
+  set_target_properties(${LIB_TARGET_NAME} PROPERTIES LINKER_LANGUAGE CXX)
 
   if (SYCL_ENABLE_XPTI_TRACING)
     target_compile_definitions(${LIB_OBJ_NAME} PRIVATE XPTI_ENABLE_INSTRUMENTATION XPTI_STATIC_LIBRARY)
-    target_link_libraries(${LIB_NAME} PRIVATE ${ARG_XPTI_LIB})
+    target_link_libraries(${LIB_TARGET_NAME} PRIVATE ${ARG_XPTI_LIB})
   endif()
 
   if (NOT LLVM_ENABLE_ZSTD)
     target_compile_definitions(${LIB_OBJ_NAME} PRIVATE SYCL_RT_ZSTD_NOT_AVAIABLE)
   else()
-    target_link_libraries(${LIB_NAME} PRIVATE ${zstd_STATIC_LIBRARY})
+    target_link_libraries(${LIB_TARGET_NAME} PRIVATE ${zstd_STATIC_LIBRARY})
     target_include_directories(${LIB_OBJ_NAME} PRIVATE ${zstd_INCLUDE_DIR})
   endif()
 
   # ur_win_proxy_loader
   if (WIN32)
     include_directories(${LLVM_EXTERNAL_SYCL_SOURCE_DIR}/ur_win_proxy_loader)
-    if(WIN_DUPE)
-      target_link_libraries(${LIB_NAME} PUBLIC ur_win_proxy_loaderd)
-      set(MANIFEST_FILE_NAME "sycld.manifest")
-    else()
-      target_link_libraries(${LIB_NAME} PUBLIC ur_win_proxy_loader)
-      set(MANIFEST_FILE_NAME "sycl.manifest")
-    endif()
+    target_link_libraries(${LIB_TARGET_NAME} PUBLIC ur_win_proxy_loader)
+    set(MANIFEST_FILE_NAME "sycl$<$<CONFIG:Debug>:d>.manifest")
     # Embed manifest into the sycl.dll where ur_win_proxy_loader.dll is described as sycl.dll's private dll and will always be loaded from the same directory.
     # 0x2000: LOAD_LIBRARY_SAFE_CURRENT_DIRS flag. Using this flag means that loading dependency DLLs (of sycl.dll)
     # from the current directory is only allowed if it is under a directory in the Safe load list.
-    target_link_options(${LIB_NAME} PRIVATE "LINKER:/DEPENDENTLOADFLAG:0x2000" "LINKER:/MANIFEST:NO" "LINKER:/MANIFEST:EMBED" "LINKER:/MANIFESTINPUT:${CMAKE_CURRENT_SOURCE_DIR}/${MANIFEST_FILE_NAME}")
+    target_link_options(${LIB_TARGET_NAME} PRIVATE "LINKER:/DEPENDENTLOADFLAG:0x2000" "LINKER:/MANIFEST:NO" "LINKER:/MANIFEST:EMBED" "LINKER:/MANIFESTINPUT:${CMAKE_CURRENT_SOURCE_DIR}/${MANIFEST_FILE_NAME}")
   endif()
 
   if (WIN32)
-    if (ARG_IMPLIB_NAME)
-      add_custom_command(
-        TARGET ${LIB_NAME} POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy
-        ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${LIB_NAME}.lib ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${ARG_IMPLIB_NAME}.lib
-        COMMENT "Creating version-agnostic copy of the import library.")
-      install(
-        FILES ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${ARG_IMPLIB_NAME}.lib
-        DESTINATION "lib${LLVM_LIBDIR_SUFFIX}" COMPONENT sycl)
-    endif()
+    add_custom_command(
+      TARGET ${LIB_TARGET_NAME} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E copy
+              ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${LIB_OUTPUT_NAME}.lib
+              ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${ARG_IMPLIB_OUTPUT_NAME}.lib
+      COMMENT "Creating version-agnostic copy of the import library.")
+    install(
+      FILES ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${ARG_IMPLIB_OUTPUT_NAME}.lib
+      DESTINATION "lib${LLVM_LIBDIR_SUFFIX}" COMPONENT sycl)
   endif()
 
   if (MSVC)
     # Install stripped PDB
-    add_stripped_pdb(${LIB_NAME})
+    add_stripped_pdb(${LIB_TARGET_NAME})
   else()
     if (UNIX AND NOT APPLE)
       set(linker_script "${CMAKE_CURRENT_SOURCE_DIR}/ld-version-script.txt")
       target_link_libraries(
-          ${LIB_NAME} PRIVATE "-Wl,--version-script=${linker_script}")
-      set_target_properties(${LIB_NAME} PROPERTIES LINK_DEPENDS ${linker_script})
+          ${LIB_TARGET_NAME} PRIVATE "-Wl,--version-script=${linker_script}")
+      set_target_properties(${LIB_TARGET_NAME} PROPERTIES LINK_DEPENDS ${linker_script})
     endif()
     if (SYCL_ENABLE_XPTI_TRACING)
-      target_link_libraries(${LIB_NAME} PRIVATE ${CMAKE_DL_LIBS})
+      target_link_libraries(${LIB_TARGET_NAME} PRIVATE ${CMAKE_DL_LIBS})
     endif()
   endif()
 
@@ -206,18 +200,18 @@ function(add_sycl_rt_library LIB_NAME LIB_OBJ_NAME)
     set(SYCL_JIT_INCLUDE_DIRS
         ${LLVM_EXTERNAL_SYCL_JIT_SOURCE_DIR}/common/include
         ${LLVM_EXTERNAL_SYCL_JIT_SOURCE_DIR}/jit-compiler/include)
-    add_dependencies(${LIB_NAME} sycl-jit)
+    add_dependencies(${LIB_TARGET_NAME} sycl-jit)
     add_dependencies(${LIB_OBJ_NAME} sycl-jit)
     target_include_directories(${LIB_OBJ_NAME} PRIVATE ${SYCL_JIT_INCLUDE_DIRS})
     set_property(GLOBAL APPEND PROPERTY SYCL_TOOLCHAIN_INSTALL_COMPONENTS
        sycl-jit)
-    target_compile_definitions(${LIB_NAME} PRIVATE SYCL_EXT_JIT_ENABLE)
+    target_compile_definitions(${LIB_TARGET_NAME} PRIVATE SYCL_EXT_JIT_ENABLE)
     target_compile_definitions(${LIB_OBJ_NAME} PRIVATE SYCL_EXT_JIT_ENABLE)
   endif(SYCL_ENABLE_EXTENSION_JIT)
 
-  add_common_options(${LIB_NAME} ${LIB_OBJ_NAME})
+  add_common_options(${LIB_TARGET_NAME} ${LIB_OBJ_NAME})
 
-  set_target_properties(${LIB_NAME} PROPERTIES
+  set_target_properties(${LIB_TARGET_NAME} PROPERTIES
                         VERSION ${SYCL_VERSION_STRING}
                         SOVERSION ${SYCL_MAJOR_VERSION})
 
@@ -232,6 +226,12 @@ function(add_sycl_rt_library LIB_NAME LIB_OBJ_NAME)
       file(REMOVE ${VERSION_FILE})
     endif()
   endif()
+
+  # Ensure that we use the dynamic CRT on Windows, i.e. /MD or /MDd.
+  set_target_properties(${LIB_TARGET_NAME} PROPERTIES
+                        MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
+  set_target_properties(${LIB_OBJ_NAME} PROPERTIES
+                        MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
 endfunction(add_sycl_rt_library)
 
 set(SYCL_COMMON_SOURCES
@@ -333,40 +333,6 @@ set(SYCL_NON_PREVIEW_SOURCES "${SYCL_COMMON_SOURCES}"
 set(SYCL_PREVIEW_SOURCES "${SYCL_COMMON_SOURCES}"
 )
 
-if (MSVC)
-  # MSVC provides two incompatible build variants for its CRT: release and debug
-  # To avoid potential issues in user code we also need to provide two kinds
-  # of SYCL Runtime Library for release and debug configurations.
-  foreach(flag_var
-      CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
-      CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
-    string(REGEX REPLACE "/MDd" "" ${flag_var} "${${flag_var}}")
-    string(REGEX REPLACE "/MTd" "" ${flag_var} "${${flag_var}}")
-    string(REGEX REPLACE "/MD" "" ${flag_var} "${${flag_var}}")
-    string(REGEX REPLACE "/MT" "" ${flag_var} "${${flag_var}}")
-  endforeach()
-
-  set(WIN_DUPE "1")
-  if (SYCL_ENABLE_XPTI_TRACING)
-    add_sycl_rt_library(sycl${SYCL_MAJOR_VERSION}d sycld_object XPTI_LIB xptid COMPILE_OPTIONS "/MDd" SOURCES ${SYCL_NON_PREVIEW_SOURCES} IMPLIB_NAME sycld)
-    if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
-      add_sycl_rt_library(sycl${SYCL_MAJOR_VERSION}-previewd sycl-previewd_object XPTI_LIB xptid COMPILE_OPTIONS "/MDd" "/D__INTEL_PREVIEW_BREAKING_CHANGES" SOURCES ${SYCL_PREVIEW_SOURCES} IMPLIB_NAME sycl-previewd)
-    endif()
-  else()
-    add_sycl_rt_library(sycl${SYCL_MAJOR_VERSION}d sycld_object COMPILE_OPTIONS "/MDd" SOURCES ${SYCL_NON_PREVIEW_SOURCES} IMPLIB_NAME sycld)
-    if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
-      add_sycl_rt_library(sycl${SYCL_MAJOR_VERSION}-previewd sycl-previewd_object COMPILE_OPTIONS "/MDd" "/D__INTEL_PREVIEW_BREAKING_CHANGES" SOURCES ${SYCL_PREVIEW_SOURCES} IMPLIB_NAME sycl-previewd)
-    endif()
-  endif()
-  unset(WIN_DUPE)
-  add_library(sycld ALIAS sycl${SYCL_MAJOR_VERSION}d)
-  if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
-    add_library(sycl-previewd ALIAS sycl${SYCL_MAJOR_VERSION}-previewd)
-  endif()
-
-  set(SYCL_EXTRA_OPTS "/MD")
-endif()
-
 check_cxx_compiler_flag(-fsemantic-interposition HAS_SEMANTIC_INTERPOSITION_FLAG)
 if (HAS_SEMANTIC_INTERPOSITION_FLAG AND NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
   # See https://github.com/llvm/llvm-project/issues/58295.
@@ -375,31 +341,45 @@ endif()
 
 if (WIN32)
 set(LIB_NAME "sycl${SYCL_MAJOR_VERSION}")
+set(LIB_OUTPUT_NAME "${LIB_NAME}$<$<CONFIG:Debug>:d>")
 else()
 set(LIB_NAME "sycl")
+set(LIB_OUTPUT_NAME "${LIB_NAME}")
 endif()
-# Version-agnostic name of the import library, has effect on Windows only.
-set(IMPLIB_NAME "sycl")
+set(LIB_PREVIEW_NAME ${LIB_NAME}-preview)
+set(LIB_PREVIEW_OUTPUT_NAME ${LIB_OUTPUT_NAME}-preview)
 
-if (SYCL_ENABLE_XPTI_TRACING)
-  add_sycl_rt_library(${LIB_NAME} sycl_object XPTI_LIB xpti COMPILE_OPTIONS ${SYCL_EXTRA_OPTS}  SOURCES ${SYCL_NON_PREVIEW_SOURCES} IMPLIB_NAME ${IMPLIB_NAME})
-  if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
-    add_sycl_rt_library(${LIB_NAME}-preview sycl-preview_object XPTI_LIB xpti COMPILE_OPTIONS ${SYCL_EXTRA_OPTS} "-D__INTEL_PREVIEW_BREAKING_CHANGES" SOURCES ${SYCL_PREVIEW_SOURCES} IMPLIB_NAME ${IMPLIB_NAME}-preview)
-  endif()
-else()
-  add_sycl_rt_library(${LIB_NAME} sycl_object COMPILE_OPTIONS ${SYCL_EXTRA_OPTS} SOURCES ${SYCL_NON_PREVIEW_SOURCES} IMPLIB_NAME ${IMPLIB_NAME})
-  if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
-    add_sycl_rt_library(${LIB_NAME}-preview sycl-preview_object COMPILE_OPTIONS ${SYCL_EXTRA_OPTS} "-D__INTEL_PREVIEW_BREAKING_CHANGES" SOURCES ${SYCL_PREVIEW_SOURCES} IMPLIB_NAME ${IMPLIB_NAME}-preview)
-  endif()
+# Version-agnostic name of the import library, has effect on Windows only.
+set(IMPLIB_NAME "sycl$<$<CONFIG:Debug>:d>")
+set(IMPLIB_PREVIEW_NAME "${IMPLIB_NAME}-preview")
+
+add_sycl_rt_library(${LIB_NAME} sycl_object ${LIB_OUTPUT_NAME}
+                    XPTI_LIB xpti
+                    COMPILE_OPTIONS ${SYCL_EXTRA_OPTS}
+                    SOURCES ${SYCL_NON_PREVIEW_SOURCES}
+                    IMPLIB_OUTPUT_NAME ${IMPLIB_NAME})
+if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
+  add_sycl_rt_library(${LIB_PREVIEW_NAME} sycl-preview_object ${LIB_PREVIEW_OUTPUT_NAME}
+                      XPTI_LIB xpti
+                      COMPILE_OPTIONS ${SYCL_EXTRA_OPTS} "-D__INTEL_PREVIEW_BREAKING_CHANGES"
+                      SOURCES ${SYCL_PREVIEW_SOURCES}
+                      IMPLIB_OUTPUT_NAME ${IMPLIB_PREVIEW_NAME})
 endif()
 
-if (WIN32)
+if (CMAKE_SYSTEM_NAME STREQUAL Windows)
   add_library(sycl ALIAS ${LIB_NAME})
   if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB)
     add_library(sycl-preview ALIAS sycl${SYCL_MAJOR_VERSION}-preview)
   endif()
 endif()
 
+if (CMAKE_SYSTEM_NAME STREQUAL Windows)
+  set_target_properties(${LIB_NAME} PROPERTIES DEBUG_POSTFIX d)
+  if(SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB AND (CMAKE_BUILD_TYPE STREQUAL Debug))
+    set_target_properties(sycl${SYCL_MAJOR_VERSION}-preview PROPERTIES OUTPUT_NAME sycl${SYCL_MAJOR_VERSION}d-preview)
+  endif()
+endif()
+
 install(TARGETS ${SYCL_RT_LIBS}
   ARCHIVE DESTINATION "lib${LLVM_LIBDIR_SUFFIX}" COMPONENT sycl
   LIBRARY DESTINATION "lib${LLVM_LIBDIR_SUFFIX}" COMPONENT sycl
diff --git a/sycl/test-e2e/README.md b/sycl/test-e2e/README.md
index ca48be8a961c6..f9f79b89d90e0 100644
--- a/sycl/test-e2e/README.md
+++ b/sycl/test-e2e/README.md
@@ -203,6 +203,9 @@ or via the ***LIT_OPTS*** environment variable.
 compilation command line for GPU device. If not specified "-device *" value is
 used.
 
+***USE_DEBUG_LIBRARIES*** - enable the use of Windows debug libraries by setting
+this to "ON". "OFF" by default.
+
 ## Special test categories
 
 There are two special directories for extended testing. See documentation at:
diff --git a/sycl/test-e2e/Regression/compile_on_win_with_mdd.cpp b/sycl/test-e2e/Regression/compile_on_win_with_mdd.cpp
index 57826c81ece2e..d6506d205fff5 100644
--- a/sycl/test-e2e/Regression/compile_on_win_with_mdd.cpp
+++ b/sycl/test-e2e/Regression/compile_on_win_with_mdd.cpp
@@ -1,4 +1,4 @@
-// REQUIRES: windows
+// REQUIRES: windows && debug_sycl_library && build-mode && run-mode
 
 // RUN: %clangxx --driver-mode=cl -fsycl /MDd -c %s -o %t.obj
 // RUN: %clangxx --driver-mode=cl -fsycl %t.obj -Wno-unused-command-line-argument -o %t.out
@@ -9,6 +9,8 @@
 // The failure happens if perform separate compile and link, and pass /MDd to
 // the compile line. In that case, user application will crash during launching
 // with abort() message.
+// Note that building requires the Windows debug library to be present, so it is
+// only run in full testing mode.
 
 #include <sycl/queue.hpp>
 
diff --git a/sycl/test-e2e/Regression/msvc_crt.cpp b/sycl/test-e2e/Regression/msvc_crt.cpp
index 9d59547e50d7b..1d07c9a26730f 100644
--- a/sycl/test-e2e/Regression/msvc_crt.cpp
+++ b/sycl/test-e2e/Regression/msvc_crt.cpp
@@ -1,7 +1,5 @@
-// RUN: %{build} /MD -o %t1.exe
-// RUN: %{run} %t1.exe
-// RUN: %{build} /MDd -o %t2.exe
-// RUN: %{run} %t2.exe
+// RUN: %{build} %if debug_sycl_library %{ /MDd %} %else %{ /MD %} -o %t.exe
+// RUN: %{run} %t.exe
 // REQUIRES: system-windows, cl_options
 //==-------------- msvc_crt.cpp - SYCL MSVC CRT test -----------------------==//
 //
diff --git a/sycl/test-e2e/lit.cfg.py b/sycl/test-e2e/lit.cfg.py
index 59f8e890fed8e..73285d40e50f3 100644
--- a/sycl/test-e2e/lit.cfg.py
+++ b/sycl/test-e2e/lit.cfg.py
@@ -322,6 +322,12 @@ def open_check_file(file_name):
 if ps.wait() == 0:
     config.available_features.add("has_ndebug")
 
+# Check if the current build mode is debug.
+if config.use_debug_libs:
+    config.available_features.add("debug_sycl_library")
+    # Add /MDd to the build command to make it use the debug library.
+    config.cxx_flags += " /MDd" if cl_options else " -fms-runtime-lib=dll_dbg"
+
 # Check for Level Zero SDK
 check_l0_file = "l0_include.cpp"
 with open_check_file(check_l0_file) as fp:
@@ -558,7 +564,13 @@ def open_check_file(file_name):
         (
             "%sycl_options",
             " "
-            + os.path.normpath(os.path.join(config.sycl_libs_dir + "/../lib/sycl8.lib"))
+            + os.path.normpath(
+                os.path.join(
+                    config.sycl_libs_dir
+                    + "/../lib/"
+                    + ("sycl8d.lib" if config.use_debug_libs else "sycl8.lib")
+                )
+            )
             + " -Xclang -isystem -Xclang "
             + config.sycl_include
             + " -Xclang -isystem -Xclang "
@@ -576,7 +588,11 @@ def open_check_file(file_name):
     config.substitutions.append(
         (
             "%sycl_options",
-            (" -lsycl8" if platform.system() == "Windows" else " -lsycl")
+            (
+                (" -lsycl8d" if config.use_debug_libs else " -lsycl8")
+                if platform.system() == "Windows"
+                else " -lsycl"
+            )
             + " -isystem "
             + config.sycl_include
             + " -isystem "
@@ -747,9 +763,7 @@ def remove_level_zero_suffix(devices):
     xptifw_dispatcher = os.path.join(xptifw_lib_dir, "libxptifw.so")
 elif platform.system() == "Windows":
     # Use debug version of xptifw library if tests are built with \MDd.
-    xptifw_dispatcher_name = (
-        XPTIFW_DEBUG if "/MDd" in config.cxx_flags else XPTIFW_RELEASE
-    )
+    xptifw_dispatcher_name = XPTIFW_DEBUG if config.use_debug_libs else XPTIFW_RELEASE
     xptifw_dispatcher = os.path.join(
         config.dpcpp_root_dir, "bin", xptifw_dispatcher_name + ".dll"
     )
@@ -761,7 +775,7 @@ def remove_level_zero_suffix(devices):
     config.substitutions.append(("%xptifw_dispatcher", xptifw_dispatcher))
     if cl_options:
         # Use debug version of xptifw library if tests are built with \MDd.
-        xptifw_lib_name = XPTIFW_DEBUG if "/MDd" in config.cxx_flags else XPTIFW_RELEASE
+        xptifw_lib_name = XPTIFW_DEBUG if config.use_debug_libs else XPTIFW_RELEASE
         xptifw_lib = os.path.normpath(
             os.path.join(xptifw_lib_dir, xptifw_lib_name + ".lib")
         )
diff --git a/sycl/test-e2e/lit.site.cfg.py.in b/sycl/test-e2e/lit.site.cfg.py.in
index 05e71c47ee8aa..9537712723ad3 100644
--- a/sycl/test-e2e/lit.site.cfg.py.in
+++ b/sycl/test-e2e/lit.site.cfg.py.in
@@ -49,6 +49,8 @@ config.vulkan_include_dir = "@Vulkan_INCLUDE_DIRS@"
 config.vulkan_lib = "@Vulkan_LIBRARY@"
 config.vulkan_found = "@Vulkan_FOUND@"
 
+config.use_debug_libs = ("@USE_DEBUG_LIBRARIES@" == "ON")
+
 config.run_launcher = lit_config.params.get('run_launcher', "@SYCL_E2E_RUN_LAUNCHER@")
 config.allow_unknown_arch = "@SYCL_E2E_LIT_ALLOW_UNKNOWN_ARCH@"
 
diff --git a/sycl/test/abi/sycl_symbols_windows.dump b/sycl/test/abi/sycl_symbols_windows.dump
index 18df177095cde..fa67f0f3cacb6 100644
--- a/sycl/test/abi/sycl_symbols_windows.dump
+++ b/sycl/test/abi/sycl_symbols_windows.dump
@@ -3,7 +3,7 @@
 # DO NOT EDIT IT MANUALLY. Refer to sycl/doc/developer/ABIPolicyGuide.md for more info.
 ################################################################################
 
-# RUN: env LLVM_BIN_PATH=%llvm_build_bin_dir %python %sycl_tools_src_dir/abi_check.py --mode check_symbols --reference %s %llvm_build_bin_dir/sycl8.dll
+# RUN: env LLVM_BIN_PATH=%llvm_build_bin_dir %python %sycl_tools_src_dir/abi_check.py --mode check_symbols --reference %s %if debug_sycl_library %{ %llvm_build_bin_dir/sycl8d.dll %} %else %{ %llvm_build_bin_dir/sycl8.dll %}
 # REQUIRES: windows
 # UNSUPPORTED: libcxx
 
diff --git a/sycl/test/lit.cfg.py b/sycl/test/lit.cfg.py
index 4ebe0b06ff040..f1b97ad4c1556 100644
--- a/sycl/test/lit.cfg.py
+++ b/sycl/test/lit.cfg.py
@@ -69,6 +69,10 @@
 if config.sycl_preview_lib_enabled == "ON":
     config.available_features.add("preview-breaking-changes-supported")
 
+# Check if the current build mode is debug.
+if config.build_mode == "Debug":
+    config.available_features.add("debug_sycl_library")
+
 # Configure LD_LIBRARY_PATH or corresponding os-specific alternatives
 # Add 'libcxx' feature to filter out all SYCL abi tests when SYCL runtime
 # is built with llvm libcxx. This feature is added for Linux only since MSVC
@@ -137,9 +141,12 @@
         sycl_host_only_options += " -isystem %s" % include_dir
 config.substitutions.append(("%fsycl-host-only", sycl_host_only_options))
 
-config.substitutions.append(
-    ("%sycl_lib", " -lsycl8" if platform.system() == "Windows" else "-lsycl")
-)
+if platform.system() == "Windows":
+    config.substitutions.append(
+        ("%sycl_lib", " -lsycl8d" if config.build_mode == "Debug" else " -lsycl8")
+    )
+else:
+    config.substitutions.append(("%sycl_lib", "-lsycl"))
 
 llvm_config.add_tool_substitutions(["llvm-spirv"], [config.sycl_tools_dir])
 
@@ -198,10 +205,13 @@
 if not dump_only_tests:
     llvm_config.use_clang(additional_flags=additional_flags)
 
-# Set timeout for test = 10 mins
+# Set timeout for test = 10 mins (Release) or 20 mins (Debug)
 try:
     import psutil
 
-    lit_config.maxIndividualTestTime = 600
+    if config.build_mode != "Debug":
+        lit_config.maxIndividualTestTime = 600
+    else:
+        lit_config.maxIndividualTestTime = 1200
 except ImportError:
     pass
diff --git a/sycl/test/lit.site.cfg.py.in b/sycl/test/lit.site.cfg.py.in
index cc9043f71bf3e..3da06e7ed9134 100644
--- a/sycl/test/lit.site.cfg.py.in
+++ b/sycl/test/lit.site.cfg.py.in
@@ -36,6 +36,8 @@ config.native_cpu = '@SYCL_BUILD_BACKEND_NATIVE_CPU@'
 config.native_cpu_ock = '@NATIVECPU_USE_OCK@'
 config.sycl_preview_lib_enabled = '@SYCL_ENABLE_MAJOR_RELEASE_PREVIEW_LIB@'
 
+config.build_mode = "@CMAKE_BUILD_TYPE@"
+
 import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
diff --git a/sycl/test/regression/std_array_vec_constructor.cpp b/sycl/test/regression/std_array_vec_constructor.cpp
index 9b84e552767f9..92a3207e0b9f6 100644
--- a/sycl/test/regression/std_array_vec_constructor.cpp
+++ b/sycl/test/regression/std_array_vec_constructor.cpp
@@ -1,6 +1,6 @@
 // Test to isolate sycl::vec bug due to use of std::array in
 // the constructor.
-// REQUIRES: windows
+// REQUIRES: windows && debug_sycl_library
 
 // RUN: %clangxx -O0 -fsycl -D_DEBUG -shared %s -nostdlib -Xclang --dependent-lib=msvcrtd -fms-runtime-lib=dll_dbg
 
diff --git a/sycl/test/win_ucrt/lit.local.cfg b/sycl/test/win_ucrt/lit.local.cfg
new file mode 100644
index 0000000000000..38b99a9a37f14
--- /dev/null
+++ b/sycl/test/win_ucrt/lit.local.cfg
@@ -0,0 +1 @@
+config.suffixes = [".py"]
diff --git a/sycl/test/win_ucrt/ucrt_check.py b/sycl/test/win_ucrt/ucrt_check.py
new file mode 100644
index 0000000000000..4e51c2702737a
--- /dev/null
+++ b/sycl/test/win_ucrt/ucrt_check.py
@@ -0,0 +1,59 @@
+# REQUIRES: windows
+# RUN: %python %s %llvm_build_bin_dir
+#
+# Check for Windows URCT dependencies in library files in a specified path. If a
+# library uses a the debug URCT it must be postfixed with either "d" or
+# "d-preview".
+#
+import argparse
+import os
+import subprocess
+import sys
+
+
+# Some libraries are excluded from the check:
+#  * OpenCL.dll: The OpenCL ICD loader is ignored as it is generally not part of
+#                the compiler release packages.
+exclude_list = {"OpenCL.dll"}
+
+
+def check_file(filepath):
+    filename, file_ext = os.path.splitext(entry.name)
+
+    # Only consider .dll or .lib files.
+    if not (file_ext == ".dll" or file_ext == ".lib"):
+        return 0
+
+    has_debug_postfix = filename.endswith("d") or filename.endswith("d-preview")
+    dep_output = subprocess.run(
+        ["dumpbin", "/dependents", filepath], shell=False, capture_output=True
+    )
+
+    if str(dep_output.stdout).find("ucrtbased.dll") != -1:
+        if not has_debug_postfix:
+            print("Unexpected use of ucrtbased.dll:", filepath)
+            return 1
+    elif str(dep_output.stdout).find("ucrtbase.dll") != -1:
+        if has_debug_postfix:
+            print("Unexpected use of ucrtbase.dll:", filepath)
+            return 1
+    elif str(dep_output.stdout).find("api-ms-win-crt-") != -1:
+        if has_debug_postfix:
+            print("Unexpected use of api-ms-win-crt-*.dll: ", filepath)
+            return 1
+    return 0
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Windows UCRT checker utility.")
+    parser.add_argument("target_path", type=str)
+    args = parser.parse_args()
+
+    # Scan the path for library files.
+    failures = 0
+    with os.scandir(args.target_path) as it:
+        for entry in it:
+            if entry.is_file():
+                failures += check_file(entry.name)
+    if failures > 0:
+        exit(failures)
diff --git a/sycl/tools/sycl-ls/CMakeLists.txt b/sycl/tools/sycl-ls/CMakeLists.txt
index 9bb17dee4145b..e7360a28046c9 100644
--- a/sycl/tools/sycl-ls/CMakeLists.txt
+++ b/sycl/tools/sycl-ls/CMakeLists.txt
@@ -2,18 +2,12 @@ add_executable(sycl-ls sycl-ls.cpp)
 add_dependencies(sycl-ls sycl)
 target_include_directories(sycl-ls PRIVATE "${sycl_inc_dir}")
 
-set(sycl_lib sycl)
-string(TOLOWER "${CMAKE_BUILD_TYPE}" build_type_lower)
-if (WIN32 AND "${build_type_lower}" MATCHES "debug")
-  set(sycl_lib sycld)
-endif()
-
-# Disable aspect::image & deprecation warnings.
+# Disable aspect::image warning.
 target_compile_definitions(sycl-ls PRIVATE SYCL_DISABLE_IMAGE_ASPECT_WARNING SYCL2020_DISABLE_DEPRECATION_WARNINGS)
 
 target_link_libraries(sycl-ls
   PRIVATE
-    ${sycl_lib}
+    sycl
     OpenCL-Headers
     UnifiedRuntime-Headers
 )
diff --git a/sycl/ur_win_proxy_loader/CMakeLists.txt b/sycl/ur_win_proxy_loader/CMakeLists.txt
index 940fcd28299e7..65421deffc4d4 100644
--- a/sycl/ur_win_proxy_loader/CMakeLists.txt
+++ b/sycl/ur_win_proxy_loader/CMakeLists.txt
@@ -12,58 +12,20 @@ set_property(SOURCE ${CMAKE_CURRENT_BINARY_DIR}/versioninfo.rc
                "RC_COPYRIGHT=\"Copyright (C) 2023 Intel Corporation\"")
 configure_file(../../llvm/resources/windows_version_resource.rc ${CMAKE_CURRENT_BINARY_DIR}/versioninfo.rc @ONLY)
 add_library(ur_win_proxy_loader SHARED  ur_win_proxy_loader.cpp  ${CMAKE_CURRENT_BINARY_DIR}/versioninfo.rc)
+if (CMAKE_SYSTEM_NAME STREQUAL Windows)
+  set_target_properties(ur_win_proxy_loader PROPERTIES DEBUG_POSTFIX d)
+  if(CMAKE_BUILD_TYPE STREQUAL Debug)
+    target_compile_definitions(ur_win_proxy_loader PRIVATE UR_WIN_PROXY_LOADER_DEBUG_POSTFIX)
+  endif()
+endif()
 add_dependencies(ur_win_proxy_loader UnifiedRuntimeLoader)
 install(TARGETS ur_win_proxy_loader
   RUNTIME DESTINATION "bin" COMPONENT ur_win_proxy_loader
 )
 
 if (MSVC)
-  # MSVC provides two incompatible build variants for its CRT: release and debug
-  # To avoid potential issues in user code we also need to provide two kinds
-  # of SYCL Runtime Library for release and debug configurations.
-  set(WINUNLOAD_CXX_FLAGS "")
-  if (CMAKE_BUILD_TYPE MATCHES "Debug")
-    set(WINUNLOAD_CXX_FLAGS "${CMAKE_CXX_FLAGS_DEBUG}")
-    string(REPLACE "/MDd" "" WINUNLOAD_CXX_FLAGS "${WINUNLOAD_CXX_FLAGS}")
-    string(REPLACE "/MTd" "" WINUNLOAD_CXX_FLAGS "${WINUNLOAD_CXX_FLAGS}")
-  else()
-    if (CMAKE_BUILD_TYPE MATCHES "Release")
-      set(WINUNLOAD_CXX_FLAGS "${CMAKE_CXX_FLAGS_RELEASE}")
-    elseif (CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo")
-      set(WINUNLOAD_CXX_FLAGS "${CMAKE_CXX_FLAGS_MINSIZEREL}")
-    elseif (CMAKE_BUILD_TYPE MATCHES "MinSizeRel")
-      set(WINUNLOAD_CXX_FLAGS "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
-    endif()
-    string(REPLACE "/MD" "" WINUNLOAD_CXX_FLAGS "${WINUNLOAD_CXX_FLAGS}")
-    string(REPLACE "/MT" "" WINUNLOAD_CXX_FLAGS "${WINUNLOAD_CXX_FLAGS}")
-  endif()
-
-  # target_compile_options requires list of options, not a string
-  string(REPLACE " " ";" WINUNLOAD_CXX_FLAGS "${WINUNLOAD_CXX_FLAGS}")
-
-  set(WINUNLOAD_CXX_FLAGS_RELEASE "${WINUNLOAD_CXX_FLAGS};/MD")
-  set(WINUNLOAD_CXX_FLAGS_DEBUG "${WINUNLOAD_CXX_FLAGS};/MDd")
-
-  # CMake automatically applies these flags to all targets. To override this
-  # behavior, options lists are reset.
-  set(CMAKE_CXX_FLAGS_RELEASE "")
-  set(CMAKE_CXX_FLAGS_MINSIZEREL "")
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "")
-  set(CMAKE_CXX_FLAGS_DEBUG "")
-
-  # Handle the debug version for the Microsoft compiler as a special case by
-  # creating a debug version of the static library that uses the flags used by
-  # the SYCL runtime
-  add_library(ur_win_proxy_loaderd SHARED ur_win_proxy_loader.cpp ${CMAKE_CURRENT_BINARY_DIR}/versioninfo.rc)
-  target_compile_options(ur_win_proxy_loaderd PRIVATE ${WINUNLOAD_CXX_FLAGS_DEBUG})
-  target_compile_options(ur_win_proxy_loader PRIVATE ${WINUNLOAD_CXX_FLAGS_RELEASE})
-  target_compile_definitions(ur_win_proxy_loaderd PRIVATE UR_WIN_PROXY_LOADER_DEBUG)
-  target_link_libraries(ur_win_proxy_loaderd PRIVATE shlwapi)
   target_link_libraries(ur_win_proxy_loader PRIVATE shlwapi)
   # 0x2000: LOAD_LIBRARY_SAFE_CURRENT_DIRS flag. Using this flag means that loading dependency DLLs
   # from the current directory is only allowed if it is under a directory in the Safe load list.
-  target_link_options(ur_win_proxy_loaderd PRIVATE LINKER:/DEPENDENTLOADFLAG:0x2000)
   target_link_options(ur_win_proxy_loader PRIVATE LINKER:/DEPENDENTLOADFLAG:0x2000)
-  install(TARGETS ur_win_proxy_loaderd
-    RUNTIME DESTINATION "bin" COMPONENT ur_win_proxy_loader)
 endif()
diff --git a/unified-runtime/CMakeLists.txt b/unified-runtime/CMakeLists.txt
index 75ec8cf02643f..a1d8b0de74aac 100644
--- a/unified-runtime/CMakeLists.txt
+++ b/unified-runtime/CMakeLists.txt
@@ -66,7 +66,6 @@ set(UR_CONFORMANCE_TARGET_TRIPLES "" CACHE STRING
     "List of sycl targets to build CTS device binaries for")
 set(UR_CONFORMANCE_AMD_ARCH "" CACHE STRING "AMD device target ID to build CTS binaries for")
 set(UR_CONFORMANCE_SELECTOR "" CACHE STRING "If nonempty, the device selector for conformance tests")
-option(UR_USE_DEBUG_POSTFIX "Enable debug postfix 'd' for libraries" OFF)
 set(UR_ADAPTER_LEVEL_ZERO_SOURCE_DIR "" CACHE PATH
     "Path to external 'level_zero' adapter source dir")
 set(UR_ADAPTER_OPENCL_SOURCE_DIR "" CACHE PATH
@@ -223,11 +222,7 @@ if(UR_ENABLE_TRACING)
         endif()
     endif()
 
-    if (MSVC)
-        set(TARGET_XPTI $<IF:$<CONFIG:Release>,xpti,xptid>)
-    else()
-        set(TARGET_XPTI xpti)
-    endif()
+    set(TARGET_XPTI xpti)
 endif()
 
 if(UR_ENABLE_SANITIZER)
diff --git a/unified-runtime/cmake/helpers.cmake b/unified-runtime/cmake/helpers.cmake
index b607f1b3112bd..1af00c658e9e0 100644
--- a/unified-runtime/cmake/helpers.cmake
+++ b/unified-runtime/cmake/helpers.cmake
@@ -197,7 +197,7 @@ function(add_ur_library name)
             $<$<STREQUAL:$<TARGET_LINKER_FILE_NAME:${name}>,link.exe>:LINKER:/DEPENDENTLOADFLAG:0x2000>
         )
     endif()
-    if(UR_USE_DEBUG_POSTFIX)
+    if(CMAKE_SYSTEM_NAME STREQUAL Windows)
         set_target_properties(${name} PROPERTIES DEBUG_POSTFIX d)
     endif()
     if(UR_EXTERNAL_DEPENDENCIES)
diff --git a/unified-runtime/source/adapters/CMakeLists.txt b/unified-runtime/source/adapters/CMakeLists.txt
index 56e053d29bc3e..3270c74f7707c 100644
--- a/unified-runtime/source/adapters/CMakeLists.txt
+++ b/unified-runtime/source/adapters/CMakeLists.txt
@@ -6,7 +6,11 @@
 function(add_ur_adapter name)
     add_ur_library(${name} ${ARGN})
     if(MSVC)
-        set(TARGET_LIBNAME ${name})
+        if(CMAKE_BUILD_TYPE STREQUAL Debug)
+            set(TARGET_LIBNAME ${name}d)
+        else()
+            set(TARGET_LIBNAME ${name})
+        endif()
         string(TOUPPER ${TARGET_LIBNAME} TARGET_LIBNAME)
 
         set(ADAPTER_VERSION_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/${name}.def)
@@ -26,6 +30,9 @@ function(add_ur_adapter name)
         configure_file(${CMAKE_CURRENT_SOURCE_DIR}/../adapter.map.in ${ADAPTER_VERSION_SCRIPT} @ONLY)
         target_link_options(${name} PRIVATE "-Wl,--version-script=${ADAPTER_VERSION_SCRIPT}")
     endif()
+    if(WIN32)
+        set_target_properties(${name} PROPERTIES DEBUG_POSTFIX d)
+    endif()
     add_dependencies(ur_loader ${name})
 endfunction()
 
diff --git a/unified-runtime/source/common/CMakeLists.txt b/unified-runtime/source/common/CMakeLists.txt
index 1d14d3e3cecbb..f8c809e33c13b 100644
--- a/unified-runtime/source/common/CMakeLists.txt
+++ b/unified-runtime/source/common/CMakeLists.txt
@@ -73,6 +73,12 @@ else()
   set(UMF_BUILD_EXAMPLES OFF CACHE INTERNAL "Build UMF examples")
   set(UMF_BUILD_SHARED_LIBRARY ${UMF_BUILD_SHARED_LIBRARY} CACHE INTERNAL "Build UMF shared library")
 
+  if (CMAKE_SYSTEM_NAME STREQUAL Windows)
+    if(CMAKE_BUILD_TYPE STREQUAL Debug)
+      set(UMF_USE_DEBUG_POSTFIX ON)
+    endif()
+  endif()
+
   FetchContent_MakeAvailable(unified-memory-framework)
   FetchContent_GetProperties(unified-memory-framework)
 endif()
@@ -127,3 +133,7 @@ target_link_libraries(ur_umf INTERFACE
     umf::umf
     umf::headers
 )
+
+if (CMAKE_SYSTEM_NAME STREQUAL Windows)
+    set_target_properties(ur_umf PROPERTIES DEBUG_POSTFIX d)
+endif()
diff --git a/unified-runtime/source/loader/CMakeLists.txt b/unified-runtime/source/loader/CMakeLists.txt
index e58514bfb38d4..4be0519433f4b 100644
--- a/unified-runtime/source/loader/CMakeLists.txt
+++ b/unified-runtime/source/loader/CMakeLists.txt
@@ -21,12 +21,18 @@ add_ur_library(ur_loader
 )
 install_ur_library(ur_loader)
 
-target_compile_definitions(ur_loader PRIVATE
-    UR_USE_DEBUG_POSTFIX=$<BOOL:${UR_USE_DEBUG_POSTFIX}>
-)
+if (CMAKE_SYSTEM_NAME STREQUAL Windows)
+    if(CMAKE_BUILD_TYPE STREQUAL Debug)
+        target_compile_definitions(ur_loader PRIVATE UR_USE_DEBUG_POSTFIX=1)
+    endif()
+endif()
 
 if (MSVC)
-    set(TARGET_LIBNAME ur_loader)
+    if(CMAKE_BUILD_TYPE STREQUAL Debug)
+        set(TARGET_LIBNAME ur_loaderd)
+    else()
+        set(TARGET_LIBNAME ur_loader)
+    endif()
     string(TOUPPER ${TARGET_LIBNAME} TARGET_LIBNAME)
 
     set(LOADER_VERSION_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/ur_loader.def)
diff --git a/unified-runtime/source/mock/CMakeLists.txt b/unified-runtime/source/mock/CMakeLists.txt
index f3933fbef1453..affb350dadbdb 100644
--- a/unified-runtime/source/mock/CMakeLists.txt
+++ b/unified-runtime/source/mock/CMakeLists.txt
@@ -6,6 +6,10 @@
 add_library (ur_mock_headers SHARED
     "${CMAKE_CURRENT_SOURCE_DIR}/ur_mock_helpers.cpp")
 
+if(CMAKE_SYSTEM_NAME STREQUAL Windows)
+    set_target_properties(ur_mock_headers PROPERTIES DEBUG_POSTFIX d)
+endif()
+
 target_include_directories(ur_mock_headers
     INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}"
 )
diff --git a/xpti/CMakeLists.txt b/xpti/CMakeLists.txt
index 6433e39c94c70..53ae5d38668cb 100644
--- a/xpti/CMakeLists.txt
+++ b/xpti/CMakeLists.txt
@@ -22,41 +22,6 @@ if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type (default Release)" FORCE)
 endif()
 
-if (MSVC)
-  # MSVC provides two incompatible build variants for its CRT: release and debug
-  # To avoid potential issues in user code we also need to provide two kinds
-  # of SYCL Runtime Library for release and debug configurations.
-  set(XPTI_CXX_FLAGS "")
-  if (CMAKE_BUILD_TYPE MATCHES "Debug")
-    set(XPTI_CXX_FLAGS "${CMAKE_CXX_FLAGS_DEBUG}")
-    string(REPLACE "/MDd" "" XPTI_CXX_FLAGS "${XPTI_CXX_FLAGS}")
-    string(REPLACE "/MTd" "" XPTI_CXX_FLAGS "${XPTI_CXX_FLAGS}")
-  else()
-    if (CMAKE_BUILD_TYPE MATCHES "Release")
-      set(XPTI_CXX_FLAGS "${CMAKE_CXX_FLAGS_RELEASE}")
-    elseif (CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo")
-      set(XPTI_CXX_FLAGS "${CMAKE_CXX_FLAGS_MINSIZEREL}")
-    elseif (CMAKE_BUILD_TYPE MATCHES "MinSizeRel")
-      set(XPTI_CXX_FLAGS "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
-    endif()
-    string(REPLACE "/MD" "" XPTI_CXX_FLAGS "${XPTI_CXX_FLAGS}")
-    string(REPLACE "/MT" "" XPTI_CXX_FLAGS "${XPTI_CXX_FLAGS}")
-  endif()
-
-  # target_compile_options requires list of options, not a string
-  string(REPLACE " " ";" XPTI_CXX_FLAGS "${XPTI_CXX_FLAGS}")
-
-  set(XPTI_CXX_FLAGS_RELEASE "${XPTI_CXX_FLAGS};/MD")
-  set(XPTI_CXX_FLAGS_DEBUG "${XPTI_CXX_FLAGS};/MDd")
-
-  # CMake automatically applies these flags to all targets. To override this
-  # behavior, options lists are reset.
-  set(CMAKE_CXX_FLAGS_RELEASE "")
-  set(CMAKE_CXX_FLAGS_MINSIZEREL "")
-  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "")
-  set(CMAKE_CXX_FLAGS_DEBUG "")
-endif()
-
 if (SYCL_USE_LIBCXX)
   if ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR
     (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
@@ -91,9 +56,6 @@ if (LLVM_BINARY_DIR)
     COMMENT "Copying XPTI headers ..."
   )
   add_dependencies(xpti xpti-headers)
-  if (MSVC)
-    add_dependencies(xptid xpti-headers)
-  endif()
 endif()
 
 include(GNUInstallDirs)
diff --git a/xpti/src/CMakeLists.txt b/xpti/src/CMakeLists.txt
index 1d7e371e98a17..d94ddad5f0125 100644
--- a/xpti/src/CMakeLists.txt
+++ b/xpti/src/CMakeLists.txt
@@ -22,13 +22,3 @@ set(SOURCES
 )
 
 add_xpti_lib(xpti ${SOURCES})
-
-# Handle the debug version for the Microsoft compiler as a special case by
-# creating a debug version of the static library that uses the flags used by
-# the SYCL runtime
-if (MSVC)
-  add_xpti_lib(xptid STATIC ${SOURCES})
-  target_compile_options(xptid PRIVATE ${XPTI_CXX_FLAGS_DEBUG})
-  target_compile_options(xpti PRIVATE ${XPTI_CXX_FLAGS_RELEASE})
-endif()
-
diff --git a/xptifw/CMakeLists.txt b/xptifw/CMakeLists.txt
index 99c7e84c43a56..35763a566f459 100644
--- a/xptifw/CMakeLists.txt
+++ b/xptifw/CMakeLists.txt
@@ -61,10 +61,6 @@ set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR})
 add_subdirectory(src)
 
 set(xptifw_lib xptifw)
-string(TOLOWER "${CMAKE_BUILD_TYPE}" build_type_lower)
-if (WIN32 AND "${build_type_lower}" MATCHES "debug")
-  set(xptifw_lib xptifwd)
-endif()
 
 add_custom_target(check-xptifw)
 
diff --git a/xptifw/src/CMakeLists.txt b/xptifw/src/CMakeLists.txt
index 2811b73baf833..d8116506e2617 100644
--- a/xptifw/src/CMakeLists.txt
+++ b/xptifw/src/CMakeLists.txt
@@ -31,13 +31,8 @@ function(add_xpti_library LIB_NAME)
   remove_definitions(-DXPTI_STATIC_LIBRARY)
   add_library(${LIB_NAME} SHARED ${SOURCES})
 
-  if (${LIB_NAME} MATCHES "xptifwd")
-    set_property(TARGET ${LIB_NAME} PROPERTY
-      MSVC_RUNTIME_LIBRARY "MultiThreadedDebugDLL")
-  else()
-    set_property(TARGET ${LIB_NAME} PROPERTY
-      MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")
-  endif()
+  set_target_properties(${LIB_NAME} PROPERTIES
+                        MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
 
   target_compile_definitions(${LIB_NAME} PRIVATE -DXPTI_API_EXPORTS)
   target_include_directories(${LIB_NAME} PUBLIC
@@ -60,6 +55,10 @@ function(add_xpti_library LIB_NAME)
       target_link_libraries(${LIB_NAME} PRIVATE "-L${SYCL_LIBCXX_LIBRARY_PATH}" -Wl,-rpath,${SYCL_LIBCXX_LIBRARY_PATH} -nodefaultlibs -lc++ -lc++abi -lm -lc -lgcc_s -lgcc)
   endif()
 
+  if (CMAKE_SYSTEM_NAME STREQUAL Windows)
+      set_target_properties(${LIB_NAME} PROPERTIES DEBUG_POSTFIX d)
+  endif()
+
   # Set the location of the library installation
   include(GNUInstallDirs)
   install(TARGETS ${LIB_NAME}
@@ -69,10 +68,4 @@ function(add_xpti_library LIB_NAME)
   )
 endfunction(add_xpti_library)
 
-# MSVC provides two incompatible build variants for its CRT: release and debug
-# To avoid potential issues in user code we also need to provide two kinds
-# of XPTIFW for release and debug configurations.
 add_xpti_library(xptifw)
-if (MSVC)
-  add_xpti_library(xptifwd)
-endif()