Build and ship the OpenVINO backend in the Windows wheel

The OpenVINO delegate lets ExecuTorch run models on Intel hardware (CPUs,
integrated and discrete GPUs, and NPUs). Until now the prebuilt delegate shipped
only in the Linux wheels. The Windows wheel left it out, even though Intel
publishes an OpenVINO runtime for Windows x86-64, so Windows users could not use
it without building from source.

This brings the Windows wheel to parity with Linux.

What changed:

- The runtime loader now works on Windows. It loaded the OpenVINO C library with
  POSIX calls (dlopen/dlsym) and a hardcoded libopenvino_c.so name. The loader is
  now split by platform: LoadLibraryExA/GetProcAddress/FreeLibrary and
  openvino_c.dll on Windows, the existing dlopen path on Linux. On Windows it
  loads with LOAD_WITH_ALTERED_SEARCH_PATH so the runtime's own dependencies
  (openvino.dll, TBB, the device plugins) resolve from its folder.
- The build file sets exceptions and RTTI with the compiler's own flags: /EHsc
  and /GR for MSVC, -frtti and -fexceptions otherwise.
- setup.py enables EXECUTORCH_BUILD_OPENVINO on Windows as well as Linux, and
  packages the delegate's import library (.lib) beside the other Windows DLLs.
- The openvino extra now installs the OpenVINO runtime on Windows x86-64 too, so
  pip install "executorch[openvino]" activates the backend on both platforms. The
  Python auto-discovery looks for openvino_c.dll on Windows.
- The Windows wheel smoke test now checks the delegate registers and runs a model
  through it, the same checks the Linux wheel already runs.

Test plan:

- Compiled both the Windows and POSIX branches of the loader in isolation.
- Confirmed the single-owner symbol check matches the delegate's exported name in
  both the Linux (nm) and Windows (dumpbin) spellings.
- Ran black, clang-format and cmake-format on the changed files.
- The Windows wheel CI job builds the wheel and runs the smoke test end to end.

Author: shoumikhin

.ci/scripts/wheel/test_shared_libraries.py

@@ -149,7 +149,12 @@
 # The delegate's own entry points. A second definer means the delegate is compiled
 # into the Python extension as well, which would register it twice in one process.
 _QNN_BACKEND_SYMBOLS = ("QnnExecuTorchBackendRegister",)
-_OPENVINO_BACKEND_SYMBOLS = ("executorch::backends::openvino::OpenvinoBackend",)
+# A member rather than the bare class name: a class has no symbol of its own, and the
+# PE reader matches an MSVC decorated name, which spells a member as
+# ?is_available@OpenvinoBackend@... and never the class alone.
+_OPENVINO_BACKEND_SYMBOLS = (
+    "executorch::backends::openvino::OpenvinoBackend::is_available",
+)
 
 _BUNDLED_XNNPACK_SYMBOLS = ("xnn_create_runtime_v4",)
 
@@ -1099,6 +1104,9 @@ def _wheel_cuda_train() -> str:
 
 # Marker for a row whose owner every Linux wheel carries and no macOS wheel does.
 _REQUIRED_ON_LINUX = "linux-only"
+# Marker for a row whose owner every Linux and Windows wheel carries. The OpenVINO
+# delegate loads its runtime by name on both, so neither needs the SDK at build time.
+_REQUIRED_ON_LINUX_AND_WINDOWS = "linux-and-windows"
 # Marker for a row whose owner every macOS wheel carries and no other wheel does.
 # The Core ML delegate is built on every macOS wheel, so its presence is decidable
 # from the installed wheel and a macOS wheel that dropped it should fail rather than
@@ -1122,6 +1130,8 @@ def _resolve_required(required):
         return bool(_wheel_cuda_train())
     if required == _REQUIRED_ON_LINUX:
         return sys.platform == "linux"
+    if required == _REQUIRED_ON_LINUX_AND_WINDOWS:
+        return sys.platform in ("linux", "win32")
     if required == _REQUIRED_ON_MACOS:
         return sys.platform == "darwin"
     if required == _REQUIRED_ON_LINUX_X86:
@@ -1287,7 +1297,7 @@ def _resolve_required(required):
         "OpenVINO delegate",
         _OPENVINO_BACKEND_SYMBOLS,
         _library_file_name("libexecutorch_backend_openvino"),
-        _REQUIRED_ON_LINUX,
+        _REQUIRED_ON_LINUX_AND_WINDOWS,
     ),
     # Required on Linux x86_64 only, where the Qualcomm SDK the delegate builds against
     # is published. A fixed False would pass a wheel that compiled the delegate back

.ci/scripts/wheel/test_windows.py

@@ -79,6 +79,11 @@ def run_tests(model_tests: List[ModelTest]) -> None:
 
     if platform.system() == "Windows":
         registered = _get_registered_backend_names()
+        assert (
+            "OpenvinoBackend" in registered
+        ), f"OpenvinoBackend not found in registered backends: {registered}"
+        print("✓ OpenvinoBackend is registered")
+
         # Vulkan backend is optional: only present when the wheel was built with
         # EXECUTORCH_BUILD_VULKAN=1 and the Vulkan SDK (glslc) was available.
         if "VulkanBackend" in registered:
@@ -88,6 +93,9 @@ def run_tests(model_tests: List[ModelTest]) -> None:
 
         test_base.test_cmsis_nn_install()
 
+        # Registration above proves the delegate loaded, not that it computes.
+        test_base.test_a_model_runs_through_the_openvino_delegate()
+
     # The wheel ships the runtime, the kernels, the delegate and the thread pool as
     # separate DLLs here too, so check that each has exactly one owner and that all of
     # them load.

backends/openvino/CMakeLists.txt

@@ -28,8 +28,9 @@ set(COMMON_INCLUDE_DIRS ${EXECUTORCH_ROOT}/..)
 # Include utility CMake scripts from ExecuteTorch
 include(${EXECUTORCH_ROOT}/tools/cmake/Utils.cmake)
 
-# The backend resolves OpenVINO C API symbols via dlopen/dlsym at runtime, so
-# there is no build-time dependency on the OpenVINO SDK.
+# The backend resolves OpenVINO C API symbols at runtime (dlopen on Linux,
+# LoadLibrary on Windows), so there is no build-time dependency on the OpenVINO
+# SDK.
 
 # Shared when the wheel build asks for it, static otherwise.
 if(EXECUTORCH_BUILD_SHARED)
@@ -40,7 +41,11 @@ endif()
 add_library(openvino_backend ${_openvino_backend_library_type})
 
 # Enable exceptions and RTTI for OpenVINO backend
-target_compile_options(openvino_backend PRIVATE -frtti -fexceptions)
+target_compile_options(
+  openvino_backend
+  PRIVATE $<$<CXX_COMPILER_ID:MSVC>:/EHsc /GR>
+          $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-frtti -fexceptions>
+)
 
 # Add source files for OpenVINO backend
 target_sources(

backends/openvino/README.md

@@ -14,18 +14,21 @@ For more information on the supported hardware, please refer to [OpenVINO System
 
 ## Quick Start (pip wheel)
 
-On Linux, the OpenVINO backend is included in the ExecuTorch pip wheel. Install the OpenVINO runtime to activate it:
+On Linux and Windows, the OpenVINO backend is included in the ExecuTorch pip wheel. Install the OpenVINO runtime to activate it:
 
 ```bash
 pip install executorch[openvino]
 ```
 
-The backend automatically discovers the OpenVINO C library from the pip-installed package — no `LD_LIBRARY_PATH` setup is needed.
+The backend automatically discovers the OpenVINO C library from the pip-installed package, so no library search path setup is needed.
 
 If auto-discovery fails (e.g. non-standard install), you can point to the library explicitly:
 
 ```bash
+# Linux
 export OPENVINO_LIB_PATH=$(python3 -c "import openvino, os; print(os.path.join(os.path.dirname(openvino.__file__), 'libs', 'libopenvino_c.so'))")
+# Windows (PowerShell)
+$env:OPENVINO_LIB_PATH = python -c "import openvino, os; print(os.path.join(os.path.dirname(openvino.__file__), 'libs', 'openvino_c.dll'))"
 ```
 
 Verify the backend is available:

backends/openvino/runtime/OpenvinoApi.h

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include <dlfcn.h>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
@@ -96,12 +95,9 @@ using ov_shape_create_fn =
     ov_status_e (*)(int64_t, const int64_t*, ov_shape_t*);
 using ov_shape_free_fn = ov_status_e (*)(ov_shape_t*);
 
+// Defined in OpenvinoBackend.cpp, where the platform's loader API is included.
 struct DlCloser {
-  void operator()(void* handle) {
-    if (handle) {
-      dlclose(handle);
-    }
-  }
+  void operator()(void* handle);
 };
 using DlHandle = std::unique_ptr<void, DlCloser>;
 

backends/openvino/runtime/OpenvinoBackend.cpp

@@ -10,6 +10,12 @@
 #include <cstring>
 #include <string>
 
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
 #include <executorch/runtime/backend/interface.h>
 #include <executorch/runtime/core/error.h>
 #include <executorch/runtime/core/evalue.h>
@@ -23,7 +29,45 @@ namespace openvino {
 
 namespace {
 
+#ifdef _WIN32
+constexpr const char* kDefaultLibName = "openvino_c.dll";
+constexpr const char* kLibrarySearchPathHint = "PATH";
+
+void* open_library(const char* path) {
+  // Resolves openvino_c.dll's own dependencies (openvino.dll, TBB, the device
+  // plugins) from its directory when it is given as a full path.
+  return LoadLibraryExA(path, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH);
+}
+
+std::string last_error() {
+  return "error " + std::to_string(GetLastError());
+}
+
+template <typename FuncPtr>
+FuncPtr load_symbol(void* handle, const char* name) {
+  FARPROC sym = GetProcAddress(static_cast<HMODULE>(handle), name);
+  if (!sym) {
+    ET_LOG(
+        Error,
+        "OpenVINO: failed to resolve symbol '%s': %s",
+        name,
+        last_error().c_str());
+    return nullptr;
+  }
+  return reinterpret_cast<FuncPtr>(sym);
+}
+#else
 constexpr const char* kDefaultLibName = "libopenvino_c.so";
+constexpr const char* kLibrarySearchPathHint = "LD_LIBRARY_PATH";
+
+void* open_library(const char* path) {
+  return dlopen(path, RTLD_NOW | RTLD_LOCAL);
+}
+
+std::string last_error() {
+  const char* err = dlerror();
+  return err ? err : "unknown error";
+}
 
 template <typename FuncPtr>
 FuncPtr load_symbol(void* handle, const char* name) {
@@ -36,26 +80,41 @@ FuncPtr load_symbol(void* handle, const char* name) {
   }
   return reinterpret_cast<FuncPtr>(sym);
 }
+#endif
 
 } // namespace
 
+void DlCloser::operator()(void* handle) {
+  if (!handle) {
+    return;
+  }
+#ifdef _WIN32
+  FreeLibrary(static_cast<HMODULE>(handle));
+#else
+  dlclose(handle);
+#endif
+}
+
 // Loading is attempted exactly once via std::call_once.  If the first attempt
-// fails (e.g. library not on LD_LIBRARY_PATH), subsequent calls return false
+// fails (e.g. library not on the search path), subsequent calls return false
 // without retrying.  Users must fix their environment and restart the process.
 bool OpenvinoBackend::ensure_loaded() const {
   std::call_once(load_flag_, [this]() {
     const char* lib_path = std::getenv("OPENVINO_LIB_PATH");
     const char* effective_path = lib_path ? lib_path : kDefaultLibName;
 
-    void* handle = dlopen(effective_path, RTLD_NOW | RTLD_LOCAL);
+    void* handle = open_library(effective_path);
     if (!handle) {
       ET_LOG(
           Error,
-          "OpenVINO runtime not found (dlopen failed: %s). "
-          "Ensure 'libopenvino_c.so' is on your library search path "
-          "(set OPENVINO_LIB_PATH or LD_LIBRARY_PATH), or install with: "
+          "OpenVINO runtime not found (loading '%s' failed: %s). "
+          "Ensure '%s' is on your library search path "
+          "(set OPENVINO_LIB_PATH or %s), or install with: "
           "pip install \"openvino>=2025.1.0,<2026.0.0\"",
-          dlerror());
+          effective_path,
+          last_error().c_str(),
+          kDefaultLibName,
+          kLibrarySearchPathHint);
       return;
     }
     lib_handle_.reset(handle);

extension/pybindings/portable_lib.py

@@ -52,28 +52,29 @@ class _LightweightExperimentalWarning(DeprecationWarning):
 
 
 # Auto-discover the OpenVINO C library path from the pip-installed openvino
-# package so the C++ backend's dlopen("libopenvino_c.so") works without the
-# user having to set LD_LIBRARY_PATH or OPENVINO_LIB_PATH manually.
+# package so the C++ backend can load it without the user having to set
+# OPENVINO_LIB_PATH or the platform's library search path manually.
 if not os.environ.get("OPENVINO_LIB_PATH"):
     try:
         import glob
         import importlib.util
 
+        _ov_c_lib = "openvino_c.dll" if sys.platform == "win32" else "libopenvino_c.so"
         spec = importlib.util.find_spec("openvino")
         if spec is not None and spec.submodule_search_locations:
             _ov_dir = spec.submodule_search_locations[0]
-            _ov_libs = sorted(
-                glob.glob(os.path.join(_ov_dir, "libs", "libopenvino_c.so*"))
-            )
+            _ov_libs = sorted(glob.glob(os.path.join(_ov_dir, "libs", _ov_c_lib + "*")))
             if _ov_libs:
                 os.environ["OPENVINO_LIB_PATH"] = _ov_libs[0]
             else:
                 logger.warning(
-                    "OpenVINO package found but libopenvino_c.so not in %s; "
+                    "OpenVINO package found but %s not in %s; "
                     "set OPENVINO_LIB_PATH manually if needed",
+                    _ov_c_lib,
                     os.path.join(_ov_dir, "libs"),
                 )
             del _ov_libs, _ov_dir, spec
+        del _ov_c_lib
     except Exception as e:
         logger.debug("OpenVINO auto-discovery failed: %s", e)
 

pyproject.toml

@@ -86,7 +86,7 @@ ethos_u = [
   "tosa-tools==2026.5.0",
 ]
 openvino = [
-  "openvino>=2025.1.0,<2026.0.0; platform_system == 'Linux'",
+  "openvino>=2025.1.0,<2026.0.0; platform_system == 'Linux' or (platform_system == 'Windows' and platform_machine == 'AMD64')",
 ]
 
 [project.urls]

setup.py

@@ -1411,6 +1411,12 @@ def _windows_import_libraries() -> List["BuiltFile"]:
             None,
             ["EXECUTORCH_BUILD_CUDA"],
         ),
+        (
+            "backends/openvino/",
+            "executorch_backend_openvino",
+            None,
+            ["EXECUTORCH_BUILD_OPENVINO"],
+        ),
     ]
     return [
         BuiltFile(
@@ -2814,11 +2820,12 @@ def run(self):  # noqa C901
                 f"-DQNN_SDK_ROOT={qnn_sdk_root}",
             ]
 
-        # Enable OpenVINO backend on Linux. The backend uses dlopen at
-        # runtime so it has no build-time SDK dependency.
+        # Enable the OpenVINO backend on Linux and Windows. The backend loads
+        # the OpenVINO runtime at run time, so it has no build-time SDK
+        # dependency.
         if (
             not minimal_build
-            and sys.platform == "linux"
+            and sys.platform in ("linux", "win32")
             and install_utils.is_cmake_option_on(
                 cmake_configuration_args,
                 "EXECUTORCH_BUILD_OPENVINO",

tools/cmake/executorch-wheel-config.cmake

@@ -89,8 +89,8 @@
 #                                CUDAToolkit_ROOT or CMake's standard toolkit
 #                                search. A program that calls the CUDA runtime
 #                                itself links CUDA::cudart.
-# executorch::backend_openvino   The OpenVINO delegate. Linux only. Opens the
-#                                OpenVINO runtime by name, which a C++ program
+# executorch::backend_openvino   The OpenVINO delegate. Linux and Windows. Opens
+#                                the OpenVINO runtime by name, which a C++ program
 #                                installs and points OPENVINO_LIB_PATH at.
 # executorch::threadpool         The shared thread pool.
 # executorch::etdump             The profiler. Not on Windows.