diff --git a/CMakeLists.txt b/CMakeLists.txt
index df54344dec9a..101c1507bd8c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -359,40 +359,32 @@ endif()
 if(USE_IOS_RPC)
   add_subdirectory(apps/ios_rpc)
 endif()
-# The parent owns installation of the core when it embeds the source build.
-if(NOT TVM_USE_INSTALLED_TIRX)
-  set(_core_install_targets tvm_tirx tvm_runtime tvm_runtime_static)
-  foreach(_backend cuda opencl vulkan metal rocm)
-    if(TARGET tvm_runtime_${_backend})
-      list(APPEND _core_install_targets tvm_runtime_${_backend})
-    endif()
-  endforeach()
-  install(TARGETS ${_core_install_targets}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR})
-  install(DIRECTORY tirx/include/ DESTINATION include FILES_MATCHING PATTERN "*.h")
-  install(FILES tirx/cmake/tvm_tirx-config.cmake tirx/python/tvm_tirx/config.py
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx")
-  install(DIRECTORY tirx/cmake/utils/
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx/utils" FILES_MATCHING PATTERN "Find*.cmake")
-endif()
 install(TARGETS tvm_compiler tvm_runtime_extra
-  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR})
-install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h")
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm
+  RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm)
+if(TVM_TIRX_USE_CUDA AND USE_CUTLASS)
+  install(TARGETS fpA_intB_gemm flash_attn
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm
+    RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm)
+endif()
+install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  COMPONENT tvm FILES_MATCHING PATTERN "*.h")
 # Parent minRPC compilation retains its own source and private header closure.
-install(DIRECTORY src/runtime/rpc/ DESTINATION src/runtime/rpc FILES_MATCHING PATTERN "*.h" PATTERN "*.cc")
-install(DIRECTORY src/support/ DESTINATION src/support FILES_MATCHING PATTERN "*.h")
-install(DIRECTORY src/runtime/extra/ DESTINATION src/runtime/extra FILES_MATCHING PATTERN "*.h" PATTERN "*.cuh")
+install(DIRECTORY src/runtime/rpc/ DESTINATION src/runtime/rpc
+  COMPONENT tvm FILES_MATCHING PATTERN "*.h" PATTERN "*.cc")
+install(DIRECTORY src/support/ DESTINATION src/support
+  COMPONENT tvm FILES_MATCHING PATTERN "*.h")
+install(DIRECTORY src/runtime/extra/ DESTINATION src/runtime/extra
+  COMPONENT tvm FILES_MATCHING PATTERN "*.h" PATTERN "*.cuh")
 if(TVM_BUILD_PYTHON_MODULE)
-  install(DIRECTORY web/ DESTINATION web)
-  install(DIRECTORY licenses/ DESTINATION licenses)
-  install(FILES LICENSE NOTICE DESTINATION .)
+  install(DIRECTORY web/ DESTINATION web COMPONENT tvm)
+  install(DIRECTORY licenses/ DESTINATION licenses COMPONENT tvm)
+  install(FILES LICENSE NOTICE DESTINATION . COMPONENT tvm)
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/cutlass/include")
     install(DIRECTORY 3rdparty/cutlass/include/ DESTINATION 3rdparty/cutlass/include
-      FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp")
+      COMPONENT tvm FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp")
   endif()
 endif()
 find_and_set_linker(${USE_ALTERNATIVE_LINKER})
diff --git a/cmake/modules/RuntimeExtra.cmake b/cmake/modules/RuntimeExtra.cmake
index b2d726cdb59f..e3057ebe0b5c 100644
--- a/cmake/modules/RuntimeExtra.cmake
+++ b/cmake/modules/RuntimeExtra.cmake
@@ -98,4 +98,5 @@ if(TVM_VISIBILITY_FLAG)
   set_property(TARGET tvm_runtime_extra APPEND PROPERTY LINK_OPTIONS "${TVM_VISIBILITY_FLAG}")
 endif()
 
-tvm_configure_target_library(tvm_runtime_extra RUNTIME_MODULE)
+# The root registers the package-owned installation alongside tvm_compiler.
+tvm_configure_target_library(tvm_runtime_extra)
diff --git a/cmake/utils/Library.cmake b/cmake/utils/Library.cmake
index 4b4d9f660590..f1ec6be620eb 100644
--- a/cmake/utils/Library.cmake
+++ b/cmake/utils/Library.cmake
@@ -78,9 +78,9 @@ function(tvm_configure_target_library target_name)
       RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
       ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
     )
-    install(TARGETS ${target_name} DESTINATION lib${LIB_SUFFIX})
+    install(TARGETS ${target_name} DESTINATION lib${LIB_SUFFIX} COMPONENT tvm)
     if(TVM_BUILD_PYTHON_MODULE)
-      install(TARGETS ${target_name} DESTINATION "lib")
+      install(TARGETS ${target_name} DESTINATION "lib" COMPONENT tvm)
     endif()
   endif()
 endfunction()
diff --git a/pyproject.toml b/pyproject.toml
index cff0e474b3fb..8305d6dd8827 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -89,6 +89,7 @@ wheel.py-api = "py3"
 build-dir = "build"
 
 # Wheel configuration
+install.components = ["tvm"]
 wheel.packages = ["python/tvm"]
 wheel.install-dir = "tvm"
 
diff --git a/tirx/CMakeLists.txt b/tirx/CMakeLists.txt
index 510d708c5bbe..c3397d5736c9 100644
--- a/tirx/CMakeLists.txt
+++ b/tirx/CMakeLists.txt
@@ -21,49 +21,61 @@ if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR AND NOT DEFINED CMAKE_EXPO
 endif()
 project(tvm_tirx LANGUAGES C CXX)
 
+# Declare native boolean switches and typed cache settings uniformly.
+function(tvm_tirx_option variable type default description)
+  if(type STREQUAL "BOOL")
+    option(${variable} "${description}" "${default}")
+  else()
+    set(${variable} "${default}" CACHE ${type} "${description}")
+  endif()
+endfunction()
+
 # ######### Common options ##########
 
 set(TVM_TIRX_VERSION "0.1.0a0")
 if(PROJECT_IS_TOP_LEVEL)
-  option(TVM_TIRX_BUILD_TESTS "Build C++ tests" OFF)
-  option(TVM_TIRX_BUILD_PYTHON_MODULE "Build the Python package with scikit-build-core" OFF)
+  tvm_tirx_option(TVM_TIRX_BUILD_TESTS BOOL OFF "Build C++ tests")
+  tvm_tirx_option(TVM_TIRX_BUILD_PYTHON_MODULE BOOL OFF "Build the Python package with scikit-build-core")
 endif()
-option(TVM_TIRX_USE_THREADS "Build with thread support" ON)
-option(TVM_TIRX_USE_CUSTOM_LOGGING "Use user-defined logging implementations" OFF)
-set(TVM_TIRX_USE_OPENMP OFF CACHE STRING "OpenMP thread pool implementation (OFF, gnu, intel)")
-set_property(CACHE TVM_TIRX_USE_OPENMP PROPERTY STRINGS OFF gnu intel)
+tvm_tirx_option(TVM_TIRX_USE_THREADS BOOL ON "Build with thread support")
+tvm_tirx_option(TVM_TIRX_USE_CUSTOM_LOGGING BOOL OFF "Use user-defined logging implementations")
 
 # ######### LLVM ##########
 
-set(TVM_TIRX_USE_LLVM OFF CACHE STRING "Build with LLVM (OFF, ON, or llvm-config command)")
+tvm_tirx_option(TVM_TIRX_USE_LLVM STRING OFF "Build with LLVM (OFF, ON, or llvm-config command)")
 
 # ######### Z3 ##########
 
-set(TVM_TIRX_USE_Z3 AUTO CACHE STRING "Build with Z3 SMT solver support (OFF, ON, AUTO)")
+tvm_tirx_option(TVM_TIRX_USE_Z3 STRING AUTO "Build with Z3 SMT solver support (OFF, ON, AUTO)")
 set_property(CACHE TVM_TIRX_USE_Z3 PROPERTY STRINGS OFF ON AUTO)
 
 # ######### CUDA ##########
 
-set(TVM_TIRX_USE_CUDA OFF CACHE STRING "Build with CUDA (OFF, ON, or SDK path)")
+tvm_tirx_option(TVM_TIRX_USE_CUDA STRING OFF "Build with CUDA (OFF, ON, or SDK path)")
 
 # ######### Other device runtimes ##########
 
 # OpenCL
-set(TVM_TIRX_USE_OPENCL OFF CACHE STRING "Build with OpenCL (OFF, ON, or SDK path)")
-option(TVM_TIRX_USE_OPENCL_ENABLE_HOST_PTR "Enable OpenCL memory object access to host" OFF)
-option(TVM_TIRX_USE_OPENCL_EXTN_QCOM "Enable Qualcomm OpenCL extensions" OFF)
+tvm_tirx_option(TVM_TIRX_USE_OPENCL STRING OFF "Build with OpenCL (OFF, ON, or SDK path)")
+tvm_tirx_option(TVM_TIRX_USE_OPENCL_ENABLE_HOST_PTR BOOL OFF "Enable OpenCL memory object access to host")
+tvm_tirx_option(TVM_TIRX_USE_OPENCL_EXTN_QCOM BOOL OFF "Enable Qualcomm OpenCL extensions")
 
 # Vulkan
-set(TVM_TIRX_USE_VULKAN OFF CACHE STRING "Build with Vulkan (OFF, ON, or SDK path)")
-set(TVM_TIRX_USE_KHRONOS_SPIRV OFF CACHE STRING "Use Khronos SPIR-V tools (OFF or install path)")
-option(TVM_TIRX_USE_SPIRV_KHR_INTEGER_DOT_PRODUCT "Enable SPIR-V integer dot product" OFF)
+tvm_tirx_option(TVM_TIRX_USE_VULKAN STRING OFF "Build with Vulkan (OFF, ON, or SDK path)")
+tvm_tirx_option(TVM_TIRX_USE_KHRONOS_SPIRV STRING OFF "Use Khronos SPIR-V tools (OFF or install path)")
+tvm_tirx_option(TVM_TIRX_USE_SPIRV_KHR_INTEGER_DOT_PRODUCT BOOL OFF "Enable SPIR-V integer dot product")
 
 # ROCm
-set(TVM_TIRX_ROCM_PATH /opt/rocm CACHE PATH "Default ROCm SDK location")
-set(TVM_TIRX_USE_ROCM OFF CACHE STRING "Build with ROCm (OFF, ON, or SDK path)")
+tvm_tirx_option(TVM_TIRX_ROCM_PATH PATH /opt/rocm "Default ROCm SDK location")
+tvm_tirx_option(TVM_TIRX_USE_ROCM STRING OFF "Build with ROCm (OFF, ON, or SDK path)")
 
 # Metal
-option(TVM_TIRX_USE_METAL "Build with Metal" OFF)
+tvm_tirx_option(TVM_TIRX_USE_METAL BOOL OFF "Build with Metal")
+
+# ######### OpenMP ##########
+
+tvm_tirx_option(TVM_TIRX_USE_OPENMP STRING OFF "OpenMP thread pool implementation (OFF, gnu, intel)")
+set_property(CACHE TVM_TIRX_USE_OPENMP PROPERTY STRINGS OFF gnu intel)
 
 # ######### Dependencies ##########
 
@@ -83,17 +95,8 @@ endif()
 
 # ######### TIRx build settings ##########
 
-# Apply these after the FFI subdirectory so its own settings remain independent.
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CUDA_STANDARD 20)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_CXX_VISIBILITY_PRESET hidden)
-set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
+include(GNUInstallDirs)
 if(PROJECT_IS_TOP_LEVEL)
-  include(GNUInstallDirs)
   if(TVM_TIRX_BUILD_PYTHON_MODULE)
     set(CMAKE_INSTALL_LIBDIR lib)
   endif()
@@ -135,7 +138,6 @@ target_link_libraries(tvm_tirx_header INTERFACE tvm_ffi::header)
 # ######### Sources and backends ##########
 
 set(TVM_LINKER_LIBS "")
-set(TVM_RUNTIME_LINKER_LIBS "${CMAKE_DL_LIBS}")
 set(TVM_RUNTIME_BACKEND_LIBS "")
 set(BUILD_FOR_ANDROID "${ANDROID}")
 # Source file lists
@@ -145,25 +147,7 @@ file(GLOB_RECURSE COMPILER_SRCS CONFIGURE_DEPENDS
     src/sym/*.cc
     src/tirx/*.cc
     src/support/*.cc
-    # Shared printer and TVMScript IR builder. Per-dialect printer/builder pieces
-    # live under src/<dialect>/script/. List shared files explicitly so a dialect
-    # implementation cannot be silently included through a recursive glob.
-    src/script/ir_builder/base.cc
-    src/script/ir_builder/ir.cc
-    src/script/ir_builder/frame.cc
-    src/script/printer/config.cc
-    src/script/printer/doc.cc
-    src/script/printer/doc_translator.cc
-    src/script/printer/ir/call.cc
-    src/script/printer/ir/utils.cc
-    src/script/printer/ir/ir.cc
-    src/script/printer/ir/misc.cc
-    src/script/printer/ir/prim_type.cc
-    src/script/printer/ir/prim_expr.cc
-    src/script/printer/ir/stmt.cc
-    src/script/printer/printer.cc
-    src/script/printer/doc_printer.cc
-    src/script/printer/script_printer.cc
+    src/script/*.cc
     )
 
 file(GLOB CODEGEN_SRCS CONFIGURE_DEPENDS
@@ -198,10 +182,6 @@ list(APPEND COMPILER_SRCS ${CODEGEN_SRCS})
 file(GLOB RUNTIME_SRCS CONFIGURE_DEPENDS
   src/runtime/*.cc
 )
-set(TVM_RUNTIME_EXT_OBJS "")
-
-# The core runtime's thread pool implementation supplies its link dependencies.
-include(cmake/modules/OpenMP.cmake)
 
 # ######### Targets: `tvm_runtime`, `tvm_runtime_static` ##########
 
@@ -211,10 +191,10 @@ if(MSVC)
   target_compile_definitions(tvm_runtime_objs PRIVATE TVM_RUNTIME_EXPORTS TVM_FFI_EXPORTS)
 endif()
 
-add_library(tvm_runtime SHARED $<TARGET_OBJECTS:tvm_runtime_objs> ${TVM_RUNTIME_EXT_OBJS})
+add_library(tvm_runtime SHARED $<TARGET_OBJECTS:tvm_runtime_objs>)
 add_library(tvm_runtime::shared ALIAS tvm_runtime)
 target_link_libraries(tvm_runtime PUBLIC tvm_tirx_header tvm_ffi::shared)
-add_library(tvm_runtime_static STATIC $<TARGET_OBJECTS:tvm_runtime_objs> ${TVM_RUNTIME_EXT_OBJS})
+add_library(tvm_runtime_static STATIC $<TARGET_OBJECTS:tvm_runtime_objs>)
 target_link_libraries(tvm_runtime_static PUBLIC tvm_tirx_header tvm_ffi::static)
 # Static consumers retain registration objects from both archives, with
 # tvm_ffi::static before tvm_runtime_static in their whole-archive link group.
@@ -223,19 +203,27 @@ if(MSVC)
     TVM_RUNTIME_DLL= TVM_RUNTIME_DLL_EXPORT= TVM_FFI_DLL= TVM_FFI_DLL_EXPORT=)
 endif()
 foreach(_target tvm_runtime tvm_runtime_static)
-  target_link_libraries(${_target} PRIVATE ${TVM_RUNTIME_LINKER_LIBS})
+  target_link_libraries(${_target} PRIVATE ${CMAKE_DL_LIBS})
   if(TVM_TIRX_USE_THREADS)
     target_link_libraries(${_target} PUBLIC Threads::Threads)
   endif()
 endforeach()
 
+# The core runtime owns the selected thread pool and its link dependencies.
+include(cmake/modules/OpenMP.cmake)
+
 # ######### Device runtimes and compiler backends ##########
 
 # The core runtime exists before device runtimes link to it. Compiler backend
 # contributions are collected before the compiler object target is created.
-foreach(_module CUDA OpenCL Vulkan Metal ROCM LLVM contrib/Z3 Git)
-  include(cmake/modules/${_module}.cmake)
-endforeach()
+include(cmake/modules/CUDA.cmake)
+include(cmake/modules/OpenCL.cmake)
+include(cmake/modules/Vulkan.cmake)
+include(cmake/modules/Metal.cmake)
+include(cmake/modules/ROCM.cmake)
+include(cmake/modules/LLVM.cmake)
+include(cmake/modules/contrib/Z3.cmake)
+include(cmake/modules/Git.cmake)
 # ######### Target: `tvm_tirx` ##########
 
 add_library(tvm_tirx_objs OBJECT ${COMPILER_SRCS})
@@ -249,7 +237,7 @@ endif()
 add_library(tvm_tirx SHARED $<TARGET_OBJECTS:tvm_tirx_objs>)
 add_library(tvm_tirx::shared ALIAS tvm_tirx)
 target_link_libraries(tvm_tirx PUBLIC tvm_runtime tvm_tirx_header)
-target_link_libraries(tvm_tirx PRIVATE ${TVM_LINKER_LIBS} ${TVM_RUNTIME_LINKER_LIBS})
+target_link_libraries(tvm_tirx PRIVATE ${TVM_LINKER_LIBS})
 
 # Avoid GNU ld relaxation of LLVM's GOT calls into incorrect direct calls.
 if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT "${TVM_TIRX_USE_LLVM}" MATCHES ${IS_FALSE_PATTERN})
@@ -261,6 +249,7 @@ include(cmake/modules/ClangFlags.cmake)
 # ######### Library configuration ##########
 
 foreach(_target tvm_runtime_objs tvm_tirx_objs tvm_runtime tvm_runtime_static tvm_tirx)
+  tvm_tirx_configure_target(${_target})
   tvm_ffi_add_prefix_map(${_target} "${CMAKE_CURRENT_SOURCE_DIR}")
 endforeach()
 foreach(_target IN LISTS TVM_RUNTIME_BACKEND_LIBS)
@@ -268,7 +257,6 @@ foreach(_target IN LISTS TVM_RUNTIME_BACKEND_LIBS)
   tvm_ffi_add_prefix_map(${_target} "${CMAKE_CURRENT_SOURCE_DIR}")
 endforeach()
 foreach(_target tvm_runtime tvm_tirx ${TVM_RUNTIME_BACKEND_LIBS})
-  tvm_tirx_configure_target(${_target})
   if(APPLE)
     target_link_options(${_target} PRIVATE "-Wl,-undefined,error")
   elseif(UNIX)
@@ -280,31 +268,40 @@ endforeach()
 
 # ######### Installation ##########
 
-if(PROJECT_IS_TOP_LEVEL)
-  file(GLOB_RECURSE _headers CONFIGURE_DEPENDS RELATIVE
-    "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/include/*.h")
-  foreach(_header IN LISTS _headers)
-    get_filename_component(_directory "${_header}" DIRECTORY)
-    install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/${_header}" DESTINATION "include/${_directory}")
+# Public headers
+file(GLOB_RECURSE _headers CONFIGURE_DEPENDS RELATIVE
+  "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/include/*.h")
+foreach(_header IN LISTS _headers)
+  get_filename_component(_directory "${_header}" DIRECTORY)
+  install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/${_header}"
+    DESTINATION "include/${_directory}" COMPONENT tvm_tirx)
+endforeach()
+
+# Libraries
+install(TARGETS tvm_tirx_header tvm_tirx tvm_runtime tvm_runtime_static
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx
+  RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx)
+
+# CMake package and dependency helpers
+install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/tvm_tirx-config.cmake"
+  "${CMAKE_CURRENT_SOURCE_DIR}/python/tvm_tirx/config.py"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx" COMPONENT tvm_tirx)
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/utils/"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx/utils"
+  COMPONENT tvm_tirx FILES_MATCHING PATTERN "Find*.cmake")
+
+# Python package artifacts and licenses
+if(TVM_TIRX_BUILD_PYTHON_MODULE)
+  foreach(_extra_lib IN LISTS TVM_TIRX_PACKAGE_EXTRA_LIBS)
+    if(NOT EXISTS "${_extra_lib}")
+      message(FATAL_ERROR "TVM_TIRX_PACKAGE_EXTRA_LIBS entry does not exist: ${_extra_lib}")
+    endif()
+    install(FILES "${_extra_lib}" DESTINATION lib COMPONENT tvm_tirx)
   endforeach()
-  install(TARGETS tvm_tirx_header tvm_tirx tvm_runtime tvm_runtime_static
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR})
-  install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/tvm_tirx-config.cmake"
-    "${CMAKE_CURRENT_SOURCE_DIR}/python/tvm_tirx/config.py" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx")
-  install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/utils/"
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/tvm_tirx/utils" FILES_MATCHING PATTERN "Find*.cmake")
-  if(TVM_TIRX_BUILD_PYTHON_MODULE)
-    foreach(_extra_lib IN LISTS TVM_TIRX_PACKAGE_EXTRA_LIBS)
-      if(NOT EXISTS "${_extra_lib}")
-        message(FATAL_ERROR "TVM_TIRX_PACKAGE_EXTRA_LIBS entry does not exist: ${_extra_lib}")
-      endif()
-      install(FILES "${_extra_lib}" DESTINATION lib)
-    endforeach()
-    install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/licenses/" DESTINATION licenses)
-    install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE" "${CMAKE_CURRENT_SOURCE_DIR}/NOTICE" DESTINATION .)
-  endif()
+  install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/licenses/" DESTINATION licenses COMPONENT tvm_tirx)
+  install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE" "${CMAKE_CURRENT_SOURCE_DIR}/NOTICE"
+    DESTINATION . COMPONENT tvm_tirx)
 endif()
 
 # ######### C++ tests ##########
@@ -316,10 +313,9 @@ endif()
 
 set(TVM_TIRX_CMAKE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 if(NOT PROJECT_IS_TOP_LEVEL)
-  foreach(_variable TVM_TIRX_VERSION TVM_TIRX_CMAKE_DIR TVM_TIRX_USE_CUDA TVM_TIRX_USE_ROCM)
-    set(${_variable} "${${_variable}}" PARENT_SCOPE)
-  endforeach()
-  set(TVM_TIRX_BUILD_FOR_ANDROID "${BUILD_FOR_ANDROID}" PARENT_SCOPE)
+  # The parent checks the core version and reuses its dependency finders.
+  set(TVM_TIRX_VERSION "${TVM_TIRX_VERSION}" PARENT_SCOPE)
+  set(TVM_TIRX_CMAKE_DIR "${TVM_TIRX_CMAKE_DIR}" PARENT_SCOPE)
   return()
 endif()
 
diff --git a/tirx/cmake/modules/CUDA.cmake b/tirx/cmake/modules/CUDA.cmake
index 9093c3fb33ca..68525b7d87eb 100644
--- a/tirx/cmake/modules/CUDA.cmake
+++ b/tirx/cmake/modules/CUDA.cmake
@@ -77,9 +77,7 @@ if(TVM_TIRX_USE_CUDA)
   target_compile_definitions(tvm_runtime_cuda_objs PRIVATE TVM_RUNTIME_EXPORTS TVM_FFI_EXPORTS)
   set_target_properties(tvm_runtime_cuda_objs PROPERTIES POSITION_INDEPENDENT_CODE ON)
   add_library(tvm_runtime_cuda SHARED $<TARGET_OBJECTS:tvm_runtime_cuda_objs>)
-  if(PROJECT_IS_TOP_LEVEL)
-    install(TARGETS tvm_runtime_cuda DESTINATION ${CMAKE_INSTALL_LIBDIR})
-  endif()
+  install(TARGETS tvm_runtime_cuda DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx)
   list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_cuda)
   target_link_libraries(tvm_runtime_cuda PUBLIC tvm_runtime PRIVATE ${CUDA_CUDART_LIBRARY} ${CUDA_CUDA_LIBRARY})
   tvm_tirx_configure_target(tvm_runtime_cuda_objs)
diff --git a/tirx/cmake/modules/Metal.cmake b/tirx/cmake/modules/Metal.cmake
index c733344c256f..53d62c832038 100644
--- a/tirx/cmake/modules/Metal.cmake
+++ b/tirx/cmake/modules/Metal.cmake
@@ -25,9 +25,7 @@ if(TVM_TIRX_USE_METAL)
   target_link_libraries(tvm_runtime_metal_objs PUBLIC tvm_tirx_header)
   set_target_properties(tvm_runtime_metal_objs PROPERTIES POSITION_INDEPENDENT_CODE ON)
   add_library(tvm_runtime_metal SHARED $<TARGET_OBJECTS:tvm_runtime_metal_objs>)
-  if(PROJECT_IS_TOP_LEVEL)
-    install(TARGETS tvm_runtime_metal DESTINATION ${CMAKE_INSTALL_LIBDIR})
-  endif()
+  install(TARGETS tvm_runtime_metal DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx)
   list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_metal)
   target_link_libraries(tvm_runtime_metal PUBLIC tvm_runtime PRIVATE ${METAL_LIB} ${FOUNDATION_LIB})
   tvm_tirx_configure_target(tvm_runtime_metal_objs)
diff --git a/tirx/cmake/modules/OpenCL.cmake b/tirx/cmake/modules/OpenCL.cmake
index 168977b508d9..a1d4aa3eb8e0 100644
--- a/tirx/cmake/modules/OpenCL.cmake
+++ b/tirx/cmake/modules/OpenCL.cmake
@@ -53,9 +53,7 @@ if(TVM_TIRX_USE_OPENCL)
   target_compile_definitions(tvm_runtime_opencl_objs PRIVATE "TVM_OPENCL_DLL=${_opencl_export}")
   set_target_properties(tvm_runtime_opencl_objs PROPERTIES POSITION_INDEPENDENT_CODE ON)
   add_library(tvm_runtime_opencl SHARED $<TARGET_OBJECTS:tvm_runtime_opencl_objs>)
-  if(PROJECT_IS_TOP_LEVEL)
-    install(TARGETS tvm_runtime_opencl DESTINATION ${CMAKE_INSTALL_LIBDIR})
-  endif()
+  install(TARGETS tvm_runtime_opencl DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx)
   list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_opencl)
   target_link_libraries(tvm_runtime_opencl PUBLIC tvm_runtime PRIVATE ${_opencl_libs})
   target_compile_definitions(tvm_runtime_opencl INTERFACE "TVM_OPENCL_DLL=${_opencl_import}")
diff --git a/tirx/cmake/modules/OpenMP.cmake b/tirx/cmake/modules/OpenMP.cmake
index 3eb4d315908b..a92376fb405c 100644
--- a/tirx/cmake/modules/OpenMP.cmake
+++ b/tirx/cmake/modules/OpenMP.cmake
@@ -15,34 +15,35 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# OpenMP Module
-if(TVM_TIRX_USE_OPENMP STREQUAL "gnu")
-  find_package(OpenMP)
-  if(OPENMP_FOUND)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
-    list(APPEND TVM_RUNTIME_LINKER_LIBS ${OpenMP_CXX_LIBRARIES})
-    add_definitions(-DTVM_THREADPOOL_USE_OPENMP=1)
-    message(STATUS "Build with OpenMP ${OpenMP_CXX_LIBRARIES}")
-  else()
-    add_definitions(-DTVM_THREADPOOL_USE_OPENMP=0)
-    message(WARNING "OpenMP cannot be found, use TVM threadpool instead.")
-  endif()
-elseif(TVM_TIRX_USE_OPENMP STREQUAL "intel")
-  find_package(OpenMP)
-  if(OPENMP_FOUND)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
-    if (MSVC)
-      find_library(OMP_LIBRARY NAMES libiomp5md)
+# OpenMP implements only the core runtime's thread pool.
+if(TVM_TIRX_USE_OPENMP STREQUAL "gnu" OR TVM_TIRX_USE_OPENMP STREQUAL "intel")
+  find_package(OpenMP COMPONENTS CXX)
+  if(OpenMP_CXX_FOUND)
+    target_compile_definitions(tvm_runtime_objs PRIVATE TVM_THREADPOOL_USE_OPENMP=1)
+    if(TVM_TIRX_USE_OPENMP STREQUAL "gnu")
+      target_link_libraries(tvm_runtime_objs PRIVATE OpenMP::OpenMP_CXX)
+      target_link_libraries(tvm_runtime PRIVATE OpenMP::OpenMP_CXX)
+      target_link_libraries(tvm_runtime_static PRIVATE OpenMP::OpenMP_CXX)
+      message(STATUS "Build with OpenMP ${OpenMP_CXX_LIBRARIES}")
     else()
-      find_library(OMP_LIBRARY NAMES iomp5)
+      # Keep Intel's runtime even when the compiler's default OpenMP runtime is GNU.
+      if(MSVC)
+        find_library(OMP_LIBRARY NAMES libiomp5md)
+      else()
+        find_library(OMP_LIBRARY NAMES iomp5)
+      endif()
+      separate_arguments(_openmp_flags NATIVE_COMMAND "${OpenMP_CXX_FLAGS}")
+      target_compile_options(tvm_runtime_objs PRIVATE
+        "$<$<COMPILE_LANGUAGE:CXX>:${_openmp_flags}>")
+      target_include_directories(tvm_runtime_objs PRIVATE ${OpenMP_CXX_INCLUDE_DIRS})
+      target_link_libraries(tvm_runtime PRIVATE ${OMP_LIBRARY})
+      target_link_libraries(tvm_runtime_static PRIVATE ${OMP_LIBRARY})
+      message(STATUS "Build with OpenMP ${OMP_LIBRARY}")
     endif()
-    list(APPEND TVM_RUNTIME_LINKER_LIBS ${OMP_LIBRARY})
-    add_definitions(-DTVM_THREADPOOL_USE_OPENMP=1)
-    message(STATUS "Build with OpenMP " ${OMP_LIBRARY})
   else()
-    add_definitions(-DTVM_THREADPOOL_USE_OPENMP=0)
+    target_compile_definitions(tvm_runtime_objs PRIVATE TVM_THREADPOOL_USE_OPENMP=0)
     message(WARNING "OpenMP cannot be found, use TVM threadpool instead.")
   endif()
 else()
-  add_definitions(-DTVM_THREADPOOL_USE_OPENMP=0)
+  target_compile_definitions(tvm_runtime_objs PRIVATE TVM_THREADPOOL_USE_OPENMP=0)
 endif()
diff --git a/tirx/cmake/modules/ROCM.cmake b/tirx/cmake/modules/ROCM.cmake
index a1be778dd81a..b51b1fbca65d 100644
--- a/tirx/cmake/modules/ROCM.cmake
+++ b/tirx/cmake/modules/ROCM.cmake
@@ -47,9 +47,7 @@ if(TVM_TIRX_USE_ROCM)
   target_link_libraries(tvm_runtime_rocm_objs PUBLIC tvm_tirx_header)
   set_target_properties(tvm_runtime_rocm_objs PROPERTIES POSITION_INDEPENDENT_CODE ON)
   add_library(tvm_runtime_rocm SHARED $<TARGET_OBJECTS:tvm_runtime_rocm_objs>)
-  if(PROJECT_IS_TOP_LEVEL)
-    install(TARGETS tvm_runtime_rocm DESTINATION ${CMAKE_INSTALL_LIBDIR})
-  endif()
+  install(TARGETS tvm_runtime_rocm DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx)
   list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_rocm)
   target_link_libraries(tvm_runtime_rocm PUBLIC tvm_runtime PRIVATE ${_rocm_libs})
   tvm_tirx_configure_target(tvm_runtime_rocm_objs)
diff --git a/tirx/cmake/modules/Vulkan.cmake b/tirx/cmake/modules/Vulkan.cmake
index de6bbfec333c..88025bf03dd8 100644
--- a/tirx/cmake/modules/Vulkan.cmake
+++ b/tirx/cmake/modules/Vulkan.cmake
@@ -49,9 +49,7 @@ if(TVM_TIRX_USE_VULKAN)
   target_link_libraries(tvm_runtime_vulkan_objs PUBLIC tvm_tirx_header)
   set_target_properties(tvm_runtime_vulkan_objs PROPERTIES POSITION_INDEPENDENT_CODE ON)
   add_library(tvm_runtime_vulkan SHARED $<TARGET_OBJECTS:tvm_runtime_vulkan_objs>)
-  if(PROJECT_IS_TOP_LEVEL)
-    install(TARGETS tvm_runtime_vulkan DESTINATION ${CMAKE_INSTALL_LIBDIR})
-  endif()
+  install(TARGETS tvm_runtime_vulkan DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT tvm_tirx)
   list(APPEND TVM_RUNTIME_BACKEND_LIBS tvm_runtime_vulkan)
   target_link_libraries(tvm_runtime_vulkan PUBLIC tvm_runtime PRIVATE ${Vulkan_LIBRARY})
   tvm_tirx_configure_target(tvm_runtime_vulkan_objs)
diff --git a/tirx/cmake/modules/contrib/Z3.cmake b/tirx/cmake/modules/contrib/Z3.cmake
index 4543e46909ec..37c37f74cb91 100644
--- a/tirx/cmake/modules/contrib/Z3.cmake
+++ b/tirx/cmake/modules/contrib/Z3.cmake
@@ -103,7 +103,7 @@ if(TVM_TIRX_BUILD_PYTHON_MODULE AND Z3_TARGET)
       "import importlib.util; from pathlib import Path; s=importlib.util.find_spec('mlc_z3_static'); print((Path(s.origin).parent / 'licenses/LICENSE-Z3.txt').as_posix() if s else '')"
       OUTPUT_VARIABLE _z3_license OUTPUT_STRIP_TRAILING_WHITESPACE)
     if(EXISTS "${_z3_license}")
-      install(FILES "${_z3_license}" DESTINATION licenses)
+      install(FILES "${_z3_license}" DESTINATION licenses COMPONENT tvm_tirx)
     endif()
   endif()
 endif()
diff --git a/tirx/cmake/utils/FindLLVM.cmake b/tirx/cmake/utils/FindLLVM.cmake
index fc6796a3619a..e249de8b011e 100644
--- a/tirx/cmake/utils/FindLLVM.cmake
+++ b/tirx/cmake/utils/FindLLVM.cmake
@@ -15,6 +15,29 @@
 # specific language governing permissions and limitations
 # under the License.
 
+# Isolate the signature probe from an embedding project's compilation defaults.
+function(_tvm_llvm_check_dibuilder)
+  include(CheckCXXSourceCompiles)
+  include(CMakePushCheckState)
+  cmake_push_check_state(RESET)
+  set(CMAKE_REQUIRED_INCLUDES ${LLVM_INCLUDE_DIRS})
+  # Probe the headers with the same standard as the TIRx compilation targets.
+  set(CMAKE_CXX_STANDARD 20)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+  check_cxx_source_compiles("
+    #include <llvm/IR/DIBuilder.h>
+    #include <llvm/IR/Instructions.h>
+    void f(llvm::DIBuilder* b, llvm::Value* v, llvm::DILocalVariable* var,
+           llvm::DIExpression* e, const llvm::DILocation* dl,
+           llvm::Instruction* i) {
+      b->insertDeclare(v, var, e, dl, llvm::BasicBlock::iterator(i));
+      b->insertDbgValueIntrinsic(v, var, e, dl, llvm::BasicBlock::iterator(i));
+    }
+  " TVM_LLVM_DIBUILDER_USES_ITERATOR)
+  cmake_pop_check_state()
+endfunction()
+
 #######################################################
 # Enhanced version of find llvm.
 #
@@ -233,31 +256,7 @@ macro(find_llvm use_llvm)
   # (upstream LLVM 20+) vs Instruction* (pre-LLVM 20 and ROCm-bundled LLVM 20,
   # which reports version 200 but retains the legacy Instruction* overload).
   if (${TVM_LLVM_VERSION} GREATER_EQUAL 200)
-    include(CheckCXXSourceCompiles)
-    include(CMakePushCheckState)
-    cmake_push_check_state(RESET)
-    set(CMAKE_REQUIRED_INCLUDES ${LLVM_INCLUDE_DIRS})
-    # Only force -std= when the outer project hasn't already selected a
-    # standard; signature-only probe does not need -fno-rtti. Use the
-    # compiler-appropriate form so the probe works under MSVC as well.
-    if(NOT CMAKE_CXX_STANDARD)
-      if(MSVC)
-        set(CMAKE_REQUIRED_FLAGS "/std:c++20")
-      else()
-        set(CMAKE_REQUIRED_FLAGS "-std=c++20")
-      endif()
-    endif()
-    check_cxx_source_compiles("
-      #include <llvm/IR/DIBuilder.h>
-      #include <llvm/IR/Instructions.h>
-      void f(llvm::DIBuilder* b, llvm::Value* v, llvm::DILocalVariable* var,
-             llvm::DIExpression* e, const llvm::DILocation* dl,
-             llvm::Instruction* i) {
-        b->insertDeclare(v, var, e, dl, llvm::BasicBlock::iterator(i));
-        b->insertDbgValueIntrinsic(v, var, e, dl, llvm::BasicBlock::iterator(i));
-      }
-    " TVM_LLVM_DIBUILDER_USES_ITERATOR)
-    cmake_pop_check_state()
+    _tvm_llvm_check_dibuilder()
     if(TVM_LLVM_DIBUILDER_USES_ITERATOR)
       add_definitions(-DTVM_LLVM_DIBUILDER_USES_ITERATOR=1)
       message(STATUS "LLVM DIBuilder insertion APIs use BasicBlock::iterator")
diff --git a/tirx/cmake/utils/Library.cmake b/tirx/cmake/utils/Library.cmake
index ee26447a800e..a37a8a97f937 100644
--- a/tirx/cmake/utils/Library.cmake
+++ b/tirx/cmake/utils/Library.cmake
@@ -15,8 +15,18 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# Keep shared libraries relocatable within their installation directory.
+# Apply compilation policy only to TIRx targets, including their object libraries.
 function(tvm_tirx_configure_target target)
+  set_property(TARGET ${target} PROPERTY POSITION_INDEPENDENT_CODE ON)
+  set_property(TARGET ${target} PROPERTY CXX_STANDARD 20)
+  set_property(TARGET ${target} PROPERTY CXX_STANDARD_REQUIRED ON)
+  set_property(TARGET ${target} PROPERTY CUDA_STANDARD 20)
+  set_property(TARGET ${target} PROPERTY CUDA_STANDARD_REQUIRED ON)
+  set_property(TARGET ${target} PROPERTY CXX_EXTENSIONS OFF)
+  set_property(TARGET ${target} PROPERTY CXX_VISIBILITY_PRESET hidden)
+  set_property(TARGET ${target} PROPERTY VISIBILITY_INLINES_HIDDEN ON)
+
+  # Keep shared libraries relocatable within their installation directory.
   if(APPLE)
     set_target_properties(${target} PROPERTIES BUILD_RPATH "@loader_path" INSTALL_RPATH "@loader_path")
   elseif(UNIX)
diff --git a/tirx/pyproject.toml b/tirx/pyproject.toml
index 5b232d849590..98afc68828b3 100644
--- a/tirx/pyproject.toml
+++ b/tirx/pyproject.toml
@@ -89,6 +89,7 @@ wheel.py-api = "py3"
 build-dir = "build"
 
 # Wheel configuration
+install.components = ["tvm_tirx"]
 wheel.packages = ["python/tvm_tirx"]
 wheel.install-dir = "tvm_tirx"