diff --git a/.github/workflows/conda-package.yml b/.github/workflows/conda-package.yml
index e715c444c0..dd9389c40d 100644
--- a/.github/workflows/conda-package.yml
+++ b/.github/workflows/conda-package.yml
@@ -102,6 +102,8 @@ jobs:
         run: |
           echo "WHEELS_OUTPUT_FOLDER=$GITHUB_WORKSPACE${{ runner.os == 'Linux' && '/' || '\\' }}" >> $GITHUB_ENV
       - name: Build conda package
+        env:
+          OVERRIDE_INTEL_IPO: 1   # IPO requires more resources that GH actions VM provides
         run: conda build --no-test --python ${{ matrix.python }} -c intel -c conda-forge --override-channels conda-recipe
       - name: Upload artifact
         uses: actions/upload-artifact@v3
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f506f1e2fe..eb53db12ec 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,7 +18,7 @@ option(DPCTL_GENERATE_COVERAGE
     OFF
 )
 
-find_package(IntelDPCPP REQUIRED PATHS ${CMAKE_SOURCE_DIR}/cmake NO_DEFAULT_PATH)
+find_package(IntelSYCL REQUIRED PATHS ${CMAKE_SOURCE_DIR}/cmake NO_DEFAULT_PATH)
 
 add_subdirectory(libsyclinterface)
 
diff --git a/cmake/IntelDPCPPConfig.cmake b/cmake/IntelSYCLConfig.cmake
old mode 100644
new mode 100755
similarity index 64%
rename from cmake/IntelDPCPPConfig.cmake
rename to cmake/IntelSYCLConfig.cmake
index 37d79a3ec1..c51e47290c
--- a/cmake/IntelDPCPPConfig.cmake
+++ b/cmake/IntelSYCLConfig.cmake
@@ -1,5 +1,5 @@
 #
-# Modifications, Copyright (C) 2021 Intel Corporation
+# Modifications, Copyright (C) 2022 Intel Corporation
 #
 # This software and the related documents are Intel copyrighted materials, and
 # your use of them is governed by the express license under which they were
@@ -15,10 +15,10 @@
 # file Copyright.txt or https://cmake.org/licensing for details.
 
 #[=======================================================================[.rst:
-IntelDPCPPConfig
+IntelSYCLConfig
 -------
 
-DPCPP Library to verify DPCPP/SYCL compatability of CMAKE_CXX_COMPILER
+Library to verify SYCL compatability of CMAKE_CXX_COMPILER
 and passes relevant compiler flags.
 
 Result Variables
@@ -26,8 +26,8 @@ Result Variables
 
 This will define the following variables:
 
-``IntelDPCPP_FOUND``
-  True if the system has the DPCPP library.
+``IntelSYCL_FOUND``
+  True if the system has the SYCL library.
 ``SYCL_LANGUAGE_VERSION``
   The SYCL language spec version by Compiler.
 ``SYCL_INCLUDE_DIR``
@@ -37,35 +37,39 @@ This will define the following variables:
 ``SYCL_FLAGS``
   SYCL specific flags for the compiler.
 
+``IntelSYCL::SYCL_CXX``
+  Target for using Intel SYCL (DPC++).  The following properties are defined
+  for the target: ``INTERFACE_COMPILE_OPTIONS``, ``INTERFACE_LINK_OPTIONS``,
+  ``INTERFACE_INCLUDE_DIRECTORIES``, and ``INTERFACE_LINK_DIRECTORIES``
+
 Cache Variables
 ^^^^^^^^^^^^^^^
 
-The following cache variables may also be set:
+The following cache variable may also be set:
 
-``SYCL_INCLUDE_DIR``
-  The directory containing ``sycl.hpp``.
-``SYCL_LIBRARY_DIR``
-  The path to the SYCL library.
-``SYCL_FLAGS``
-  SYCL specific flags for the compiler.
 ``SYCL_LANGUAGE_VERSION``
   The SYCL language spec version by Compiler.
 
 
-.. note::
+.. Note::
 
-  For now, user needs to set -DCMAKE_CXX_COMPILER or environment of
+  1. User needs to set -DCMAKE_CXX_COMPILER or environment of
   CXX pointing to SYCL compatible compiler  ( eg: icx, clang++, icpx)
 
-  Note: do not set to DPCPP compiler. If set to a Compiler family
-  that supports dpcpp ( eg: IntelLLVM) both DPCPP and SYCL
-  features are enabled.
 
-  And add this package to user's Cmake config file.
+  2. Add this package to user's Cmake config file.
+
+  .. code-block:: cmake
+
+    find_package(IntelSYCL REQUIRED)
+
+  3. Add sources to target through add_sycl_to_target()
 
   .. code-block:: cmake
 
-    find_package(IntelDPCPP REQUIRED)
+     # Compile specific sources for SYCL and build target for SYCL
+     add_executable(target_proj A.cpp B.cpp offload1.cpp offload2.cpp)
+     add_sycl_to_target(TARGET target_proj SOURCES offload1.cpp offload2.cpp)
 
 #]=======================================================================]
 
@@ -83,25 +87,33 @@ endif()
 
 string(COMPARE EQUAL "${CMAKE_CXX_COMPILER}" "" nocmplr)
 if(nocmplr)
-  set(IntelDPCPP_FOUND False)
+  set(IntelSYCL_FOUND False)
   set(SYCL_REASON_FAILURE "SYCL: CMAKE_CXX_COMPILER not set!!")
-  set(IntelDPCPP_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
+  set(IntelSYCL_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
+endif()
+
+# Check if a Compiler ID is being set. project() should be set prior to find_package()
+
+if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "x")
+   set(IntelSYCL_FOUND False)
+   set(SYCL_REASON_FAILURE "CMake CXX Compiler family is not set. Please make sure find_package(IntelSYCL) is called after project()!!")
+   set(IntelSYCL_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
+   return()
 endif()
 
 # Check for known compiler family that supports SYCL
 
 if( NOT "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang" AND
     NOT "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntelLLVM")
-   set(IntelDPCPP_FOUND False)
+   set(IntelSYCL_FOUND False)
    set(SYCL_REASON_FAILURE "Unsupported compiler family ${CMAKE_CXX_COMPILER_ID} and compiler ${CMAKE_CXX_COMPILER}!!")
-   set(IntelDPCPP_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
+   set(IntelSYCL_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
    return()
 endif()
 
 # Assume that CXX Compiler supports SYCL and then test to verify.
 set(SYCL_COMPILER ${CMAKE_CXX_COMPILER})
 
-
 # Function to write a test case to verify SYCL features.
 
 function(SYCL_FEATURE_TEST_WRITE src)
@@ -144,7 +156,7 @@ function(SYCL_FEATURE_TEST_BUILD TEST_SRC_FILE TEST_EXE)
     OUTPUT_VARIABLE output ERROR_VARIABLE output
     OUTPUT_FILE ${SYCL_TEST_DIR}/Compile.log
     RESULT_VARIABLE result
-    TIMEOUT 20
+    TIMEOUT 60
     )
 
   # Verify if test case build properly.
@@ -168,12 +180,12 @@ function(SYCL_FEATURE_TEST_RUN TEST_EXE)
     WORKING_DIRECTORY ${SYCL_TEST_DIR}
     OUTPUT_VARIABLE output ERROR_VARIABLE output
     RESULT_VARIABLE result
-    TIMEOUT 20
+    TIMEOUT 60
     )
 
   # Verify the test execution output.
   if(test_result)
-    set(IntelDPCPP_FOUND False)
+    set(IntelSYCL_FOUND False)
     set(SYCL_REASON_FAILURE "SYCL: feature test execution failed!!")
   endif()
   # TODO: what iff the result is false.. error or ignore?
@@ -236,14 +248,14 @@ set(SYCL_LINK_FLAGS "")
 # Based on Compiler ID, add support for SYCL
 if( "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang" OR
     "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntelLLVM")
-  set(SYCL_FLAGS "-fsycl ")
-  set(SYCL_LINK_FLAGS "-fsycl ")
+  list(APPEND SYCL_FLAGS "-fsycl")
+  list(APPEND SYCL_LINK_FLAGS "-fsycl")
 endif()
 
 # TODO verify if this is needed
 # Windows: Add Exception handling
 if(WIN32)
-  set(SYCL_FLAGS "${SYCL_FLAGS} /EHsc")
+  list(APPEND SYCL_FLAGS "/EHsc")
 endif()
 
 set(SYCL_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SYCL_FLAGS}")
@@ -273,32 +285,76 @@ SYCL_FEATURE_TEST_EXTRACT(${test_output})
 # define macro  SYCL_LANGUAGE_VERSION
 string(COMPARE EQUAL "${SYCL_LANGUAGE_VERSION}" "" nosycllang)
 if(nosycllang)
-  set(IntelDPCPP_FOUND False)
+  set(IntelSYCL_FOUND False)
   set(SYCL_REASON_FAILURE "SYCL: It appears that the ${CMAKE_CXX_COMPILER} does not support SYCL")
-  set(IntelDPCPP_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
+  set(IntelSYCL_NOT_FOUND_MESSAGE "${SYCL_REASON_FAILURE}")
 endif()
 
 # Placeholder for identifying various implemenations of SYCL compilers.
 # for now, set to the CMAKE_CXX_COMPILER_ID
 set(SYCL_IMPLEMENTATION_ID "${CMAKE_CXX_COMPILER_ID}")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SYCL_FLAGS}")
-set(CMAKE_CXX_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} ${SYCL_LINK_FLAGS}")
+message(DEBUG "The SYCL compiler is ${SYCL_COMPILER}")
+message(DEBUG "The SYCL Flags are ${SYCL_FLAGS}")
+message(DEBUG "The SYCL Language Version is ${SYCL_LANGUAGE_VERSION}")
 
-message(STATUS "Echo from ${CMAKE_CURRENT_SOURCE_DIR}/IntelDPCPPConfig.cmake")
-message(STATUS "The SYCL compiler is ${SYCL_COMPILER}")
-message(STATUS "The SYCL Flags are ${SYCL_FLAGS}")
-message(STATUS "The SYCL Language Version is ${SYCL_LANGUAGE_VERSION}")
+add_library(IntelSYCL::SYCL_CXX INTERFACE IMPORTED)
+set_property(TARGET IntelSYCL::SYCL_CXX PROPERTY
+  INTERFACE_COMPILE_OPTIONS ${SYCL_FLAGS})
+set_property(TARGET IntelSYCL::SYCL_CXX PROPERTY
+  INTERFACE_LINK_OPTIONS ${SYCL_LINK_FLAGS})
+set_property(TARGET IntelSYCL::SYCL_CXX PROPERTY
+  INTERFACE_INCLUDE_DIRECTORIES ${SYCL_INCLUDE_DIR})
+set_property(TARGET IntelSYCL::SYCL_CXX PROPERTY
+  INTERFACE_LINK_DIRECTORIES ${SYCL_LIBRARY_DIR})
 
 find_package_handle_standard_args(
-  IntelDPCPP
-  FOUND_VAR IntelDPCPP_FOUND
+  IntelSYCL
+  FOUND_VAR IntelSYCL_FOUND
   REQUIRED_VARS SYCL_INCLUDE_DIR SYCL_LIBRARY_DIR SYCL_FLAGS
   VERSION_VAR SYCL_LANGUAGE_VERSION
   REASON_FAILURE_MESSAGE "${SYCL_REASON_FAILURE}")
 
 # Include in Cache
 set(SYCL_LANGUAGE_VERSION "${SYCL_LANGUAGE_VERSION}" CACHE STRING "SYCL Language version")
-set(SYCL_INCLUDE_DIR "${SYCL_INCLUDE_DIR}" CACHE FILEPATH "SYCL Include directory")
-set(SYCL_LIBRARY_DIR "${SYCL_LIBRARY_DIR}" CACHE FILEPATH "SYCL Library Directory")
-set(SYCL_FLAGS "${SYCL_FLAGS}" CACHE STRING "SYCL flags for the compiler")
+
+function(add_sycl_to_target)
+
+  set(one_value_args TARGET)
+  set(multi_value_args SOURCES)
+  cmake_parse_arguments(SYCL
+    ""
+    "${one_value_args}"
+    "${multi_value_args}"
+    ${ARGN})
+
+
+    get_target_property(__sycl_cxx_options IntelSYCL::SYCL_CXX INTERFACE_COMPILE_OPTIONS)
+    get_target_property(__sycl_cxx_include_directories IntelSYCL::SYCL_CXX INTERFACE_INCLUDE_DIRECTORIES)
+
+    if(NOT ${ARGC})
+      message(FATAL_ERROR " add_sycl_to_target() does not have any arguments")
+    elseif(${ARGC} EQUAL 1)
+      message(WARNING "add_sycl_to_target() have only one argument specified.. assuming the target to be ${ARGV}.
+Adding sycl to all sources but that may effect compilation times")
+      set(SYCL_TARGET ${ARGV})
+    endif()
+
+    if(NOT SYCL_SOURCES)
+      message(WARNING "add_sycl_to_target() does not have sources specified.. Adding sycl to all sources but that may effect compilation times")
+      target_compile_options(${SYCL_TARGET} PUBLIC ${__sycl_cxx_options})
+      target_include_directories(${SYCL_TARGET} PUBLIC ${__sycl_cxx_include_directories})
+    endif()
+
+    foreach(source ${SYCL_SOURCES})
+      set_source_files_properties(${source} PROPERTIES COMPILE_OPTIONS "${__sycl_cxx_options}")
+      set_source_files_properties(${source} PROPERTIES INCLUDE_DIRECTORIES "${__sycl_cxx_include_directories}")
+    endforeach()
+
+    get_target_property(__sycl_link_options
+        IntelSYCL::SYCL_CXX INTERFACE_LINK_OPTIONS)
+    target_link_options(${SYCL_TARGET} PRIVATE "${__sycl_link_options}")
+    get_target_property(__sycl_link_directories
+        IntelSYCL::SYCL_CXX INTERFACE_LINK_DIRECTORIES)
+    target_link_directories(${SYCL_TARGET} PUBLIC "${__sycl_link_directories}")
+endfunction(add_sycl_to_target)
diff --git a/conda-recipe/bld.bat b/conda-recipe/bld.bat
index 07fa580bb4..e92e505b63 100644
--- a/conda-recipe/bld.bat
+++ b/conda-recipe/bld.bat
@@ -6,6 +6,11 @@ set "INCLUDE=%BUILD_PREFIX%\include;%INCLUDE%"
 "%PYTHON%" setup.py clean --all
 set "SKBUILD_ARGS=-G Ninja -- -DCMAKE_C_COMPILER:PATH=icx -DCMAKE_CXX_COMPILER:PATH=icx -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON"
 
+REM Overriding IPO is useful for building in resources constrained VMs (public CI)
+if DEFINED OVERRIDE_INTEL_IPO (
+   set "SKBUILD_ARGS=%SKBUILD_ARGS% -DCMAKE_INTERPROCEDURAL_OPTIMIZATION:BOOL=FALSE"
+)
+
 FOR %%V IN (14.0.0 14 15.0.0 15 16.0.0 16 17.0.0 17) DO @(
   REM set DIR_HINT if directory exists
   IF EXIST "%BUILD_PREFIX%\Library\lib\clang\%%V\" (
diff --git a/conda-recipe/meta.yaml b/conda-recipe/meta.yaml
index 7b6f071610..2806fb9262 100644
--- a/conda-recipe/meta.yaml
+++ b/conda-recipe/meta.yaml
@@ -9,6 +9,7 @@ build:
     number: {{ GIT_DESCRIBE_NUMBER }}
     script_env:
         - WHEELS_OUTPUT_FOLDER
+        - OVERRIDE_INTEL_IPO  # [win]
 
 requirements:
     build:
diff --git a/dpctl/CMakeLists.txt b/dpctl/CMakeLists.txt
index 795ca09c78..cb872ff45f 100644
--- a/dpctl/CMakeLists.txt
+++ b/dpctl/CMakeLists.txt
@@ -58,7 +58,6 @@ elseif(UNIX)
     string(CONCAT CXXFLAGS
         "${WARNING_FLAGS}"
         "${SDL_FLAGS}"
-        "-fsycl "
     )
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 ${CFLAGS}")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 ${CXXFLAGS}")
@@ -137,10 +136,15 @@ add_custom_target(
 set(CMAKE_INSTALL_RPATH "$ORIGIN")
 
 function(build_dpctl_ext _trgt _src _dest)
+    set(options SYCL)
+    cmake_parse_arguments(BUILD_DPCTL_EXT "${options}" "" "" ${ARGN})
     add_cython_target(${_trgt} ${_src} CXX OUTPUT_VAR _generated_src)
     set(_cythonize_trgt "${_trgt}_cythonize_pyx")
     add_custom_target(${_cythonize_trgt} DEPENDS ${_src})
-    python_add_library(${_trgt} MODULE ${_generated_src})
+    Python_add_library(${_trgt} MODULE WITH_SOABI ${_generated_src})
+    if (BUILD_DPCTL_EXT_SYCL)
+      add_sycl_to_target(TARGET ${_trgt} SOURCES ${_generated_src})
+    endif()
     target_include_directories(${_trgt} PRIVATE ${NumPy_INCLUDE_DIR} ${DPCTL_INCLUDE_DIR})
     add_dependencies(${_trgt} _build_time_create_dpctl_include_copy ${_cythonize_trgt})
     if (DPCTL_GENERATE_COVERAGE)
@@ -185,14 +189,18 @@ function(build_dpctl_ext _trgt _src _dest)
     install(TARGETS ${_trgt} LIBRARY DESTINATION ${_dest})
 endfunction()
 
-file(GLOB _cython_sources *.pyx)
+file(GLOB _cython_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.pyx)
+list(REMOVE_ITEM _cython_sources ${CMAKE_CURRENT_SOURCE_DIR}/_sycl_queue.pyx)
 foreach(_cy_file ${_cython_sources})
     get_filename_component(_trgt ${_cy_file} NAME_WLE)
     build_dpctl_ext(${_trgt} ${_cy_file} "dpctl")
 endforeach()
 
+set(_cy_file ${CMAKE_CURRENT_SOURCE_DIR}/_sycl_queue.pyx)
+get_filename_component(_trgt ${_cy_file} NAME_WLE)
+build_dpctl_ext(${_trgt} ${_cy_file} "dpctl" SYCL)
 # _sycl_queue include _host_task_util.hpp
-target_include_directories(_sycl_queue PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+target_include_directories(${_trgt} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 
 add_subdirectory(program)
 add_subdirectory(memory)
diff --git a/dpctl/tensor/CMakeLists.txt b/dpctl/tensor/CMakeLists.txt
index 9a2493421e..aba009411d 100644
--- a/dpctl/tensor/CMakeLists.txt
+++ b/dpctl/tensor/CMakeLists.txt
@@ -30,8 +30,7 @@ if(WIN32)
     endif()
 endif()
 
-set(python_module_name _tensor_impl)
-pybind11_add_module(${python_module_name} MODULE
+set(_tensor_impl_sources
     ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/tensor_py.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/accumulators.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/simplify_iteration_space.cpp
@@ -52,16 +51,29 @@ pybind11_add_module(${python_module_name} MODULE
     ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/repeat.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/reduction_over_axis.cpp
 )
+
+set(python_module_name _tensor_impl)
+pybind11_add_module(${python_module_name} MODULE ${_tensor_impl_sources})
+add_sycl_to_target(TARGET ${python_module_name} SOURCES ${_tensor_impl_sources})
 set(_clang_prefix "")
 if (WIN32)
   set(_clang_prefix "/clang:")
 endif()
-set_source_files_properties(
+
+set(_no_fast_math_sources
   ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/full_ctor.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/linear_sequences.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/elementwise_functions.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/reduction_over_axis.cpp
-  PROPERTIES COMPILE_OPTIONS "${_clang_prefix}-fno-fast-math")
+)
+foreach(_src_fn ${_no_fast_math_sources})
+  get_source_file_property(_cmpl_options_prop ${_src_fn} COMPILE_OPTIONS)
+  set(_combined_options_prop ${_cmpl_options_prop} "${_clang_prefix}-fno-fast-math")
+  set_source_files_properties(
+     ${_src_fn}
+     PROPERTIES COMPILE_OPTIONS "${_combined_options_prop}"
+  )
+endforeach()
 if (UNIX)
   set_source_files_properties(
     ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/elementwise_functions.cpp
diff --git a/dpctl/utils/CMakeLists.txt b/dpctl/utils/CMakeLists.txt
index 8bc65e3056..aadc1c0fe0 100644
--- a/dpctl/utils/CMakeLists.txt
+++ b/dpctl/utils/CMakeLists.txt
@@ -16,9 +16,11 @@ add_custom_target(_dpctl4pybind11_header_ready
 )
 
 set(python_module_name _device_queries)
+set(_module_src ${CMAKE_CURRENT_SOURCE_DIR}/src/device_queries.cpp)
 pybind11_add_module(${python_module_name} MODULE
-  ${CMAKE_CURRENT_SOURCE_DIR}/src/device_queries.cpp
+  ${_module_src}
 )
+add_sycl_to_target(TARGET ${python_module_name} SOURCES ${_module_src})
 target_include_directories(${python_module_name}
     PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/../include
diff --git a/examples/pybind11/external_usm_allocation/CMakeLists.txt b/examples/pybind11/external_usm_allocation/CMakeLists.txt
index db8c6c9aa6..c8679ab73a 100644
--- a/examples/pybind11/external_usm_allocation/CMakeLists.txt
+++ b/examples/pybind11/external_usm_allocation/CMakeLists.txt
@@ -5,7 +5,7 @@ project(external_usm_allocation VERSION 0.1 LANGUAGES CXX
 
 set(DPCTL_CMAKE_MODULES_PATH "${CMAKE_SOURCE_DIR}/../../../cmake")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${DPCTL_CMAKE_MODULES_PATH})
-find_package(IntelDPCPP REQUIRED PATHS ${DPCTL_CMAKE_MODULES_PATH} NO_DEFAULT_PATH)
+find_package(IntelSYCL REQUIRED PATHS ${DPCTL_CMAKE_MODULES_PATH} NO_DEFAULT_PATH)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
@@ -23,10 +23,14 @@ find_package(Python REQUIRED COMPONENTS Development.Module NumPy)
 find_package(Dpctl REQUIRED)
 
 set(py_module_name _external_usm_alloc)
+set(_sources
+  external_usm_allocation/_usm_alloc_example.cpp
+)
 pybind11_add_module(${py_module_name}
     MODULE
-    external_usm_allocation/_usm_alloc_example.cpp
+    ${_sources}
 )
+add_sycl_to_target(TARGET ${py_module_name} SOURCES ${_sources})
 target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS})
 install(TARGETS ${py_module_name}
   DESTINATION external_usm_allocation
diff --git a/examples/pybind11/onemkl_gemv/CMakeLists.txt b/examples/pybind11/onemkl_gemv/CMakeLists.txt
index c2ac5fc516..eb70b22982 100644
--- a/examples/pybind11/onemkl_gemv/CMakeLists.txt
+++ b/examples/pybind11/onemkl_gemv/CMakeLists.txt
@@ -4,7 +4,7 @@ project(example_use_mkl_gemm VERSION 0.1 LANGUAGES CXX
   DESCRIPTION "Example of using Python wrapper to oneMKL function")
 set(DPCTL_CMAKE_MODULES_PATH "${CMAKE_SOURCE_DIR}/../../../cmake")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${DPCTL_CMAKE_MODULES_PATH})
-find_package(IntelDPCPP REQUIRED PATHS ${DPCTL_CMAKE_MODULES_PATH} NO_DEFAULT_PATH)
+find_package(IntelSYCL REQUIRED PATHS ${DPCTL_CMAKE_MODULES_PATH} NO_DEFAULT_PATH)
 
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}")
@@ -35,10 +35,12 @@ find_library(OpenCL NAMES OpenCL REQUIRED)
 
 set(py_module_name _onemkl)
 
+set(_sources sycl_gemm/_onemkl.cpp)
 pybind11_add_module(${py_module_name}
     MODULE
-    sycl_gemm/_onemkl.cpp
+    ${_sources}
 )
+add_sycl_to_target(TARGET ${py_module_name} SOURCES ${_sources})
 target_compile_definitions(${py_module_name} PRIVATE -DMKL_ILP64)
 target_include_directories(${py_module_name}
     PUBLIC ${MKL_INCLUDE_DIR} sycl_gemm
@@ -50,11 +52,14 @@ target_link_libraries(${py_module_name}
 install(TARGETS ${py_module_name} DESTINATION sycl_gemm)
 target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS})
 
-get_target_property(_sycl_gemm_sources ${py_module_name} SOURCES)
-set_source_files_properties(${_sycl_gemm_sources}
-  PROPERTIES
-  COMPILE_OPTIONS "-O3"
-)
+foreach(_src_fn ${_sources})
+    get_source_file_property(_compile_options ${_src_fn} COMPILE_OPTIONS)
+    set(_combined_options ${_compile_options} "-O3")
+    set_source_files_properties(${_src_fn}
+        PROPERTIES
+        COMPILE_OPTIONS "${_combined_options}"
+    )
+endforeach()
 target_link_options(${py_module_name} PRIVATE -fsycl-device-code-split=per_kernel)
 
 add_executable(standalone_cpp
diff --git a/examples/pybind11/use_dpctl_sycl_kernel/CMakeLists.txt b/examples/pybind11/use_dpctl_sycl_kernel/CMakeLists.txt
index 32770aa750..ec33b2e153 100644
--- a/examples/pybind11/use_dpctl_sycl_kernel/CMakeLists.txt
+++ b/examples/pybind11/use_dpctl_sycl_kernel/CMakeLists.txt
@@ -5,7 +5,7 @@ project(use_queue_device VERSION 0.1 LANGUAGES CXX
 
 set(DPCTL_CMAKE_MODULES_PATH "${CMAKE_SOURCE_DIR}/../../../cmake")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${DPCTL_CMAKE_MODULES_PATH})
-find_package(IntelDPCPP REQUIRED PATHS ${DPCTL_CMAKE_MODULES_PATH} NO_DEFAULT_PATH)
+find_package(IntelSYCL REQUIRED PATHS ${DPCTL_CMAKE_MODULES_PATH} NO_DEFAULT_PATH)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
@@ -24,10 +24,12 @@ find_package(Python REQUIRED COMPONENTS Development.Module NumPy)
 find_package(Dpctl REQUIRED)
 
 set(py_module_name _use_kernel)
+set(_sources use_kernel/_example.cpp)
 pybind11_add_module(${py_module_name}
     MODULE
-    use_kernel/_example.cpp
+    ${_sources}
 )
+add_sycl_to_target(TARGET ${py_module_name} SOURCES ${_sources})
 target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS})
 install(TARGETS ${py_module_name}
   DESTINATION use_kernel
diff --git a/examples/pybind11/use_dpctl_sycl_queue/CMakeLists.txt b/examples/pybind11/use_dpctl_sycl_queue/CMakeLists.txt
index 4ee47e71a9..827388fae1 100644
--- a/examples/pybind11/use_dpctl_sycl_queue/CMakeLists.txt
+++ b/examples/pybind11/use_dpctl_sycl_queue/CMakeLists.txt
@@ -5,7 +5,7 @@ project(use_queue_device VERSION 0.1 LANGUAGES CXX
 
 set(DPCTL_CMAKE_MODULES_PATH "${CMAKE_SOURCE_DIR}/../../../cmake")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${DPCTL_CMAKE_MODULES_PATH})
-find_package(IntelDPCPP REQUIRED PATHS ${DPCTL_CMAKE_MODULES_PATH} NO_DEFAULT_PATH)
+find_package(IntelSYCL REQUIRED PATHS ${DPCTL_CMAKE_MODULES_PATH} NO_DEFAULT_PATH)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
@@ -23,10 +23,12 @@ find_package(Python REQUIRED COMPONENTS Development.Module NumPy)
 find_package(Dpctl REQUIRED)
 
 set(py_module_name _use_queue_device)
+set(_sources use_queue_device/_example.cpp)
 pybind11_add_module(${py_module_name}
     MODULE
-    use_queue_device/_example.cpp
+    ${_sources}
 )
+add_sycl_to_target(TARGET ${py_module_name} SOURCES ${_sources})
 target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS})
 install(TARGETS ${py_module_name}
   DESTINATION use_queue_device
diff --git a/libsyclinterface/CMakeLists.txt b/libsyclinterface/CMakeLists.txt
index 01b0321064..64ec3271b1 100644
--- a/libsyclinterface/CMakeLists.txt
+++ b/libsyclinterface/CMakeLists.txt
@@ -11,8 +11,8 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/mo
 
 find_package(Git REQUIRED)
 
-if(NOT DEFINED IntelDPCPP_FOUND OR NOT IntelDPCPP_FOUND)
-   find_package(IntelDPCPP REQUIRED)
+if(NOT DEFINED IntelSYCL_FOUND OR NOT IntelSYCL_FOUND)
+   find_package(IntelSYCL REQUIRED)
 endif()
 
 # Option to turn on support for creating Level Zero interoperability programs
@@ -43,11 +43,10 @@ option(DPCTL_ENABLE_GLOG
 )
 
 # Minimum version requirement only when oneAPI dpcpp is used.
-find_package(IntelDPCPP REQUIRED)
 if(DPCTL_DPCPP_FROM_ONEAPI)
-    find_package(IntelSycl 2021.3.0 REQUIRED)
+    find_package(IntelSyclCompiler 2021.3.0 REQUIRED)
 else()
-    find_package(IntelSycl REQUIRED)
+    find_package(IntelSyclCompiler REQUIRED)
 endif()
 
 if(DPCTL_ENABLE_L0_PROGRAM_CREATION)
@@ -57,7 +56,7 @@ if(DPCTL_ENABLE_L0_PROGRAM_CREATION)
     if (UNIX)
         find_library(PI_LEVEL_ZERO_LIB
             NAMES pi_level_zero
-            HINTS ${IntelSycl_LIBRARY_DIR}
+            HINTS ${IntelSyclCompiler_LIBRARY_DIR}
         )
         find_program(READELF_PROG readelf)
         find_program(GREP_PROG grep)
@@ -77,7 +76,7 @@ endif()
 if (UNIX)
   find_library(PI_OPENCL_LIB
       NAMES pi_opencl
-      HINTS ${IntelSycl_LIBRARY_DIR}
+      HINTS ${IntelSyclCompiler_LIBRARY_DIR}
   )
   find_program(READELF_PROG readelf)
   find_program(GREP_PROG grep)
@@ -157,7 +156,6 @@ elseif(UNIX)
     string(CONCAT CXXFLAGS
         "${WARNING_FLAGS}"
         "${SDL_FLAGS}"
-        "-fsycl "
     )
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CFLAGS}")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXXFLAGS}")
@@ -206,6 +204,7 @@ add_library(DPCTLSyclInterface
     ${sources}
     ${helper_sources}
 )
+add_sycl_to_target(TARGET DPCTLSyclInterface SOURCES ${sources} ${helper_sources})
 
 if(DPCTL_GENERATE_COVERAGE)
     target_link_options(DPCTLSyclInterface
@@ -222,9 +221,6 @@ target_include_directories(DPCTLSyclInterface
     ${CMAKE_CURRENT_SOURCE_DIR}/helper/include/
     ${SYCL_INCLUDE_DIR}
 )
-target_link_libraries(DPCTLSyclInterface
-  PRIVATE ${IntelSycl_SYCL_LIBRARY}
-)
 
 if(DPCTL_ENABLE_GLOG)
     find_package(glog REQUIRED)
diff --git a/libsyclinterface/cmake/modules/FindIntelSycl.cmake b/libsyclinterface/cmake/modules/FindIntelSyclCompiler.cmake
similarity index 64%
rename from libsyclinterface/cmake/modules/FindIntelSycl.cmake
rename to libsyclinterface/cmake/modules/FindIntelSyclCompiler.cmake
index 84e8946fea..45bb4f583f 100644
--- a/libsyclinterface/cmake/modules/FindIntelSycl.cmake
+++ b/libsyclinterface/cmake/modules/FindIntelSyclCompiler.cmake
@@ -19,21 +19,23 @@
 #
 # Example usage:
 #
-# find_package(IntelSycl)
+# find_package(IntelSyclCompiler)
 #
 # If successful, the following variables will be defined:
-# IntelSycl_FOUND
-# IntelSycl_VERSION
-# IntelSycl_INCLUDE_DIR
-# IntelSycl_C_COMPILER
-# IntelSycl_CXX_COMPILER
-# IntelSycl_SYCL_INCLUDE_DIR
-# IntelSycl_LIBRARY_DIR
-# IntelSycl_SYCL_LIBRARY
-# IntelSycl_OPENCL_LIBRARY
+# IntelSyclCompiler_FOUND
+# IntelSyclCompiler_VERSION
+# IntelSyclCompiler_INCLUDE_DIR
+# IntelSyclCompiler_C_COMPILER
+# IntelSyclCompiler_CXX_COMPILER
+# IntelSyclCompiler_SYCL_INCLUDE_DIR
+# IntelSyclCompiler_LIBRARY_DIR
+# IntelSyclCompiler_SYCL_LIBRARY
+# IntelSyclCompiler_OPENCL_LIBRARY
 
 include(FindPackageHandleStandardArgs)
-find_package(IntelDPCPP REQUIRED)
+if(NOT DEFINED IntelSYCL_FOUND OR NOT IntelSYCL_FOUND)
+   find_package(IntelSYCL REQUIRED)
+endif()
 
 # We will extract the version information from the compiler
 set(clangxx_cmd "${CMAKE_CXX_COMPILER}")
@@ -91,78 +93,78 @@ execute_process(
 
 # If dpcpp is found then set the package variables
 if(${clangxx_result} MATCHES "0")
-    string(REPLACE "\n" ";" IntelSycl_VERSION_LIST "${clangxx_ver}")
+    string(REPLACE "\n" ";" IntelSyclCompiler_VERSION_LIST "${clangxx_ver}")
     set(IDX 0)
-    foreach(X ${IntelSycl_VERSION_LIST})
+    foreach(X ${IntelSyclCompiler_VERSION_LIST})
         message(STATUS "dpcpp ver[${IDX}]: ${X}")
         MATH(EXPR IDX "${IDX}+1")
     endforeach()
-    list(GET IntelSycl_VERSION_LIST 0 VERSION_STRING)
+    list(GET IntelSyclCompiler_VERSION_LIST 0 VERSION_STRING)
 
     # Get the dpcpp version
     string(REGEX MATCH
         "[0-9]+\.[0-9]+\.[0-9]+"
-        IntelSycl_VERSION
+        IntelSyclCompiler_VERSION
         ${VERSION_STRING}
     )
 
     # Split out the version into major, minor an patch
-    string(REPLACE "." ";" IntelSycl_VERSION_LIST1 "${IntelSycl_VERSION}")
-    list(GET IntelSycl_VERSION_LIST1 0 IntelSycl_VERSION_MAJOR)
-    list(GET IntelSycl_VERSION_LIST1 1 IntelSycl_VERSION_MINOR)
-    list(GET IntelSycl_VERSION_LIST1 2 IntelSycl_VERSION_PATCH)
-    set(IntelSycl_INCLUDE_DIR ${SYCL_INCLUDE_DIR})
-    set(IntelSycl_SYCL_INCLUDE_DIR ${SYCL_INCLUDE_DIR}/sycl)
-    set(IntelSycl_LIBRARY_DIR ${SYCL_LIBRARY_DIR})
+    string(REPLACE "." ";" IntelSyclCompiler_VERSION_LIST1 "${IntelSyclCompiler_VERSION}")
+    list(GET IntelSyclCompiler_VERSION_LIST1 0 IntelSyclCompiler_VERSION_MAJOR)
+    list(GET IntelSyclCompiler_VERSION_LIST1 1 IntelSyclCompiler_VERSION_MINOR)
+    list(GET IntelSyclCompiler_VERSION_LIST1 2 IntelSyclCompiler_VERSION_PATCH)
+    set(IntelSyclCompiler_INCLUDE_DIR ${SYCL_INCLUDE_DIR})
+    set(IntelSyclCompiler_SYCL_INCLUDE_DIR ${SYCL_INCLUDE_DIR}/sycl)
+    set(IntelSyclCompiler_LIBRARY_DIR ${SYCL_LIBRARY_DIR})
     if("x${CMAKE_SYSTEM_NAME}" STREQUAL "xWindows")
         find_file(
-            IntelSycl_SYCL_LIBRARY
+            IntelSyclCompiler_SYCL_LIBRARY
             NAMES "sycl.lib" "sycl6.lib" "sycl7.lib"
-            PATHS ${IntelSycl_LIBRARY_DIR}
+            PATHS ${IntelSyclCompiler_LIBRARY_DIR}
         )
         find_file(
-            IntelSycl_OPENCL_LIBRARY
+            IntelSyclCompiler_OPENCL_LIBRARY
             NAMES "OpenCL.lib"
-            PATHS ${IntelSycl_LIBRARY_DIR}
+            PATHS ${IntelSyclCompiler_LIBRARY_DIR}
         )
     elseif("x${CMAKE_SYSTEM_NAME}" STREQUAL "xLinux")
         find_file(
-            IntelSycl_SYCL_LIBRARY
+            IntelSyclCompiler_SYCL_LIBRARY
             NAMES "libsycl.so"
-            PATHS ${IntelSycl_LIBRARY_DIR}
+            PATHS ${IntelSyclCompiler_LIBRARY_DIR}
         )
         find_file(
-            IntelSycl_OPENCL_LIBRARY
+            IntelSyclCompiler_OPENCL_LIBRARY
             NAMES "libOpenCL.so"
-            PATHS ${IntelSycl_LIBRARY_DIR}
+            PATHS ${IntelSyclCompiler_LIBRARY_DIR}
         )
     endif()
 
 endif()
 
 # Check if a specific version of DPCPP is requested.
-if(IntelSycl_FIND_VERSION AND (DEFINED IntelSycl_VERSION))
+if(IntelSyclCompiler_FIND_VERSION AND (DEFINED IntelSyclCompiler_VERSION))
     set(VERSION_GT_FIND_VERSION FALSE)
     versions_greater_equal(
-        ${IntelSycl_VERSION}
-        ${IntelSycl_FIND_VERSION}
+        ${IntelSyclCompiler_VERSION}
+        ${IntelSyclCompiler_FIND_VERSION}
         VERSION_GT_FIND_VERSION
     )
     if(VERSION_GT_FIND_VERSION)
-        set(IntelSycl_FOUND TRUE)
+        set(IntelSyclCompiler_FOUND TRUE)
     else()
-        set(IntelSycl_FOUND FALSE)
+        set(IntelSyclCompiler_FOUND FALSE)
     endif()
 else()
-    set(IntelSycl_FOUND TRUE)
+    set(IntelSyclCompiler_FOUND TRUE)
 endif()
 
-find_package_handle_standard_args(IntelSycl DEFAULT_MSG
-    IntelSycl_FOUND
-    IntelSycl_VERSION
-    IntelSycl_INCLUDE_DIR
-    IntelSycl_SYCL_INCLUDE_DIR
-    IntelSycl_LIBRARY_DIR
-    IntelSycl_SYCL_LIBRARY
-    IntelSycl_OPENCL_LIBRARY
+find_package_handle_standard_args(IntelSyclCompiler DEFAULT_MSG
+    IntelSyclCompiler_FOUND
+    IntelSyclCompiler_VERSION
+    IntelSyclCompiler_INCLUDE_DIR
+    IntelSyclCompiler_SYCL_INCLUDE_DIR
+    IntelSyclCompiler_LIBRARY_DIR
+    IntelSyclCompiler_SYCL_LIBRARY
+    IntelSyclCompiler_OPENCL_LIBRARY
 )
diff --git a/libsyclinterface/include/Config/dpctl_config.h.in b/libsyclinterface/include/Config/dpctl_config.h.in
index f26fc5591b..6e3daffbed 100644
--- a/libsyclinterface/include/Config/dpctl_config.h.in
+++ b/libsyclinterface/include/Config/dpctl_config.h.in
@@ -31,7 +31,7 @@
 #define __SYCL_COMPILER_VERSION_REQUIRED 20221201L
 
 /* The DPCPP version used to build dpctl */
-#define DPCTL_DPCPP_VERSION "@IntelSycl_VERSION@"
+#define DPCTL_DPCPP_VERSION "@IntelSyclCompiler_VERSION@"
 
 #define DPCTL_LIBZE_LOADER_FILENAME "@LIBZE_LOADER_FILENAME@"
 #define DPCTL_LIBCL_LOADER_FILENAME "@LIBCL_LOADER_FILENAME@"
diff --git a/libsyclinterface/tests/CMakeLists.txt b/libsyclinterface/tests/CMakeLists.txt
index 4cfd30338d..472e1787fa 100644
--- a/libsyclinterface/tests/CMakeLists.txt
+++ b/libsyclinterface/tests/CMakeLists.txt
@@ -21,17 +21,39 @@ foreach(tf ${spirv-test-files})
     file(COPY ${tf} DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 endforeach()
 
-if(DPCTL_GENERATE_COVERAGE)
-    file(GLOB_RECURSE
-        sources ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp
-    )
+file(GLOB_RECURSE
+    sources ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp
+)
 
-    # Add all dpctl sources into a single executable so that we can run coverage
-    # analysis and generate a report.
-    add_executable(dpctl_c_api_tests
-        EXCLUDE_FROM_ALL
-        ${sources}
-    )
+# Add all dpctl sources into a single executable so that we can run coverage
+# analysis and generate a report.
+add_executable(dpctl_c_api_tests
+    EXCLUDE_FROM_ALL
+    ${sources}
+)
+add_sycl_to_target(
+  TARGET dpctl_c_api_tests
+  SOURCES
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_helper.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_context_interface.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_device_invalid_filters.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_device_subdevices.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_device_interface.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_device_manager.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_device_selector_interface.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_device_aspects.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_event_interface.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_platform_interface.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_kernel_interface.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_kernel_bundle_interface.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_platform_invalid_filters.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_queue_manager.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_queue_submit.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_queue_interface.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_sycl_usm_interface.cpp
+)
+
+if(DPCTL_GENERATE_COVERAGE)
     target_include_directories(dpctl_c_api_tests
         PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../helper/include"
         PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../include"
@@ -40,7 +62,7 @@ if(DPCTL_GENERATE_COVERAGE)
         ${CMAKE_THREAD_LIBS_INIT}
         GTest::GTest
         DPCTLSyclInterface
-        ${IntelSycl_OPENCL_LIBRARY}
+        ${IntelSyclCompiler_OPENCL_LIBRARY}
         ${CMAKE_DL_LIBS}
     )
     set(object_arg "-object;")
@@ -90,13 +112,11 @@ if(DPCTL_GENERATE_COVERAGE)
         DEPENDS dpctl_c_api_tests
     )
 else()
-    file(GLOB_RECURSE sources ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
-    add_executable(dpctl_c_api_tests EXCLUDE_FROM_ALL ${sources})
     target_link_libraries(dpctl_c_api_tests
         ${CMAKE_THREAD_LIBS_INIT}
         GTest::GTest
         DPCTLSyclInterface
-        ${IntelSycl_OPENCL_LIBRARY}
+        ${IntelSyclCompiler_OPENCL_LIBRARY}
     )
 endif()