@@ -155,6 +155,12 @@
 # does: a second copy means two MLX runtimes in one process.
 _MLX_SYMBOLS = ("executorch::backends::mlx::mutable_state_note_handle",)
 _BUNDLED_MLX_SYMBOLS = ("mlx::core::allocator::free",)
+# A representative symbol from the Core ML delegate, exported from the shipped
+# library. get_registered_delegate() rather than the constructor, which demangles
+# to two entries (complete and base object), while this is a single definition.
+_COREML_SYMBOLS = (
+    "executorch::backends::coreml::CoreMLBackendDelegate::get_registered_delegate()",
+)
 
 # A representative symbol from the TorchAO kernels. These are Apple Silicon only, so
 # most wheels ship no such library and the row below is not required.
@@ -872,6 +878,11 @@ 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 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
+# quietly regress to folding it into the Python extension.
+_REQUIRED_ON_MACOS = "macos-only"
 # Narrower than the marker above on purpose. The Qualcomm SDK the delegate builds
 # against is published for Linux x86_64 only, so the aarch64 Linux wheels ship no such
 # library and demanding it there would fail a wheel that is correct. Reusing the
@@ -885,6 +896,8 @@ def _resolve_required(required):
         return bool(_wheel_cuda_train())
     if required == _REQUIRED_ON_LINUX:
         return sys.platform == "linux"
+    if required == _REQUIRED_ON_MACOS:
+        return sys.platform == "darwin"
     if required == _REQUIRED_ON_LINUX_X86:
         return sys.platform == "linux" and platform.machine() in ("x86_64", "amd64")
     return required
@@ -946,6 +959,15 @@ def _resolve_required(required):
         _library_file_name("libexecutorch_backend_xnnpack"),
         True,
     ),
+    # Required on macOS, where the delegate is built for every wheel, so a macOS
+    # wheel that folds it back into the Python extension fails here. Not built on
+    # any other platform, where the row resolves to not-required and skips.
+    (
+        "Core ML delegate",
+        _COREML_SYMBOLS,
+        _library_file_name("libexecutorch_backend_coreml"),
+        _REQUIRED_ON_MACOS,
+    ),
     # Not required: the delegate is built only on an Apple Silicon macOS wheel whose
     # build found the Metal compiler, so every other wheel legitimately ships no MLX
     # library and the row skips.
@@ -2337,6 +2359,7 @@ def test_shipped_library_names_are_expected() -> None:
         # dependency, so both have to ship and both are expected here.
         "libextension_cuda",
         "libexecutorch_backend_xnnpack",
+        "libexecutorch_backend_coreml",
         "libexecutorch_backend_mlx",
         "libexecutorch_backend_openvino",
         "libexecutorch_backend_qnn",
 
@@ -1419,7 +1419,11 @@ if(EXECUTORCH_BUILD_PYBIND)
   # Only the libraries that do not already retain themselves are named. A
   # delegate that calls executorch_target_link_options_shared_lib exports
   # --no-as-needed around its own file to every consumer, so the CUDA and
-  # OpenVINO backends are covered by that and are deliberately absent here.
+  # OpenVINO backends are covered by that and are deliberately absent here. That
+  # export is emitted only for NOT APPLE, so it does nothing for an Apple-only
+  # delegate like Core ML; those are covered instead by Mach-O, which keeps a
+  # named dylib's namespace-scope initializers without an --as-needed
+  # equivalent.
   foreach(_retained_component optimized_native_cpu_ops_lib xnnpack_backend
                               extension_threadpool etdump
   )
 
@@ -12,6 +12,15 @@ if(APPLE)
   find_library(SQLITE_LIBRARY sqlite3 REQUIRED)
 endif()
 
+# Signals to packaging whether the standalone shared delegate library was built.
+# Reset to OFF on every configure so a reused build directory that switches
+# platform or library type does not carry a stale value; the shared branch below
+# turns it on only when it actually produces the library.
+set(EXECUTORCH_COREML_DELEGATE_LIBRARY_BUILT
+    OFF
+    CACHE INTERNAL "The standalone Core ML delegate library was built"
+)
+
 if(EXECUTORCH_BUILD_DEVTOOLS)
   # protobuf requires frtti
   set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -frtti")
@@ -186,7 +195,17 @@ endif()
 # coremldelegate
 
 if(APPLE)
-  add_library(coremldelegate)
+  # Build the delegate as a shared library for the wheel so a C++ consumer can
+  # link it, and so the Python extension links it dynamically instead of
+  # absorbing its code. Keyed on EXECUTORCH_BUILD_SHARED rather than
+  # BUILD_SHARED_LIBS, the same way the other shipped delegates decide this, so
+  # the wheel controls it independently of the generic CMake switch.
+  if(EXECUTORCH_BUILD_SHARED)
+    set(_coreml_backend_library_type SHARED)
+  else()
+    set(_coreml_backend_library_type STATIC)
+  endif()
+  add_library(coremldelegate ${_coreml_backend_library_type})
   target_sources(coremldelegate PRIVATE ${KVSTORE_SOURCES} ${DELEGATE_SOURCES})
 
   target_include_directories(
@@ -237,11 +256,42 @@ if(APPLE)
   endif()
 
   target_link_libraries(
-    coremldelegate
-    PUBLIC coreml_util coreml_inmemoryfs
-    PRIVATE executorch_core ${ACCELERATE_FRAMEWORK} ${COREML_FRAMEWORK}
-            ${FOUNDATION_FRAMEWORK} ${SQLITE_LIBRARY}
+    coremldelegate PRIVATE ${ACCELERATE_FRAMEWORK} ${COREML_FRAMEWORK}
+                           ${FOUNDATION_FRAMEWORK} ${SQLITE_LIBRARY}
   )
+  if(EXECUTORCH_BUILD_SHARED)
+    set_target_properties(
+      coremldelegate PROPERTIES OUTPUT_NAME executorch_backend_coreml
+    )
+    executorch_target_soname_policy(coremldelegate)
+    # coreml_util and coreml_inmemoryfs are static archives this delegate owns,
+    # so bundle them inside this one shipped library instead of making every
+    # consumer supply them. A plain private link is enough, not whole-archive:
+    # the delegate references the helpers it uses, so ordinary resolution pulls
+    # exactly those objects. Neither helper registers anything from an
+    # unreferenced namespace-scope initializer, which is the only thing
+    # force_load would add here.
+    target_link_libraries(
+      coremldelegate PRIVATE coreml_util coreml_inmemoryfs executorch_shared
+    )
+    # Ships beside the runtime in the wheel's lib/ directory.
+    executorch_target_shipped_runtime_path(coremldelegate)
+    # A signal for packaging that the standalone delegate library exists. The
+    # EXECUTORCH_BUILD_COREML flag alone is not enough because it is also on for
+    # the Python extension on non-Apple platforms, where this shared library is
+    # not built, so keying the wheel's install on it would look for a file that
+    # was never produced.
+    set(EXECUTORCH_COREML_DELEGATE_LIBRARY_BUILT
+        ON
+        CACHE INTERNAL "The standalone Core ML delegate library was built"
+    )
+  else()
+    target_link_libraries(
+      coremldelegate
+      PUBLIC coreml_util coreml_inmemoryfs
+      PRIVATE executorch_core
+    )
+  endif()
 
   executorch_target_link_options_shared_lib(coremldelegate)
 
 
@@ -182,6 +182,7 @@ These are the components the package provides:
 | `backend_cuda` | The CUDA delegate | Linux |
 | `extension_cuda` | The CUDA stream extension | Linux |
 | `backend_openvino` | The OpenVINO delegate | Linux |
+| `backend_coreml` | The Core ML delegate, for Apple GPU and Neural Engine execution | macOS |
 | `backend_mlx` | The MLX delegate, for Apple GPU execution | macOS, Apple Silicon |
 
 To see what your own install offers, ask CMake:
@@ -190,18 +191,14 @@ To see what your own install offers, ask CMake:
 find_package(executorch REQUIRED)
 foreach(_component
         runtime kernels_optimized kernels_quantized kernels_torchao
-        backend_xnnpack backend_mlx backend_cuda extension_cuda
+        backend_xnnpack backend_coreml backend_mlx backend_cuda extension_cuda
         backend_openvino threadpool etdump)
   if(TARGET executorch::${_component})
     message(STATUS "have ${_component}")
   endif()
 endforeach()
 ```
 
-On macOS the Core ML delegate is registered inside the Python extension rather than shipped as a
-separate C++ library, so a C++ application there cannot link it as a component; use it from
-Python, or build from source if you need it in C++.
-
 Profiling a Core ML model records `DELEGATE_CALL`, which tells you how long the delegate ran in
 total. It does not record the individual operators inside the delegate, because that detail comes
 from the Core ML developer tools sources, and the wheel does not build them. An XNNPACK model
 
@@ -2170,6 +2170,8 @@ def run(self):  # noqa C901
             if cmake_cache.is_enabled("EXECUTORCH_BUILD_SHARED"):
                 cmake_build_args += ["--target", "executorch_shared"]
                 cmake_build_args += ["--target", "etdump"]
+                if cmake_cache.is_enabled("EXECUTORCH_COREML_DELEGATE_LIBRARY_BUILT"):
+                    cmake_build_args += ["--target", "coremldelegate"]
                 if cmake_cache.is_enabled(
                     "EXECUTORCH_BUILD_PTHREADPOOL"
                 ) and cmake_cache.is_enabled("EXECUTORCH_BUILD_CPUINFO"):
@@ -2402,6 +2404,20 @@ def run(self):  # noqa C901
                         "EXECUTORCH_BUILD_MLX",
                     ],
                 ),
+                # Install the Core ML delegate beside them, so a C++ consumer can
+                # link it out of the wheel rather than only reaching it from Python.
+                BuiltFile(
+                    src_dir="%CMAKE_CACHE_DIR%/backends/apple/coreml/",
+                    src_name=get_dynamic_lib_name("executorch_backend_coreml"),
+                    dst="executorch/lib/"
+                    + get_dynamic_lib_name("executorch_backend_coreml"),
+                    dependent_cmake_flags=[
+                        # Not EXECUTORCH_BUILD_COREML: that is also on for the Python
+                        # extension on non-Apple platforms, where this shared library
+                        # is not built. This flag is set only when it actually is.
+                        "EXECUTORCH_COREML_DELEGATE_LIBRARY_BUILT",
+                    ],
+                ),
                 # Install the prebuilt pybindings extension wrapper for the runtime,
                 # portable kernels, and a selection of backends. This lets users
                 # load and execute .pte files from python.
 
@@ -71,6 +71,7 @@
 #                                model. Not part of EXECUTORCH_LIBRARIES, see
 #                                below.
 # executorch::backend_xnnpack    The XNNPACK delegate.
+# executorch::backend_coreml     The Core ML delegate. macOS only.
 # executorch::backend_mlx        The MLX delegate. macOS on Apple Silicon only.
 #                                Its Metal kernel archive is published as
 #                                MLX_METALLIB_PATH, see below.
@@ -336,6 +337,7 @@ if(_executorch_runtime_library AND NOT _executorch_targets_supported)
     ITEMS libexecutorch_kernels_optimized
           libexecutorch_kernels_torchao
           libexecutorch_backend_xnnpack
+          libexecutorch_backend_coreml
           libexecutorch_backend_mlx
           libexecutorch_backend_cuda
           libexecutorch_extension_cuda
@@ -658,6 +660,8 @@ if(TARGET executorch::runtime AND TARGET executorch::threadpool)
 endif()
 
 _executorch_define_component(backend_xnnpack executorch_backend_xnnpack)
+# The Core ML delegate, present only in a wheel built on macOS.
+_executorch_define_component(backend_coreml executorch_backend_coreml)
 # The MLX delegate, present only in a wheel built on Apple Silicon with the
 # Metal compiler available.
 _executorch_define_component(backend_mlx executorch_backend_mlx)