diff --git a/sycl/CMakeLists.txt b/sycl/CMakeLists.txt
index c87834185879d..0832e50ebc795 100644
--- a/sycl/CMakeLists.txt
+++ b/sycl/CMakeLists.txt
@@ -9,7 +9,7 @@ option(SYCL_ENABLE_WERROR "Treat all warnings as errors in SYCL project" OFF)
 option(SYCL_ADD_DEV_VERSION_POSTFIX "Adds -V postfix to version string" ON)
 
 set(SYCL_MAJOR_VERSION 2)
-set(SYCL_MINOR_VERSION 0)
+set(SYCL_MINOR_VERSION 1)
 set(SYCL_PATCH_VERSION 0)
 set(SYCL_DEV_ABI_VERSION 0)
 if (SYCL_ADD_DEV_VERSION_POSTFIX)
diff --git a/sycl/include/CL/sycl/backend/cuda.hpp b/sycl/include/CL/sycl/backend/cuda.hpp
index d215800e673b7..5235131e62401 100644
--- a/sycl/include/CL/sycl/backend/cuda.hpp
+++ b/sycl/include/CL/sycl/backend/cuda.hpp
@@ -21,6 +21,7 @@ typedef int CUdevice;
 typedef struct CUctx_st *CUcontext;
 typedef struct CUstream_st *CUstream;
 typedef struct CUevent_st *CUevent;
+typedef struct CUmod_st *CUmodule;
 
 // As defined in the CUDA 10.1 header file. This requires CUDA version > 3.2
 #if defined(_WIN64) || defined(__LP64__)
@@ -40,6 +41,8 @@ template <> struct interop<backend::cuda, queue> { using type = CUstream; };
 
 template <> struct interop<backend::cuda, event> { using type = CUevent; };
 
+template <> struct interop<backend::cuda, program> { using type = CUmodule; };
+
 template <typename DataT, int Dimensions, access::mode AccessMode>
 struct interop<backend::cuda, accessor<DataT, Dimensions, AccessMode,
                                        access::target::global_buffer,
diff --git a/sycl/include/CL/sycl/backend/level_zero.hpp b/sycl/include/CL/sycl/backend/level_zero.hpp
new file mode 100644
index 0000000000000..54a1a04d5f996
--- /dev/null
+++ b/sycl/include/CL/sycl/backend/level_zero.hpp
@@ -0,0 +1,81 @@
+//==--------- level_zero.hpp - SYCL Level-Zero backend ---------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <CL/sycl.hpp>
+#include <level_zero/ze_api.h>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+template <> struct interop<backend::level0, platform> {
+  using type = ze_driver_handle_t;
+};
+
+template <> struct interop<backend::level0, device> {
+  using type = ze_device_handle_t;
+};
+
+template <> struct interop<backend::level0, queue> {
+  using type = ze_command_queue_handle_t;
+};
+
+template <> struct interop<backend::level0, program> {
+  using type = ze_module_handle_t;
+};
+
+template <typename DataT, int Dimensions, access::mode AccessMode>
+struct interop<backend::level0, accessor<DataT, Dimensions, AccessMode,
+                                         access::target::global_buffer,
+                                         access::placeholder::false_t>> {
+  using type = char *;
+};
+
+namespace level0 {
+
+// Implementation of various "make" functions resides in libsycl.so
+platform make_platform(pi_native_handle NativeHandle);
+device make_device(const platform &Platform, pi_native_handle NativeHandle);
+program make_program(const context &Context, pi_native_handle NativeHandle);
+queue make_queue(const context &Context, pi_native_handle InteropHandle);
+
+// Construction of SYCL platform.
+template <typename T, typename std::enable_if<
+                          std::is_same<T, platform>::value>::type * = nullptr>
+T make(typename interop<backend::level0, T>::type Interop) {
+  return make_platform(reinterpret_cast<pi_native_handle>(Interop));
+}
+
+// Construction of SYCL device.
+template <typename T, typename std::enable_if<
+                          std::is_same<T, device>::value>::type * = nullptr>
+T make(const platform &Platform,
+       typename interop<backend::level0, T>::type Interop) {
+  return make_device(Platform, reinterpret_cast<pi_native_handle>(Interop));
+}
+
+// Construction of SYCL program.
+template <typename T, typename std::enable_if<
+                          std::is_same<T, program>::value>::type * = nullptr>
+T make(const context &Context,
+       typename interop<backend::level0, T>::type Interop) {
+  return make_program(Context, reinterpret_cast<pi_native_handle>(Interop));
+}
+
+// Construction of SYCL queue.
+template <typename T, typename std::enable_if<
+                          std::is_same<T, queue>::value>::type * = nullptr>
+T make(const context &Context,
+       typename interop<backend::level0, T>::type Interop) {
+  return make_queue(Context, reinterpret_cast<pi_native_handle>(Interop));
+}
+
+} // namespace level0
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)
diff --git a/sycl/include/CL/sycl/detail/pi.h b/sycl/include/CL/sycl/detail/pi.h
index 6718261c485b8..bbc9229e23637 100644
--- a/sycl/include/CL/sycl/detail/pi.h
+++ b/sycl/include/CL/sycl/detail/pi.h
@@ -850,9 +850,10 @@ piextDeviceGetNativeHandle(pi_device device, pi_native_handle *nativeHandle);
 /// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param nativeHandle is the native handle to create PI device from.
+/// \param platform is the platform of the device.
 /// \param device is the PI device created from the native handle.
 __SYCL_EXPORT pi_result piextDeviceCreateWithNativeHandle(
-    pi_native_handle nativeHandle, pi_device *device);
+    pi_native_handle nativeHandle, pi_platform platform, pi_device *device);
 
 /// Selects the most appropriate device binary based on runtime information
 /// and the IR characteristics.
@@ -944,9 +945,10 @@ piextQueueGetNativeHandle(pi_queue queue, pi_native_handle *nativeHandle);
 /// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param nativeHandle is the native handle to create PI queue from.
+/// \param context is the PI context of the queue.
 /// \param queue is the PI queue created from the native handle.
 __SYCL_EXPORT pi_result piextQueueCreateWithNativeHandle(
-    pi_native_handle nativeHandle, pi_queue *queue);
+    pi_native_handle nativeHandle, pi_context context, pi_queue *queue);
 
 //
 // Memory
@@ -1066,9 +1068,10 @@ piextProgramGetNativeHandle(pi_program program, pi_native_handle *nativeHandle);
 /// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param nativeHandle is the native handle to create PI program from.
+/// \param context is the PI context of the program.
 /// \param program is the PI program created from the native handle.
 __SYCL_EXPORT pi_result piextProgramCreateWithNativeHandle(
-    pi_native_handle nativeHandle, pi_program *program);
+    pi_native_handle nativeHandle, pi_context context, pi_program *program);
 
 //
 // Kernel
diff --git a/sycl/include/CL/sycl/detail/pi.hpp b/sycl/include/CL/sycl/detail/pi.hpp
index 5ff6e6312df36..654320722a5fb 100644
--- a/sycl/include/CL/sycl/detail/pi.hpp
+++ b/sycl/include/CL/sycl/detail/pi.hpp
@@ -334,14 +334,15 @@ template <class To, class From> inline To cast(From value) {
 
 // These conversions should use PI interop API.
 template <> inline pi::PiProgram cast(cl_program) {
-  RT::assertion(false, "pi::cast -> use piextProgramFromNative");
+  RT::assertion(false, "pi::cast -> use piextCreateProgramWithNativeHandle");
   return {};
 }
 
 template <> inline pi::PiDevice cast(cl_device_id) {
-  RT::assertion(false, "pi::cast -> use piextDeviceFromNative");
+  RT::assertion(false, "pi::cast -> use piextCreateDeviceWithNativeHandle");
   return {};
 }
+
 } // namespace pi
 } // namespace detail
 
diff --git a/sycl/include/CL/sycl/platform.hpp b/sycl/include/CL/sycl/platform.hpp
index 8c04919102df5..f45eb532c06b5 100644
--- a/sycl/include/CL/sycl/platform.hpp
+++ b/sycl/include/CL/sycl/platform.hpp
@@ -112,7 +112,7 @@ class __SYCL_EXPORT platform {
   /// \return a native handle, the type of which defined by the backend.
   template <backend BackendName>
   auto get_native() const -> typename interop<BackendName, platform>::type {
-    return detail::pi::cast<typename interop<BackendName, platform>::type>(
+    return reinterpret_cast<typename interop<BackendName, platform>::type>(
         getNative());
   }
 
diff --git a/sycl/include/CL/sycl/program.hpp b/sycl/include/CL/sycl/program.hpp
index c08e2b454cd5a..c6dbebf3f45bf 100644
--- a/sycl/include/CL/sycl/program.hpp
+++ b/sycl/include/CL/sycl/program.hpp
@@ -322,7 +322,17 @@ class __SYCL_EXPORT program {
 #endif // __SYCL_DEVICE_ONLY__
   }
 
+  /// Gets the native handle of the SYCL platform.
+  ///
+  /// \return a native handle, the type of which defined by the backend.
+  template <backend BackendName>
+  auto get_native() const -> typename interop<BackendName, program>::type {
+    return reinterpret_cast<typename interop<BackendName, program>::type>(
+        getNative());
+  }
+
 private:
+  pi_native_handle getNative() const;
   program(shared_ptr_class<detail::program_impl> impl);
 
   /// Template-free version of get_kernel.
diff --git a/sycl/plugins/cuda/pi_cuda.cpp b/sycl/plugins/cuda/pi_cuda.cpp
index 8f33a203a841c..8bde99f307c2b 100644
--- a/sycl/plugins/cuda/pi_cuda.cpp
+++ b/sycl/plugins/cuda/pi_cuda.cpp
@@ -1338,10 +1338,12 @@ pi_result cuda_piextDeviceGetNativeHandle(pi_device device,
 /// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param[in] nativeHandle The native handle to create PI device object from.
+/// \param[in] platform is the PI platform of the device.
 /// \param[out] device Set to the PI device object created from native handle.
 ///
 /// \return TBD
 pi_result cuda_piextDeviceCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                                 pi_platform platform,
                                                  pi_device *device) {
   cl::sycl::detail::pi::die(
       "Creation of PI device from native handle not implemented");
@@ -1879,10 +1881,12 @@ pi_result cuda_piextQueueGetNativeHandle(pi_queue queue,
 /// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param[in] nativeHandle The native handle to create PI queue object from.
+/// \param[in] context is the PI context of the queue.
 /// \param[out] queue Set to the PI queue object created from native handle.
 ///
 /// \return TBD
 pi_result cuda_piextQueueCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                                pi_context context,
                                                 pi_queue *queue) {
   cl::sycl::detail::pi::die(
       "Creation of PI queue from native handle not implemented");
@@ -2489,10 +2493,12 @@ pi_result cuda_piextProgramGetNativeHandle(pi_program program,
 /// NOTE: The created PI object takes ownership of the native handle.
 ///
 /// \param[in] nativeHandle The native handle to create PI program object from.
+/// \param[in] context The PI context of the program.
 /// \param[out] program Set to the PI program object created from native handle.
 ///
 /// \return TBD
 pi_result cuda_piextProgramCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                                  pi_context context,
                                                   pi_program *program) {
   cl::sycl::detail::pi::die(
       "Creation of PI program from native handle not implemented");
diff --git a/sycl/plugins/level_zero/pi_level0.cpp b/sycl/plugins/level_zero/pi_level0.cpp
index 8e3479551085f..29fb2fa8b2840 100644
--- a/sycl/plugins/level_zero/pi_level0.cpp
+++ b/sycl/plugins/level_zero/pi_level0.cpp
@@ -1182,10 +1182,16 @@ pi_result piextDeviceGetNativeHandle(pi_device Device,
 }
 
 pi_result piextDeviceCreateWithNativeHandle(pi_native_handle NativeHandle,
+                                            pi_platform Platform,
                                             pi_device *Device) {
+  assert(NativeHandle);
+  assert(Device);
+  assert(Platform);
+
   // Create PI device from the given L0 device handle.
-  die("piextDeviceCreateWithNativeHandle: not supported");
-  return PI_SUCCESS;
+  auto ZeDevice = pi_cast<ze_device_handle_t>(NativeHandle);
+  *Device = new _pi_device(ZeDevice, Platform);
+  return (*Device)->initialize();
 }
 
 pi_result piContextCreate(const pi_context_properties *Properties,
@@ -1370,13 +1376,24 @@ pi_result piQueueFinish(pi_queue Queue) {
 
 pi_result piextQueueGetNativeHandle(pi_queue Queue,
                                     pi_native_handle *NativeHandle) {
-  die("piextQueueGetNativeHandle: not supported");
+  assert(Queue);
+  assert(NativeHandle);
+
+  auto ZeQueue = pi_cast<ze_command_queue_handle_t *>(NativeHandle);
+  // Extract the L0 queue handle from the given PI queue
+  *ZeQueue = Queue->ZeCommandQueue;
   return PI_SUCCESS;
 }
 
 pi_result piextQueueCreateWithNativeHandle(pi_native_handle NativeHandle,
+                                           pi_context Context,
                                            pi_queue *Queue) {
-  die("piextQueueCreateWithNativeHandle: not supported");
+  assert(NativeHandle);
+  assert(Context);
+  assert(Queue);
+
+  auto ZeQueue = pi_cast<ze_command_queue_handle_t>(NativeHandle);
+  *Queue = new _pi_queue(ZeQueue, Context);
   return PI_SUCCESS;
 }
 
@@ -1873,13 +1890,43 @@ pi_result piProgramRelease(pi_program Program) {
 
 pi_result piextProgramGetNativeHandle(pi_program Program,
                                       pi_native_handle *NativeHandle) {
-  die("piextProgramGetNativeHandle: not supported");
+  assert(Program);
+  assert(NativeHandle);
+
+  auto ZeModule = pi_cast<ze_module_handle_t *>(NativeHandle);
+  // Extract the L0 module handle from the given PI program
+  *ZeModule = Program->ZeModule;
   return PI_SUCCESS;
 }
 
 pi_result piextProgramCreateWithNativeHandle(pi_native_handle NativeHandle,
+                                             pi_context Context,
                                              pi_program *Program) {
-  die("piextProgramCreateWithNativeHandle: not supported");
+  assert(NativeHandle);
+  assert(Context);
+  assert(Program);
+
+  auto ZeModule = pi_cast<ze_module_handle_t>(NativeHandle);
+
+  // Create PI program from the given L0 module handle.
+  //
+  // TODO: We don't have the real L0 module descriptor with
+  // which it was created, but that's only needed for zeModuleCreate,
+  // which we don't expect to be called on the interop program.
+  //
+  ze_module_desc_t ZeModuleDesc = {};
+  ZeModuleDesc.version = ZE_MODULE_DESC_VERSION_CURRENT;
+  ZeModuleDesc.format = ZE_MODULE_FORMAT_NATIVE;
+  ZeModuleDesc.inputSize = 0;
+  ZeModuleDesc.pInputModule = nullptr;
+
+  try {
+    *Program = new _pi_program(ZeModule, ZeModuleDesc, Context);
+  } catch (const std::bad_alloc &) {
+    return PI_OUT_OF_HOST_MEMORY;
+  } catch (...) {
+    return PI_ERROR_UNKNOWN;
+  }
   return PI_SUCCESS;
 }
 
diff --git a/sycl/plugins/opencl/pi_opencl.cpp b/sycl/plugins/opencl/pi_opencl.cpp
index dd51a6501d26a..718132f9a1180 100644
--- a/sycl/plugins/opencl/pi_opencl.cpp
+++ b/sycl/plugins/opencl/pi_opencl.cpp
@@ -160,7 +160,6 @@ static pi_result USMSetIndirectAccess(pi_kernel kernel) {
 
 extern "C" {
 
-// Example of a PI interface that does not map exactly to an OpenCL one.
 pi_result piPlatformsGet(pi_uint32 num_entries, pi_platform *platforms,
                          pi_uint32 *num_platforms) {
   cl_int result = clGetPlatformIDs(cast<cl_uint>(num_entries),
@@ -184,7 +183,6 @@ pi_result piextPlatformCreateWithNativeHandle(pi_native_handle nativeHandle,
   return PI_SUCCESS;
 }
 
-// Example of a PI interface that does not map exactly to an OpenCL one.
 pi_result piDevicesGet(pi_platform platform, pi_device_type device_type,
                        pi_uint32 num_entries, pi_device *devices,
                        pi_uint32 *num_devices) {
@@ -274,7 +272,7 @@ pi_result piextDeviceSelectBinary(pi_device device, pi_device_binary *images,
 }
 
 pi_result piextDeviceCreateWithNativeHandle(pi_native_handle nativeHandle,
-                                            pi_device *piDevice) {
+                                            pi_platform, pi_device *piDevice) {
   assert(piDevice != nullptr);
   *piDevice = reinterpret_cast<pi_device>(nativeHandle);
   return PI_SUCCESS;
@@ -321,7 +319,7 @@ pi_result piQueueCreate(pi_context context, pi_device device,
 }
 
 pi_result piextQueueCreateWithNativeHandle(pi_native_handle nativeHandle,
-                                           pi_queue *piQueue) {
+                                           pi_context, pi_queue *piQueue) {
   assert(piQueue != nullptr);
   *piQueue = reinterpret_cast<pi_queue>(nativeHandle);
   return PI_SUCCESS;
@@ -406,6 +404,7 @@ pi_result piProgramCreate(pi_context context, const void *il, size_t length,
 }
 
 pi_result piextProgramCreateWithNativeHandle(pi_native_handle nativeHandle,
+                                             pi_context,
                                              pi_program *piProgram) {
   assert(piProgram != nullptr);
   *piProgram = reinterpret_cast<pi_program>(nativeHandle);
diff --git a/sycl/source/CMakeLists.txt b/sycl/source/CMakeLists.txt
index 004b596e84955..5c202d369e2d3 100644
--- a/sycl/source/CMakeLists.txt
+++ b/sycl/source/CMakeLists.txt
@@ -95,6 +95,7 @@ endfunction(add_sycl_rt_library)
 set(SYCL_SOURCES
     "${sycl_inc_dir}/CL/sycl.hpp"
     "backend/opencl.cpp"
+    "backend/level_zero.cpp"
     "detail/accessor_impl.cpp"
     "detail/buffer_impl.cpp"
     "detail/builtins_common.cpp"
diff --git a/sycl/source/backend/level_zero.cpp b/sycl/source/backend/level_zero.cpp
new file mode 100644
index 0000000000000..2e62223c0301e
--- /dev/null
+++ b/sycl/source/backend/level_zero.cpp
@@ -0,0 +1,77 @@
+//==--------- level_zero.cpp - SYCL Level-Zero backend ---------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <CL/sycl.hpp>
+#include <detail/platform_impl.hpp>
+#include <detail/plugin.hpp>
+#include <detail/program_impl.hpp>
+#include <detail/queue_impl.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace level0 {
+using namespace detail;
+
+//----------------------------------------------------------------------------
+// Implementation of level0::make<platform>
+__SYCL_EXPORT platform make_platform(pi_native_handle NativeHandle) {
+  const auto &Plugin = pi::getPlugin<backend::level0>();
+  // Create PI platform first.
+  pi::PiPlatform PiPlatform;
+  Plugin.call<PiApiKind::piextPlatformCreateWithNativeHandle>(NativeHandle,
+                                                              &PiPlatform);
+
+  // Construct the SYCL platform from PI platfrom.
+  return detail::createSyclObjFromImpl<platform>(
+      std::make_shared<platform_impl>(PiPlatform, Plugin));
+}
+
+//----------------------------------------------------------------------------
+// Implementation of level0::make<device>
+__SYCL_EXPORT device make_device(const platform &Platform,
+                                 pi_native_handle NativeHandle) {
+  const auto &Plugin = pi::getPlugin<backend::level0>();
+  const auto &PlatformImpl = getSyclObjImpl(Platform);
+  // Create PI device first.
+  pi::PiDevice PiDevice;
+  Plugin.call<PiApiKind::piextDeviceCreateWithNativeHandle>(
+      NativeHandle, PlatformImpl->getHandleRef(), &PiDevice);
+  // Construct the SYCL device from PI device.
+  return detail::createSyclObjFromImpl<device>(
+      std::make_shared<device_impl>(PiDevice, PlatformImpl));
+}
+
+//----------------------------------------------------------------------------
+// Implementation of level0::make<program>
+__SYCL_EXPORT program make_program(const context &Context,
+                                   pi_native_handle NativeHandle) {
+  // Construct the SYCL program from native program.
+  // TODO: move here the code that creates PI program, and remove the
+  // native interop constructor.
+  return detail::createSyclObjFromImpl<program>(
+      std::make_shared<program_impl>(getSyclObjImpl(Context), NativeHandle));
+}
+
+//----------------------------------------------------------------------------
+// Implementation of level0::make<queue>
+__SYCL_EXPORT queue make_queue(const context &Context,
+                               pi_native_handle NativeHandle) {
+  const auto &Plugin = pi::getPlugin<backend::level0>();
+  const auto &ContextImpl = getSyclObjImpl(Context);
+  // Create PI queue first.
+  pi::PiQueue PiQueue;
+  Plugin.call<PiApiKind::piextQueueCreateWithNativeHandle>(
+      NativeHandle, ContextImpl->getHandleRef(), &PiQueue);
+  // Construct the SYCL queue from PI queue.
+  return detail::createSyclObjFromImpl<queue>(std::make_shared<queue_impl>(
+      PiQueue, ContextImpl, ContextImpl->get_async_handler()));
+}
+
+} // namespace level0
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)
diff --git a/sycl/source/backend/opencl.cpp b/sycl/source/backend/opencl.cpp
index 20f0add1f85d6..bd06563c0b8b8 100644
--- a/sycl/source/backend/opencl.cpp
+++ b/sycl/source/backend/opencl.cpp
@@ -38,7 +38,7 @@ __SYCL_EXPORT device make_device(pi_native_handle NativeHandle) {
   // Create PI device first.
   pi::PiDevice PiDevice;
   Plugin.call<PiApiKind::piextDeviceCreateWithNativeHandle>(NativeHandle,
-                                                            &PiDevice);
+                                                            nullptr, &PiDevice);
   // Construct the SYCL device from PI device.
   return detail::createSyclObjFromImpl<device>(
       std::make_shared<device_impl>(PiDevice, Plugin));
@@ -76,8 +76,8 @@ __SYCL_EXPORT queue make_queue(const context &Context,
   const auto &ContextImpl = getSyclObjImpl(Context);
   // Create PI queue first.
   pi::PiQueue PiQueue;
-  Plugin.call<PiApiKind::piextQueueCreateWithNativeHandle>(NativeHandle,
-                                                           &PiQueue);
+  Plugin.call<PiApiKind::piextQueueCreateWithNativeHandle>(
+      NativeHandle, ContextImpl->getHandleRef(), &PiQueue);
   // Construct the SYCL queue from PI queue.
   return detail::createSyclObjFromImpl<queue>(std::make_shared<queue_impl>(
       PiQueue, ContextImpl, ContextImpl->get_async_handler()));
diff --git a/sycl/source/detail/device_impl.cpp b/sycl/source/detail/device_impl.cpp
index f060986438c63..244fc00cda9d8 100644
--- a/sycl/source/detail/device_impl.cpp
+++ b/sycl/source/detail/device_impl.cpp
@@ -40,8 +40,10 @@ device_impl::device_impl(pi_native_handle InteropDeviceHandle,
   if (Device == nullptr) {
     assert(InteropDeviceHandle);
     // Get PI device from the raw device handle.
+    // NOTE: this is for OpenCL interop only (and should go away).
+    // With SYCL-2020 BE generalization "make" functions are used instead.
     Plugin.call<PiApiKind::piextDeviceCreateWithNativeHandle>(
-        InteropDeviceHandle, &MDevice);
+        InteropDeviceHandle, nullptr, &MDevice);
     InteroperabilityConstructor = true;
   }
 
diff --git a/sycl/source/detail/pi.cpp b/sycl/source/detail/pi.cpp
index b00844cf85a59..bfdc589b8a267 100644
--- a/sycl/source/detail/pi.cpp
+++ b/sycl/source/detail/pi.cpp
@@ -390,6 +390,7 @@ template <backend BE> const plugin &getPlugin() {
 }
 
 template const plugin &getPlugin<backend::opencl>();
+template const plugin &getPlugin<backend::level0>();
 
 // Report error and no return (keeps compiler from printing warnings).
 // TODO: Probably change that to throw a catchable exception,
diff --git a/sycl/source/detail/platform_impl.cpp b/sycl/source/detail/platform_impl.cpp
index 49b81c934514e..dec3ebe975d24 100644
--- a/sycl/source/detail/platform_impl.cpp
+++ b/sycl/source/detail/platform_impl.cpp
@@ -9,6 +9,7 @@
 #include <CL/sycl/device.hpp>
 #include <detail/config.hpp>
 #include <detail/device_impl.hpp>
+#include <detail/force_device.hpp>
 #include <detail/platform_impl.hpp>
 #include <detail/platform_info.hpp>
 
diff --git a/sycl/source/detail/platform_impl.hpp b/sycl/source/detail/platform_impl.hpp
index 35db1d8c6874b..16cf7ac908212 100644
--- a/sycl/source/detail/platform_impl.hpp
+++ b/sycl/source/detail/platform_impl.hpp
@@ -11,7 +11,6 @@
 #include <CL/sycl/detail/pi.hpp>
 #include <CL/sycl/info/info_desc.hpp>
 #include <CL/sycl/stl.hpp>
-#include <detail/force_device.hpp>
 #include <detail/platform_info.hpp>
 #include <detail/plugin.hpp>
 
diff --git a/sycl/source/detail/program_impl.cpp b/sycl/source/detail/program_impl.cpp
index d315a0ee23c7a..f174dfabe1570 100644
--- a/sycl/source/detail/program_impl.cpp
+++ b/sycl/source/detail/program_impl.cpp
@@ -110,8 +110,8 @@ program_impl::program_impl(ContextImplPtr Context,
     assert(InteropProgram &&
            "No InteropProgram/PiProgram defined with piextProgramFromNative");
     // Translate the raw program handle into PI program.
-    Plugin.call<PiApiKind::piextProgramCreateWithNativeHandle>(InteropProgram,
-                                                               &MProgram);
+    Plugin.call<PiApiKind::piextProgramCreateWithNativeHandle>(
+        InteropProgram, MContext->getHandleRef(), &MProgram);
   } else
     Plugin.call<PiApiKind::piProgramRetain>(Program);
 
@@ -512,6 +512,13 @@ void program_impl::flush_spec_constants(const RTDeviceBinaryImage &Img,
   }
 }
 
+pi_native_handle program_impl::getNative() const {
+  const auto &Plugin = getPlugin();
+  pi_native_handle Handle;
+  Plugin.call<PiApiKind::piextProgramGetNativeHandle>(MProgram, &Handle);
+  return Handle;
+}
+
 } // namespace detail
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)
diff --git a/sycl/source/detail/program_impl.hpp b/sycl/source/detail/program_impl.hpp
index 4205e806a6a91..eee8497ad2c1f 100644
--- a/sycl/source/detail/program_impl.hpp
+++ b/sycl/source/detail/program_impl.hpp
@@ -318,6 +318,9 @@ class program_impl {
   /// Tells whether a specialization constant has been set for this program.
   bool hasSetSpecConstants() const { return !SpecConstRegistry.empty(); }
 
+  /// Returns the native plugin handle.
+  pi_native_handle getNative() const;
+
 private:
   // Deligating Constructor used in Implementation.
   program_impl(ContextImplPtr Context, pi_native_handle InteropProgram,
diff --git a/sycl/source/program.cpp b/sycl/source/program.cpp
index 6884e91cc566b..c99842038c8bc 100644
--- a/sycl/source/program.cpp
+++ b/sycl/source/program.cpp
@@ -35,6 +35,9 @@ program::program(const context &context, cl_program clProgram)
   // must retain it in order to adhere to SYCL 1.2.1 spec (Rev6, section 4.3.1.)
   clRetainProgram(clProgram);
 }
+
+pi_native_handle program::getNative() const { return impl->getNative(); }
+
 program::program(std::shared_ptr<detail::program_impl> impl) : impl(impl) {}
 
 cl_program program::get() const { return impl->get(); }
diff --git a/sycl/source/queue.cpp b/sycl/source/queue.cpp
index a47b62950563b..18f62f85900bc 100644
--- a/sycl/source/queue.cpp
+++ b/sycl/source/queue.cpp
@@ -64,7 +64,7 @@ queue::queue(const device &syclDevice, const async_handler &asyncHandler,
 queue::queue(cl_command_queue clQueue, const context &syclContext,
              const async_handler &asyncHandler) {
   impl = std::make_shared<detail::queue_impl>(
-      detail::pi::cast<detail::RT::PiQueue>(clQueue),
+      reinterpret_cast<RT::PiQueue>(clQueue),
       detail::getSyclObjImpl(syclContext), asyncHandler);
 }
 
diff --git a/sycl/test/abi/sycl_symbols_linux.dump b/sycl/test/abi/sycl_symbols_linux.dump
index 998204aec0049..a872ac31392ac 100644
--- a/sycl/test/abi/sycl_symbols_linux.dump
+++ b/sycl/test/abi/sycl_symbols_linux.dump
@@ -4065,3 +4065,9 @@ _ZNK2cl4sycl9exception11has_contextEv
 _ZNK2cl4sycl9exception4whatEv
 __sycl_register_lib
 __sycl_unregister_lib
+_ZN2cl4sycl6level011make_deviceERKNS0_8platformEm
+_ZN2cl4sycl6level010make_queueERKNS0_7contextEm
+_ZN2cl4sycl6level012make_programERKNS0_7contextEm
+_ZN2cl4sycl6level013make_platformEm
+_ZNK2cl4sycl8platform9getNativeEv
+_ZNK2cl4sycl7program9getNativeEv