diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4ffbc25e..709bc30f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,7 +41,15 @@ include_directories(${gflags_SOURCE_DIR}/include)
 # glog
 set(WITH_GFLAGS OFF CACHE BOOL "Disable glog finding system gflags" FORCE)
 set(WITH_GTEST OFF CACHE BOOL "Disable glog finding system gtest" FORCE)
-add_subdirectory(third_party/glog)
+get_property(_infinitrain_build_testing_was_cached CACHE BUILD_TESTING PROPERTY TYPE SET)
+block()
+  set(BUILD_TESTING OFF)
+  add_subdirectory(third_party/glog)
+endblock()
+if(NOT _infinitrain_build_testing_was_cached)
+  unset(BUILD_TESTING CACHE)
+endif()
+unset(_infinitrain_build_testing_was_cached)
 include_directories(${glog_SOURCE_DIR}/src)
 
 # eigen
@@ -131,19 +139,27 @@ endif()
 # ------------------------------------------------------------------------------
 
 add_library(infini_train STATIC ${SRC})
+add_library(InfiniTrain::infini_train ALIAS infini_train)
+add_library(InfiniTrain::cpu_kernels ALIAS infini_train_cpu_kernels)
+target_compile_features(infini_train PUBLIC cxx_std_20)
+target_include_directories(infini_train PUBLIC
+  "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>"
+)
 target_link_libraries(infini_train
   PUBLIC
     glog
     gflags
-    infini_train_cpu_kernels
+    Eigen3::Eigen
 )
+if(USE_OMP)
+  target_link_libraries(infini_train PUBLIC OpenMP::OpenMP_CXX)
+endif()
 
 if(USE_CUDA)
   # infini_train contains cuda runtime wrappers (*.cc) like cuda_blas_handle.cc/cuda_guard.cc
   # Those may need CUDA runtime/driver/cublas symbols at final link, so attach them here too.
   target_link_libraries(infini_train
     PUBLIC
-      infini_train_cuda_kernels
       CUDA::cudart
       CUDA::cublas
       CUDA::cuda_driver
@@ -157,37 +173,66 @@ if(USE_CUDA)
 endif()
 
 # ------------------------------------------------------------------------------
-# Helper: link libraries in a group to fix static lib one-pass resolution
-# (THIS is what fixes "undefined reference" from cuda_kernels -> core symbols)
+# Final executable link interface
 # ------------------------------------------------------------------------------
+
+set(_infini_train_executable_archives
+  infini_train
+  infini_train_cpu_kernels
+)
+if(USE_CUDA)
+  list(APPEND _infini_train_executable_archives infini_train_cuda_kernels)
+endif()
+set_property(GLOBAL PROPERTY INFINI_TRAIN_EXECUTABLE_ARCHIVES
+  ${_infini_train_executable_archives})
+
 function(link_infini_train_exe target_name)
-  if(USE_CUDA)
-    target_link_libraries(${target_name} PRIVATE
-      "-Wl,--start-group"
-      "-Wl,--whole-archive"
-        infini_train
-        infini_train_cpu_kernels
-        infini_train_cuda_kernels
-      "-Wl,--no-whole-archive"
-      "-Wl,--end-group"
-    )
+  cmake_parse_arguments(LINK "" "" "EXTRA_ARCHIVES" ${ARGN})
+  if(LINK_KEYWORDS_MISSING_VALUES)
+    message(FATAL_ERROR
+      "link_infini_train_exe: missing values for ${LINK_KEYWORDS_MISSING_VALUES}")
+  endif()
+  if(LINK_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR
+      "link_infini_train_exe: unexpected arguments: ${LINK_UNPARSED_ARGUMENTS}")
+  endif()
+
+  get_target_property(_target_type ${target_name} TYPE)
+  if(_target_type STREQUAL "INTERFACE_LIBRARY")
+    set(_link_scope INTERFACE)
+  elseif(_target_type STREQUAL "EXECUTABLE")
+    set(_link_scope PRIVATE)
   else()
-    target_link_libraries(${target_name} PRIVATE
-      "-Wl,--start-group"
-      "-Wl,--whole-archive"
-        infini_train
-        infini_train_cpu_kernels
-      "-Wl,--no-whole-archive"
-      "-Wl,--end-group"
-    )
+    message(FATAL_ERROR
+      "link_infini_train_exe requires an executable or interface library target")
   endif()
+
+  get_property(_framework_archives GLOBAL PROPERTY INFINI_TRAIN_EXECUTABLE_ARCHIVES)
+  target_link_libraries(${target_name} ${_link_scope}
+    "-Wl,--start-group"
+    "-Wl,--whole-archive"
+    ${_framework_archives}
+    ${LINK_EXTRA_ARCHIVES}
+    "-Wl,--no-whole-archive"
+    "-Wl,--end-group"
+  )
 endfunction()
 
+# Libraries and providers link InfiniTrain::infini_train for the core API. Final
+# executables must link InfiniTrain::infini_train_executable or a provider-specific
+# executable interface; linking only InfiniTrain::infini_train may discard static
+# registration objects.
+# EXTRA_ARCHIVES is reserved for archives that still rely on static initialization.
+add_library(infini_train_executable INTERFACE)
+link_infini_train_exe(infini_train_executable)
+add_library(InfiniTrain::infini_train_executable ALIAS infini_train_executable)
+unset(_infini_train_executable_archives)
 
 # ------------------------------------------------------------------------------
 # Examples
 # ------------------------------------------------------------------------------
 
+if(PROJECT_IS_TOP_LEVEL)
 add_executable(mnist
   example/mnist/main.cc
   example/mnist/dataset.cc
@@ -220,10 +265,13 @@ add_executable(llama3
   example/llama3/checkpoint_loader.cc
 )
 link_infini_train_exe(llama3)
+endif()
 
 # Tools
+if(PROJECT_IS_TOP_LEVEL)
 add_subdirectory(tools/infini_run)
 set_target_properties(infini_run PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+endif()
 
 # Tests
 if(BUILD_TEST)
diff --git a/cmake/test_macros.cmake b/cmake/test_macros.cmake
index 4b96db17..1d358ae6 100644
--- a/cmake/test_macros.cmake
+++ b/cmake/test_macros.cmake
@@ -5,7 +5,7 @@
 #
 # Usage:
 #   1. Include this file in tests/CMakeLists.txt
-#   2. Use infini_train_add_test macro to register tests
+#   2. Use infini_train_add_test to register tests
 #
 # Examples:
 #   infini_train_add_test(
@@ -23,20 +23,28 @@ include_guard(GLOBAL)
 include(GoogleTest)
 
 # -----------------------------------------------------------------------------
-# infini_train_add_test - Test registration macro
+# infini_train_add_test - Test registration function
 # -----------------------------------------------------------------------------
 # Features:
 #   1. Create executable target
 #   2. Configure compile options, link libraries, and include paths
-#   3. Use gtest_discover_tests to auto-discover CPU test cases
-#   4. Register CUDA tests at binary granularity with CTest GPU resources
-#   5. Set test labels
+#   3. Use gtest_discover_tests to auto-discover host test cases
+#   4. Register accelerator tests at binary granularity
+#   5. Set test labels and execution properties
 #
 # Arguments:
 #   SOURCES:    Source file list (required)
 #   LABELS:     Test labels, e.g. "cpu" "cuda" "distributed" (optional, default "cpu")
-#   TEST_FILTER:  gtest test filter pattern (optional)
-#   TEST_TIMEOUT: ctest timeout in seconds (optional, default 10)
+#   TEST_FILTER:       gtest test filter pattern (optional)
+#   TEST_TIMEOUT:      ctest timeout in seconds (optional, default 10)
+#   TEST_MAIN_SOURCE:  per-target main source (optional)
+#   TEST_MAIN_TARGET:  object-library main target (optional, defaults to test_main)
+#   RUNTIME_OUTPUT_DIRECTORY: executable output directory (optional)
+#   LINK_LIBRARIES:    additional link libraries (optional)
+#   COMPILE_DEFINITIONS: target compile definitions (optional)
+#   BINARY_REGISTRATION: register the binary as one CTest test (optional)
+#   SKIP_DEFAULT_FRAMEWORK_LINK: LINK_LIBRARIES supplies the full link closure
+#   RUN_SERIAL: do not run this CTest target concurrently (optional)
 #
 # Examples:
 #   # Single-label test (one liner)
@@ -46,19 +54,55 @@ include(GoogleTest)
 #   infini_train_add_test(test_example SOURCES test_example.cc LABELS cpu TEST_FILTER "-*CUDA*")
 #   infini_train_add_test(test_example_cuda SOURCES test_example.cc LABELS cuda TEST_FILTER "*CUDA*")
 # -----------------------------------------------------------------------------
-macro(infini_train_add_test)
-  cmake_parse_arguments(ARG "" "TEST_NAME;TEST_FILTER;TEST_TIMEOUT" "SOURCES;LABELS" ${ARGN})
+function(infini_train_add_test)
+  cmake_parse_arguments(ARG
+    "BINARY_REGISTRATION;RUN_SERIAL;SKIP_DEFAULT_FRAMEWORK_LINK"
+    "TEST_NAME;TEST_FILTER;TEST_TIMEOUT;TEST_MAIN_SOURCE;TEST_MAIN_TARGET;RUNTIME_OUTPUT_DIRECTORY"
+    "SOURCES;LABELS;LINK_LIBRARIES;COMPILE_DEFINITIONS"
+    ${ARGN}
+  )
+
+  if(ARG_KEYWORDS_MISSING_VALUES)
+    message(FATAL_ERROR
+      "infini_train_add_test: missing values for ${ARG_KEYWORDS_MISSING_VALUES}")
+  endif()
 
-  if(NOT ARG_TEST_NAME)
+  if(ARG_TEST_NAME AND ARG_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR
+      "infini_train_add_test: unexpected arguments: ${ARG_UNPARSED_ARGUMENTS}")
+  elseif(NOT ARG_TEST_NAME)
     set(ARG_TEST_NAME ${ARG_UNPARSED_ARGUMENTS})
   endif()
 
-  if(NOT ARG_SOURCES)
+  list(LENGTH ARG_TEST_NAME _test_name_count)
+  if(NOT _test_name_count EQUAL 1 OR NOT ARG_SOURCES)
     message(FATAL_ERROR "infini_train_add_test: TEST_NAME and SOURCES are required")
   endif()
+  if(ARG_TEST_MAIN_SOURCE AND ARG_TEST_MAIN_TARGET)
+    message(FATAL_ERROR
+      "infini_train_add_test: TEST_MAIN_SOURCE and TEST_MAIN_TARGET are mutually exclusive")
+  endif()
 
-  # 1. Create executable target
-  add_executable(${ARG_TEST_NAME} ${ARG_SOURCES} $<TARGET_OBJECTS:test_main>)
+  # 1. Create executable target.
+  if(ARG_TEST_MAIN_SOURCE)
+    add_executable(${ARG_TEST_NAME} ${ARG_SOURCES} ${ARG_TEST_MAIN_SOURCE})
+  elseif(ARG_TEST_MAIN_TARGET)
+    if(NOT TARGET ${ARG_TEST_MAIN_TARGET})
+      message(FATAL_ERROR
+        "infini_train_add_test: TEST_MAIN_TARGET '${ARG_TEST_MAIN_TARGET}' does not exist")
+    endif()
+    add_executable(${ARG_TEST_NAME} ${ARG_SOURCES} $<TARGET_OBJECTS:${ARG_TEST_MAIN_TARGET}>)
+  else()
+    if(NOT TARGET test_main)
+      message(FATAL_ERROR
+        "infini_train_add_test: default test_main target does not exist")
+    endif()
+    add_executable(${ARG_TEST_NAME} ${ARG_SOURCES} $<TARGET_OBJECTS:test_main>)
+  endif()
+  if(ARG_RUNTIME_OUTPUT_DIRECTORY)
+    set_target_properties(${ARG_TEST_NAME} PROPERTIES
+      RUNTIME_OUTPUT_DIRECTORY "${ARG_RUNTIME_OUTPUT_DIRECTORY}")
+  endif()
 
   # 2. Disable -Werror so tests can run under relaxed warning levels
   target_compile_options(${ARG_TEST_NAME} PRIVATE -Wno-error)
@@ -66,91 +110,371 @@ macro(infini_train_add_test)
   # 3. Link Google Test (uses custom main from test_main that initializes GlobalEnv)
   target_link_libraries(${ARG_TEST_NAME} PRIVATE GTest::gtest)
 
-  # 4. Add include paths
-  target_include_directories(${ARG_TEST_NAME} PRIVATE
-    ${glog_SOURCE_DIR}/src
-  )
-
-  # 5. Link project library (reuses framework linking strategy)
-  link_infini_train_exe(${ARG_TEST_NAME})
+  # 4. Link the framework. External backends may supply a complete executable
+  # link target that owns static archive retention and link ordering.
+  if(NOT ARG_SKIP_DEFAULT_FRAMEWORK_LINK)
+    link_infini_train_exe(${ARG_TEST_NAME})
+  endif()
+  if(ARG_LINK_LIBRARIES)
+    target_link_libraries(${ARG_TEST_NAME} PRIVATE ${ARG_LINK_LIBRARIES})
+  endif()
+  if(ARG_COMPILE_DEFINITIONS)
+    target_compile_definitions(${ARG_TEST_NAME} PRIVATE ${ARG_COMPILE_DEFINITIONS})
+  endif()
 
-  # 6. Register tests
+  # 5. Register tests
   set(labels "cpu")
   if(ARG_LABELS)
     set(labels "${ARG_LABELS}")
   endif()
 
   set(test_timeout 10)
-  if(ARG_TEST_TIMEOUT)
+  if(DEFINED ARG_TEST_TIMEOUT AND NOT ARG_TEST_TIMEOUT STREQUAL "")
     set(test_timeout ${ARG_TEST_TIMEOUT})
   endif()
 
-  list(FIND labels cuda _has_cuda_label)
-  if(NOT _has_cuda_label EQUAL -1)
-    set(_cuda_test_args)
+  # Hardware discovery would execute accelerator binaries during the build.
+  # Register them as one CTest entry and defer execution to ctest.
+  if(ARG_BINARY_REGISTRATION)
+    set(_binary_test_args)
     if(ARG_TEST_FILTER)
-      list(APPEND _cuda_test_args --gtest_filter=${ARG_TEST_FILTER})
+      list(APPEND _binary_test_args --gtest_filter=${ARG_TEST_FILTER})
     endif()
 
     add_test(
       NAME ${ARG_TEST_NAME}
-      COMMAND $<TARGET_FILE:${ARG_TEST_NAME}> ${_cuda_test_args}
+      COMMAND $<TARGET_FILE:${ARG_TEST_NAME}> ${_binary_test_args}
     )
     set_tests_properties(${ARG_TEST_NAME}
       PROPERTIES
         LABELS "${labels}"
         TIMEOUT ${test_timeout}
     )
+    if(ARG_RUN_SERIAL)
+      set_tests_properties(${ARG_TEST_NAME} PROPERTIES RUN_SERIAL TRUE)
+    endif()
   elseif(ARG_TEST_FILTER)
+    set(_discovered_test_properties LABELS "${labels}" TIMEOUT ${test_timeout})
+    if(ARG_RUN_SERIAL)
+      list(APPEND _discovered_test_properties RUN_SERIAL TRUE)
+    endif()
     gtest_discover_tests(${ARG_TEST_NAME}
       TEST_FILTER "${ARG_TEST_FILTER}"
       DISCOVERY_TIMEOUT 10
-      PROPERTIES LABELS "${labels}" TIMEOUT ${test_timeout}
+      PROPERTIES ${_discovered_test_properties}
     )
   else()
+    set(_discovered_test_properties LABELS "${labels}" TIMEOUT ${test_timeout})
+    if(ARG_RUN_SERIAL)
+      list(APPEND _discovered_test_properties RUN_SERIAL TRUE)
+    endif()
     gtest_discover_tests(${ARG_TEST_NAME}
-      PROPERTIES LABELS "${labels}" TIMEOUT ${test_timeout}
+      PROPERTIES ${_discovered_test_properties}
     )
   endif()
-endmacro()
+endfunction()
 
 # -----------------------------------------------------------------------------
-# infini_train_add_test_suite - Register cpu/cuda/distributed targets in one call
+# infini_train_add_test_suite - Declare a shared device-parameterized suite
 # -----------------------------------------------------------------------------
-# Calls infini_train_add_test three times (or fewer) with the correct
-# TEST_FILTER and LABELS derived from the label list.
+# Declaration is intentionally separate from device instantiation. This lets a
+# top-level InfiniTrain build create CPU/CUDA targets while an embedding
+# provider creates only its own PrivateUse1 targets from the same source list.
 #
 # Arguments:
-#   <name>   Base name; each target is named <name>_<label>
+#   <name>   Base name; each instantiated target is named <name>_<suffix>
 #   SOURCES  Source file list (required)
-#   LABELS   Subset of {cpu cuda} (optional, default: both)
+#   LABELS   Built-in devices from {cpu cuda} (optional, default: both)
 #   TEST_TIMEOUT ctest timeout in seconds (optional, default 10)
+#   EXCLUDE_PRIVATEUSE1 do not expose this suite to PrivateUse1 providers
 #
 # Examples:
 #   infini_train_add_test_suite(test_tensor SOURCES ${TENSOR_TEST_SOURCES})
 #   infini_train_add_test_suite(test_lora   SOURCES test_lora.cc LABELS cpu)
 # -----------------------------------------------------------------------------
-macro(infini_train_add_test_suite)
-  cmake_parse_arguments(SUITE "" "TEST_TIMEOUT" "SOURCES;LABELS" ${ARGN})
-  set(_suite_name ${SUITE_UNPARSED_ARGUMENTS})
+function(infini_train_add_test_suite suite_name)
+  cmake_parse_arguments(SUITE "EXCLUDE_PRIVATEUSE1" "TEST_TIMEOUT" "SOURCES;LABELS" ${ARGN})
+  if(SUITE_KEYWORDS_MISSING_VALUES)
+    message(FATAL_ERROR
+      "infini_train_add_test_suite: missing values for ${SUITE_KEYWORDS_MISSING_VALUES}")
+  endif()
+  if(SUITE_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR
+      "infini_train_add_test_suite: unexpected arguments: ${SUITE_UNPARSED_ARGUMENTS}")
+  endif()
+  if(NOT suite_name OR NOT SUITE_SOURCES)
+    message(FATAL_ERROR
+      "infini_train_add_test_suite: a suite name and SOURCES are required")
+  endif()
+
+  # Resolve paths at the declaration site because a provider may instantiate
+  # the suite from another directory. Generator expressions stay deferred.
+  set(_suite_sources)
+  foreach(_source IN LISTS SUITE_SOURCES)
+    if(IS_ABSOLUTE "${_source}" OR _source MATCHES "^\\$<")
+      list(APPEND _suite_sources "${_source}")
+    else()
+      list(APPEND _suite_sources "${CMAKE_CURRENT_SOURCE_DIR}/${_source}")
+    endif()
+  endforeach()
 
   if(NOT SUITE_LABELS)
     set(SUITE_LABELS cpu cuda)
   endif()
+  list(REMOVE_DUPLICATES SUITE_LABELS)
 
-  set(suite_test_timeout 10)
-  if(SUITE_TEST_TIMEOUT)
-    set(suite_test_timeout ${SUITE_TEST_TIMEOUT})
+  set(_suite_timeout 10)
+  if(DEFINED SUITE_TEST_TIMEOUT AND NOT SUITE_TEST_TIMEOUT STREQUAL "")
+    set(_suite_timeout ${SUITE_TEST_TIMEOUT})
   endif()
 
+  # Global properties carry suite metadata across directory scopes and make it
+  # visible to an embedding PrivateUse1 provider.
+  get_property(_registered_suites GLOBAL PROPERTY INFINI_TRAIN_TEST_SUITES)
+  if(suite_name IN_LIST _registered_suites)
+    message(FATAL_ERROR
+      "infini_train_add_test_suite: duplicate shared suite '${suite_name}'")
+  endif()
+  set_property(GLOBAL APPEND PROPERTY INFINI_TRAIN_TEST_SUITES "${suite_name}")
+  set_property(GLOBAL PROPERTY
+    "INFINI_TRAIN_TEST_SUITE_${suite_name}_SOURCES" "${_suite_sources}")
+  set_property(GLOBAL PROPERTY
+    "INFINI_TRAIN_TEST_SUITE_${suite_name}_TIMEOUT" "${_suite_timeout}")
+  set_property(GLOBAL PROPERTY
+    "INFINI_TRAIN_TEST_SUITE_${suite_name}_BINARY_DIR" "${CMAKE_CURRENT_BINARY_DIR}")
+
   foreach(_label IN LISTS SUITE_LABELS)
-    string(TOUPPER ${_label} _label_upper)
-    set(_filter "${_label_upper}/*")
-    infini_train_add_test(${_suite_name}_${_label}
-      SOURCES ${SUITE_SOURCES}
-      LABELS ${_label}
-      TEST_FILTER "${_filter}"
-      TEST_TIMEOUT ${suite_test_timeout}
+    if(_label STREQUAL "cpu")
+      set_property(GLOBAL APPEND PROPERTY INFINI_TRAIN_CPU_TEST_SUITES "${suite_name}")
+    elseif(_label STREQUAL "cuda")
+      set_property(GLOBAL APPEND PROPERTY INFINI_TRAIN_CUDA_TEST_SUITES "${suite_name}")
+    else()
+      message(FATAL_ERROR
+        "infini_train_add_test_suite: unsupported built-in label '${_label}'")
+    endif()
+  endforeach()
+
+  if(NOT SUITE_EXCLUDE_PRIVATEUSE1)
+    set_property(GLOBAL APPEND PROPERTY INFINI_TRAIN_PRIVATEUSE1_TEST_SUITES "${suite_name}")
+  endif()
+endfunction()
+
+# -----------------------------------------------------------------------------
+# _infini_train_instantiate_test_suites - Instantiate one device target per suite
+# -----------------------------------------------------------------------------
+function(_infini_train_instantiate_test_suites)
+  cmake_parse_arguments(INSTANCE
+    "ACCELERATOR;RUN_SERIAL;SKIP_DEFAULT_FRAMEWORK_LINK"
+    "SUITE_REGISTRY;TARGET_SUFFIX;GTEST_PREFIX;DEVICE_TYPE;DEVICE_INDEX;TEST_TIMEOUT;TEST_MAIN_TARGET"
+    "LABELS;LINK_LIBRARIES"
+    ${ARGN}
+  )
+
+  if(INSTANCE_KEYWORDS_MISSING_VALUES)
+    message(FATAL_ERROR
+      "_infini_train_instantiate_test_suites: missing values for ${INSTANCE_KEYWORDS_MISSING_VALUES}")
+  endif()
+  if(INSTANCE_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR
+      "_infini_train_instantiate_test_suites: unexpected arguments: ${INSTANCE_UNPARSED_ARGUMENTS}")
+  endif()
+  foreach(_required SUITE_REGISTRY TARGET_SUFFIX GTEST_PREFIX DEVICE_TYPE)
+    if(NOT DEFINED INSTANCE_${_required} OR INSTANCE_${_required} STREQUAL "")
+      message(FATAL_ERROR
+        "_infini_train_instantiate_test_suites: ${_required} is required")
+    endif()
+  endforeach()
+  if(NOT INSTANCE_LABELS)
+    message(FATAL_ERROR
+      "_infini_train_instantiate_test_suites: LABELS are required")
+  endif()
+
+  if(NOT DEFINED INSTANCE_DEVICE_INDEX OR INSTANCE_DEVICE_INDEX STREQUAL "")
+    set(INSTANCE_DEVICE_INDEX 0)
+  endif()
+
+  get_property(_registered_suites GLOBAL PROPERTY "${INSTANCE_SUITE_REGISTRY}")
+  if(NOT _registered_suites)
+    return()
+  endif()
+
+  # Artifact suffix, GTest prefix, and dispatcher device type are independent
+  # identities; for example, MACA uses maca, PRIVATEUSE1, and kPrivateUse1.
+  set(_device_compile_definitions
+    "INFINI_TRAIN_TEST_DEVICE_TYPE=::infini_train::Device::DeviceType::${INSTANCE_DEVICE_TYPE}"
+    "INFINI_TRAIN_TEST_DEVICE_INDEX=${INSTANCE_DEVICE_INDEX}"
+    "INFINI_TRAIN_TEST_DEVICE_PREFIX=${INSTANCE_GTEST_PREFIX}"
+  )
+
+  set(_device_test_options)
+  if(INSTANCE_ACCELERATOR)
+    list(APPEND _device_test_options BINARY_REGISTRATION)
+  endif()
+  if(INSTANCE_RUN_SERIAL)
+    list(APPEND _device_test_options RUN_SERIAL)
+  endif()
+  if(INSTANCE_SKIP_DEFAULT_FRAMEWORK_LINK)
+    list(APPEND _device_test_options SKIP_DEFAULT_FRAMEWORK_LINK)
+  endif()
+
+  set(_device_link_args)
+  if(INSTANCE_LINK_LIBRARIES)
+    list(APPEND _device_link_args LINK_LIBRARIES ${INSTANCE_LINK_LIBRARIES})
+  endif()
+  set(_device_main_args)
+  if(INSTANCE_TEST_MAIN_TARGET)
+    list(APPEND _device_main_args TEST_MAIN_TARGET ${INSTANCE_TEST_MAIN_TARGET})
+  endif()
+
+  foreach(_suite_name IN LISTS _registered_suites)
+    get_property(_suite_sources GLOBAL PROPERTY
+      "INFINI_TRAIN_TEST_SUITE_${_suite_name}_SOURCES")
+    get_property(_suite_timeout GLOBAL PROPERTY
+      "INFINI_TRAIN_TEST_SUITE_${_suite_name}_TIMEOUT")
+    get_property(_suite_binary_dir GLOBAL PROPERTY
+      "INFINI_TRAIN_TEST_SUITE_${_suite_name}_BINARY_DIR")
+    if(NOT _suite_sources OR NOT _suite_binary_dir)
+      message(FATAL_ERROR
+        "Shared test suite '${_suite_name}' has incomplete registration metadata")
+    endif()
+    if(DEFINED INSTANCE_TEST_TIMEOUT AND NOT INSTANCE_TEST_TIMEOUT STREQUAL "")
+      set(_suite_timeout ${INSTANCE_TEST_TIMEOUT})
+    endif()
+
+    set(_target_name "${_suite_name}_${INSTANCE_TARGET_SUFFIX}")
+    if(TARGET ${_target_name})
+      message(FATAL_ERROR "Test target '${_target_name}' already exists")
+    endif()
+
+    # Preserve the declaring suite's output layout even when an external
+    # provider creates the target from its own CMake directory.
+    infini_train_add_test(${_target_name}
+      SOURCES ${_suite_sources}
+      LABELS ${INSTANCE_LABELS}
+      TEST_TIMEOUT ${_suite_timeout}
+      RUNTIME_OUTPUT_DIRECTORY "${_suite_binary_dir}"
+      COMPILE_DEFINITIONS ${_device_compile_definitions}
+      ${_device_main_args}
+      ${_device_link_args}
+      ${_device_test_options}
     )
   endforeach()
-endmacro()
+endfunction()
+
+# -----------------------------------------------------------------------------
+# infini_train_add_privateuse1_test_suites - Instantiate a provider's suites
+# -----------------------------------------------------------------------------
+# A PrivateUse1 provider calls this after creating its final executable link
+# target. The provider name is used as the target/binary suffix and CTest label;
+# the GTest prefix and device type remain on the PrivateUse1 contract.
+#
+# Example:
+#   infini_train_add_privateuse1_test_suites(
+#     BACKEND_NAME ${INFINITRAIN_BACKEND}
+#     LINK_LIBRARIES PrivateUse1Backend::Executable
+#     BACKEND_HEADER "privateuse1_backend/backend.h"
+#     BACKEND_REGISTRAR privateuse1_backend::RegisterBackend
+#     RUN_SERIAL
+#   )
+# -----------------------------------------------------------------------------
+function(infini_train_add_privateuse1_test_suites)
+  cmake_parse_arguments(PRIVATEUSE1
+    "RUN_SERIAL"
+    "BACKEND_NAME;DEVICE_INDEX;TEST_TIMEOUT;BACKEND_HEADER;BACKEND_REGISTRAR"
+    "LINK_LIBRARIES"
+    ${ARGN}
+  )
+
+  if(PRIVATEUSE1_KEYWORDS_MISSING_VALUES)
+    message(FATAL_ERROR
+      "infini_train_add_privateuse1_test_suites: missing values for ${PRIVATEUSE1_KEYWORDS_MISSING_VALUES}")
+  endif()
+  if(PRIVATEUSE1_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR
+      "infini_train_add_privateuse1_test_suites: unexpected arguments: ${PRIVATEUSE1_UNPARSED_ARGUMENTS}")
+  endif()
+
+  if(USE_CUDA)
+    message(FATAL_ERROR
+      "infini_train_add_privateuse1_test_suites requires USE_CUDA=OFF")
+  endif()
+
+  foreach(_required BACKEND_NAME BACKEND_HEADER BACKEND_REGISTRAR)
+    if(NOT PRIVATEUSE1_${_required})
+      message(FATAL_ERROR
+        "infini_train_add_privateuse1_test_suites: ${_required} is required")
+    endif()
+  endforeach()
+  if(PRIVATEUSE1_BACKEND_NAME STREQUAL "cpu" OR
+     PRIVATEUSE1_BACKEND_NAME STREQUAL "cuda" OR
+     NOT PRIVATEUSE1_BACKEND_NAME MATCHES "^[a-z0-9_]+$")
+    message(FATAL_ERROR
+      "infini_train_add_privateuse1_test_suites: BACKEND_NAME must be non-reserved and contain only lowercase ASCII letters, digits, and underscores")
+  endif()
+  if(NOT PRIVATEUSE1_LINK_LIBRARIES)
+    message(FATAL_ERROR
+      "infini_train_add_privateuse1_test_suites: LINK_LIBRARIES must provide the complete executable link closure")
+  endif()
+  if(NOT DEFINED PRIVATEUSE1_DEVICE_INDEX OR PRIVATEUSE1_DEVICE_INDEX STREQUAL "")
+    set(PRIVATEUSE1_DEVICE_INDEX 0)
+  endif()
+
+  get_property(_registered_suites GLOBAL PROPERTY INFINI_TRAIN_PRIVATEUSE1_TEST_SUITES)
+  if(NOT _registered_suites)
+    message(FATAL_ERROR
+      "No shared PrivateUse1 test suites are registered. Configure InfiniTrain with BUILD_TEST=ON first.")
+  endif()
+
+  # All providers occupy the single kPrivateUse1 slot, so instantiate at most
+  # one provider in a build tree.
+  get_property(_privateuse1_registered GLOBAL PROPERTY INFINI_TRAIN_PRIVATEUSE1_TEST_PROVIDER_REGISTERED)
+  if(_privateuse1_registered)
+    message(FATAL_ERROR
+      "PrivateUse1 test suites have already been instantiated in this build")
+  endif()
+
+  set(_privateuse1_options SKIP_DEFAULT_FRAMEWORK_LINK ACCELERATOR)
+  if(PRIVATEUSE1_RUN_SERIAL)
+    list(APPEND _privateuse1_options RUN_SERIAL)
+  endif()
+
+  set(_privateuse1_timeout_args)
+  if(DEFINED PRIVATEUSE1_TEST_TIMEOUT AND NOT PRIVATEUSE1_TEST_TIMEOUT STREQUAL "")
+    list(APPEND _privateuse1_timeout_args TEST_TIMEOUT ${PRIVATEUSE1_TEST_TIMEOUT})
+  endif()
+
+  # Only the process entry point needs provider initialization. Compile it once
+  # and share the object across all suites for this provider.
+  set(_privateuse1_main_target
+    "infini_train_test_main_${PRIVATEUSE1_BACKEND_NAME}")
+  if(TARGET ${_privateuse1_main_target})
+    message(FATAL_ERROR
+      "Test main target '${_privateuse1_main_target}' already exists")
+  endif()
+  add_library(${_privateuse1_main_target} OBJECT
+    "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../tests/common/test_main.cc")
+  target_include_directories(${_privateuse1_main_target} PRIVATE
+    "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/..")
+  target_compile_definitions(${_privateuse1_main_target} PRIVATE
+    "INFINI_TRAIN_TEST_BACKEND_HEADER=\"${PRIVATEUSE1_BACKEND_HEADER}\""
+    "INFINI_TRAIN_TEST_BACKEND_REGISTRAR=${PRIVATEUSE1_BACKEND_REGISTRAR}"
+  )
+  target_link_libraries(${_privateuse1_main_target} PRIVATE
+    GTest::gtest
+    ${PRIVATEUSE1_LINK_LIBRARIES}
+  )
+
+  _infini_train_instantiate_test_suites(
+    SUITE_REGISTRY INFINI_TRAIN_PRIVATEUSE1_TEST_SUITES
+    TARGET_SUFFIX ${PRIVATEUSE1_BACKEND_NAME}
+    GTEST_PREFIX PRIVATEUSE1
+    DEVICE_TYPE kPrivateUse1
+    DEVICE_INDEX ${PRIVATEUSE1_DEVICE_INDEX}
+    LABELS ${PRIVATEUSE1_BACKEND_NAME} accelerator hardware
+    TEST_MAIN_TARGET ${_privateuse1_main_target}
+    LINK_LIBRARIES ${PRIVATEUSE1_LINK_LIBRARIES}
+    ${_privateuse1_timeout_args}
+    ${_privateuse1_options}
+  )
+  set_property(GLOBAL PROPERTY INFINI_TRAIN_PRIVATEUSE1_TEST_PROVIDER_REGISTERED TRUE)
+endfunction()
diff --git a/docs/test_infrastructure_design.md b/docs/test_infrastructure_design.md
index 857824e1..9c257491 100644
--- a/docs/test_infrastructure_design.md
+++ b/docs/test_infrastructure_design.md
@@ -9,7 +9,8 @@ tests/
 ├── CMakeLists.txt              # 顶层：include 宏 + add_subdirectory
 ├── common/
 │   ├── CMakeLists.txt          # 公共 test_main target
-│   └── test_utils.h            # C++ 基类、skip 宏、填充工具函数
+│   └── test_utils.h            # 设备测试基类与 skip 宏
+├── backend/                    # PrivateUse1 扩展契约测试
 ├── tensor/                     # Tensor 创建 / 拷贝 / 销毁 / 算子
 ├── optimizer/                  # Optimizer 创建 / step
 ├── autograd/                   # 各 autograd op 的 forward / backward
@@ -20,16 +21,18 @@ tests/
 └── checkpoint/                 # Checkpoint 序列化测试
 
 cmake/
-└── test_macros.cmake           # CMake 宏：infini_train_add_test / infini_train_add_test_suite
+└── test_macros.cmake           # CMake 测试目标与设备注入接口
 ```
 
 ### 核心设计：设备参数化
 
-测试不区分 CPU / CUDA 平台。一个测试定义通过 GTest 参数化自动在所有可用设备上运行：
+测试不区分具体平台。一个测试定义通过 GTest 参数化，由 CMake 为每个已配置设备生成独立测试目标：
 
-- `INFINI_TRAIN_REGISTER_TEST(TestName)` — 注册 CPU + CUDA 两个实例
+- `INFINI_TRAIN_REGISTER_TEST(TestName)` — 注册当前目标注入的设备实例
+- 内建目标注入 CPU，以及 `USE_CUDA=ON` 时的 CUDA
+- 外部仓库可注入 `kPrivateUse1` provider，无需修改测试源码
 
-无 GPU 时 CUDA 实例在注册阶段直接跳过（不会出现在测试列表里），并打印一条 `LOG(INFO)` 提示。
+每个测试二进制只包含一种设备实例。`USE_CUDA=OFF` 时不会创建 CUDA 目标，避免空测试被误报为成功。
 
 ### 基类层次
 
@@ -58,19 +61,24 @@ SKIP_CPU();
 // 只在 CPU 实例运行（用于硬编码 CPU 设备的测试）
 ONLY_CPU();
 
-// 只在 CUDA 实例运行（用于硬编码 CUDA 设备的测试）
-ONLY_CUDA();
-
 // 需要 ≥n 个加速器设备
 REQUIRE_MIN_DEVICES(n);
 ```
 
-### CMake 宏
+### CMake 接口
 
-`test_macros.cmake` 提供两个宏减少 CMakeLists 样板：
+`test_macros.cmake` 提供三类接口减少 CMakeLists 样板：
 
 - `infini_train_add_test(name SOURCES ... LABELS ...)` — 创建可执行文件、链接 GTest + 框架库、用 `gtest_discover_tests` 自动发现用例
-- `infini_train_add_test_suite(name SOURCES ... LABELS ...)` — 按 label（cpu/cuda）拆分为多个 CTest target，通过 `TEST_FILTER` 路由到对应的参数化前缀（`CPU/*`, `CUDA/*`）
+- `infini_train_add_test_suite(name SOURCES ... LABELS ...)` — 只登记公共 suite 及其 source/timeout 元数据
+- `infini_train_add_privateuse1_test_suites(...)` — 以统一的 PrivateUse1 accelerator 身份复用所有公共 suite
+
+所有 suite 登记完成后，InfiniTrain 统一实例化 CPU，以及 `USE_CUDA=ON` 时的
+CUDA。嵌入方可在此基础上追加 PrivateUse1 provider 目标。由于 PrivateUse1
+要求 `USE_CUDA=OFF`，Backends 测试构建包含 CPU 和 provider 变体，不包含 CUDA。
+
+不应由 PrivateUse1 复用的框架内部 suite，可在
+`infini_train_add_test_suite(... EXCLUDE_PRIVATEUSE1)` 中显式排除。
 
 ## 2. 构建与运行
 
@@ -96,7 +104,7 @@ ctest -L cuda --output-on-failure
 ./tests/tensor/test_tensor_cpu --gtest_filter="CPU/TensorCreateTest.*"
 ```
 
-无 GPU 机器上 `cmake -DBUILD_TEST=ON -DUSE_CUDA=OFF ..` 即可，CUDA 测试实例不会注册。
+无 GPU 机器上 `cmake -DBUILD_TEST=ON -DUSE_CUDA=OFF ..` 即可，CUDA 测试目标不会生成。
 
 ## 3. 新增测试
 
@@ -127,9 +135,9 @@ TEST_P(FooBasicTest, CreateTensor) {
     EXPECT_NE(tensor, nullptr);
 }
 
-TEST_P(FooBasicTest, CUDAOnlyFeature) {
+TEST_P(FooBasicTest, AcceleratorOnlyFeature) {
     SKIP_CPU();
-    // CUDA-specific logic ...
+    // Accelerator-specific logic ...
 }
 
 INFINI_TRAIN_REGISTER_TEST(FooBasicTest);
@@ -160,7 +168,9 @@ infini_train_add_test_suite(test_foo
 add_subdirectory(foo)
 ```
 
-**生成的 CTest target：** `test_foo_cpu`、`test_foo_cuda`，可通过 `ctest -L cpu` 等按标签筛选。
+InfiniTrain 会生成 `test_foo_cpu`；启用 CUDA 时还生成 `test_foo_cuda`。
+PrivateUse1 provider 再使用其 `BACKEND_NAME` 追加对应目标，例如下游传入
+`maca` 时生成 `test_foo_maca`，并可通过 `maca` 标签筛选。
 
 ### 3.2 在已有目录新增测试文件
 
@@ -181,82 +191,17 @@ add_subdirectory(foo)
 | `GetDevice()` | 返回当前参数化的 `Device`（基类方法） |
 | `SKIP_CPU()` | 跳过 CPU 实例 |
 | `ONLY_CPU()` | 只在 CPU 实例运行 |
-| `ONLY_CUDA()` | 只在 CUDA 实例运行 |
 | `REQUIRE_MIN_DEVICES(n)` | 加速器设备不足时 skip |
 
-## 4. 扩展新设备平台（以沐曦 MACA 为例）
-
-当前测试体系围绕 CPU / CUDA 两种设备参数化。如果需要支持新平台（以沐曦 MACA 为例），需要改动以下几处：
-
-### 4.1 框架层：注册新设备类型
-
-在 `infini_train/include/device.h` 的 `DeviceType` 枚举中新增：
-
-```cpp
-enum class DeviceType : int8_t {
-    kCPU = 0,
-    kCUDA = 1,
-    kMACA = 2,  // 新增
-};
-```
-
-### 4.2 测试工具层：`test_utils.h`
-
-1. 新增 MACA 头文件的编译期引入（和 CUDA 对称）：
-
-```cpp
-#if defined(USE_MACA)
-#include <maca_runtime_api.h>
-#endif
-```
-
-2. 新增 `ONLY_MACA()` 宏：
-
-```cpp
-#define ONLY_MACA() \
-    do { if (GetParam() != infini_train::Device::DeviceType::kMACA) { GTEST_SKIP() << "MACA-only test"; } } while (0)
-```
-
-如果希望有类似 `REQUIRE_MIN_DEVICES(n)` 但针对 MACA 的语义，可以按 `USE_CUDA` 分支的写法增加一个新的宏；同理 `USE_MACA` 不开时该宏直接 skip 即可。
-
-### 4.3 注册宏：新增 MACA 实例
-
-沿用 `USE_CUDA` 的做法，未开启编译开关时不注册对应实例：
-
-```cpp
-#if defined(USE_CUDA) && defined(USE_MACA)
-#define INFINI_TRAIN_REGISTER_TEST(TestName)                                    \
-    INSTANTIATE_TEST_SUITE_P(CPU, TestName,                                     \
-        ::testing::Values(infini_train::Device::DeviceType::kCPU));             \
-    INSTANTIATE_TEST_SUITE_P(CUDA, TestName,                                    \
-        ::testing::Values(infini_train::Device::DeviceType::kCUDA));            \
-    INSTANTIATE_TEST_SUITE_P(MACA, TestName,                                    \
-        ::testing::Values(infini_train::Device::DeviceType::kMACA))
-#elif defined(USE_CUDA)
-#define INFINI_TRAIN_REGISTER_TEST(TestName) /* CPU + CUDA, 同现状 */
-#elif defined(USE_MACA)
-#define INFINI_TRAIN_REGISTER_TEST(TestName)                                    \
-    INSTANTIATE_TEST_SUITE_P(CPU, TestName,                                     \
-        ::testing::Values(infini_train::Device::DeviceType::kCPU));             \
-    INSTANTIATE_TEST_SUITE_P(MACA, TestName,                                    \
-        ::testing::Values(infini_train::Device::DeviceType::kMACA))
-#else
-#define INFINI_TRAIN_REGISTER_TEST(TestName) /* 仅 CPU */
-#endif
-```
-
-运行时如果机器上没有对应设备（例如 `USE_MACA` 编译但无 MACA 硬件），让测试直接报错而不是静默跳过。
-
-### 4.4 CMake 层：`test_macros.cmake`
-
-将默认 label 列表从 `cpu cuda` 扩展为 `cpu cuda maca`
+## 4. 扩展新设备平台
 
-### 4.5 检查清单
+第三方设备统一占用 `DeviceType::kPrivateUse1`，不再向框架枚举和根 CMake
+增加厂商类型或 SDK 选项。厂商仓库负责注册 runtime、kernel 和可选 CCL，
+并通过 `infini_train_add_privateuse1_test_suites()` 追加公共 suite。该接口要求
+`USE_CUDA=OFF`，保留上游 CPU 测试，并使用 `BACKEND_NAME` 作为 target 后缀和
+CTest 标签；`DEVICE_INDEX` 默认为 `0`。调用方式见
+[测试使用指南](test_usage_guide.md#外部-privateuse1-后端复用测试)。
 
-| 步骤 | 文件 | 改动 |
-|------|------|------|
-| 1 | `device.h` | `DeviceType` 枚举新增 `kMACA` |
-| 2 | `test_utils.h` | 新增 `USE_MACA` 下的 `<maca_runtime_api.h>` 引入、`ONLY_MACA()` 宏 |
-| 3 | `test_utils.h` | `INFINI_TRAIN_REGISTER_TEST` 按 `USE_MACA` 条件新增 MACA 实例 |
-| 4 | `test_macros.cmake` | 将默认 label 列表扩展为 `cpu cuda maca` |
-| 5 | `CMakeLists.txt`（根） | 新增 `USE_MACA` option + MACA SDK 查找 + kernel 编译 |
+框架中的 `tests/backend/test_privateuse1_backend.cc` 使用不依赖硬件的 fake
+backend 验证扩展契约。它与真实 provider 使用不同测试进程，避免重复注册
+`kPrivateUse1` provider。
diff --git a/docs/test_usage_guide.md b/docs/test_usage_guide.md
index 248f1a3f..4267a351 100644
--- a/docs/test_usage_guide.md
+++ b/docs/test_usage_guide.md
@@ -67,8 +67,8 @@ INFINI_TRAIN_REGISTER_TEST(TensorCopyTest);
 
 注意事项：
 - 继承 `InfiniTrainTest`。
-- 使用 `TEST_P`，设备参数由框架自动注入。
-- 文件末尾调用 `INFINI_TRAIN_REGISTER_TEST`，自动实例化 CPU 和 CUDA 两个变体。
+- 使用 `TEST_P`，设备参数由测试目标注入。
+- 文件末尾调用 `INFINI_TRAIN_REGISTER_TEST`；CMake 为每个已配置设备生成独立变体。
 
 ### 2. 在 CMakeLists.txt 中注册
 
@@ -80,7 +80,12 @@ infini_train_add_test_suite(test_tensor_copy
 )
 ```
 
-这会生成两个 CTest 目标：`test_tensor_copy_cpu`（标签 `cpu`）和 `test_tensor_copy_cuda`（标签 `cuda`）。
+这一步只登记 suite。InfiniTrain 在所有登记完成后生成
+`test_tensor_copy_cpu`；`USE_CUDA=ON` 时还生成 `test_tensor_copy_cuda`。外部
+PrivateUse1 provider 可通过通用接口追加自己的目标。
+
+若某个 suite 只验证框架内部实现、不适用于 PrivateUse1，在注册时添加
+`EXCLUDE_PRIVATEUSE1`；否则默认进入 PrivateUse1 公共测试集合。
 
 ---
 
@@ -90,7 +95,9 @@ infini_train_add_test_suite(test_tensor_copy
 
 | 方法 | 说明 |
 |---|---|
-| `GetDevice()` | 返回当前测试实例的设备（CPU 或 CUDA） |
+| `GetDevice()` | 返回当前测试目标注入的设备 |
+| `DeviceCount()` | 通过 `DeviceGuardImpl` 查询当前后端设备数 |
+| `IsAccelerator()` | 当前设备是否为非 CPU 加速器 |
 | `tensor->Fill(value)` | 用常量填充张量所有元素（`Tensor` 内置方法） |
 
 张量创建直接使用 `std::make_shared<Tensor>(shape, dtype, GetDevice(), requires_grad)`，`requires_grad` 参数默认 `false`，需要梯度的测试传 `true` 即可。
@@ -102,18 +109,18 @@ infini_train_add_test_suite(test_tensor_copy
 在 `TEST_P` 体内使用，跳过不适用的场景：
 
 ```cpp
-TEST_P(MyTest, 仅CUDA) {
-    ONLY_CUDA();   // 在 CPU 上跳过
+TEST_P(MyTest, 仅加速器) {
+    SKIP_CPU();    // 在 CPU 上跳过
     // ...
 }
 
 TEST_P(MyTest, 仅CPU) {
-    ONLY_CPU();    // 在 CUDA 上跳过
+    ONLY_CPU();    // 在所有加速器上跳过
     // ...
 }
 
 TEST_P(MyTest, 需要多卡) {
-    REQUIRE_MIN_DEVICES(2);  // GPU 数量不足时跳过
+    REQUIRE_MIN_DEVICES(2);  // 当前后端设备数量不足时跳过
     // ...
 }
 ```
@@ -126,6 +133,31 @@ TEST_P(MyTest, 需要多卡) {
 2. 在其中创建 `CMakeLists.txt`，对每个测试文件调用 `infini_train_add_test_suite()`。
 3. 在 `tests/CMakeLists.txt` 中添加 `add_subdirectory(mymodule)`。
 
+## 外部 PrivateUse1 后端复用测试
+
+外部仓库以 `BUILD_TEST=ON`、`USE_CUDA=OFF` 添加 InfiniTrain，并在 provider
+链接 target 创建后调用：
+
+```cmake
+infini_train_add_privateuse1_test_suites(
+  BACKEND_NAME ${INFINITRAIN_BACKEND}
+  DEVICE_INDEX 0
+  LINK_LIBRARIES PrivateUse1Backend::Executable
+  BACKEND_HEADER "privateuse1_backend/backend.h"
+  BACKEND_REGISTRAR privateuse1_backend::RegisterBackend
+  RUN_SERIAL
+)
+```
+
+该调用为公共 suite 追加 `test_*_<BACKEND_NAME>` 目标；`DEVICE_INDEX` 默认为
+`0`。例如 `BACKEND_NAME=maca` 使用 `maca;accelerator;hardware` CTest 标签：
+
+```bash
+ctest -L maca --output-on-failure  # MACA
+ctest -L cpu --output-on-failure   # 上游 CPU
+ctest --output-on-failure          # 全部
+```
+
 ---
 
 ## Autograd 测试
diff --git a/example/gpt2/main.cc b/example/gpt2/main.cc
index cb8c2e26..90865aec 100644
--- a/example/gpt2/main.cc
+++ b/example/gpt2/main.cc
@@ -11,8 +11,15 @@
 #include "gflags/gflags.h"
 #include "glog/logging.h"
 
+// Out-of-tree builds inject the selected provider's declaration without adding
+// a vendor dependency to the upstream example.
+#ifdef INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_HEADER
+#include INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_HEADER
+#endif
+
 #include "infini_train/include/autocast.h"
 #include "infini_train/include/checkpoint/checkpoint.h"
+#include "infini_train/include/core/privateuse1_backend.h"
 #include "infini_train/include/core/runtime/device_guard.h"
 #include "infini_train/include/dataloader.h"
 #include "infini_train/include/device.h"
@@ -76,12 +83,11 @@ DEFINE_uint32(sample_every, 0, "how often to sample from the model?");
 // debugging
 DEFINE_bool(overfit_single_batch, true, "overfit just one batch of data");
 // memory management
-DEFINE_string(device, "cuda", "device type (cpu/cuda), useless if using parallel training mode");
+DEFINE_string(device, "cuda", "device type, useless if using parallel training mode");
 // parallel
-DEFINE_int32(
-    nthread_per_process, 1,
-    "Number of threads to use for each process. "
-    "When set > 1, enables data parallelism with device=cuda on the specified number of visible CUDA devices.");
+DEFINE_int32(nthread_per_process, 1,
+             "Number of threads to use for each process. "
+             "When set > 1, enables data parallelism on the specified accelerator devices.");
 DEFINE_uint32(tensor_parallel, 1, "Tensor Parallel world size");
 DEFINE_bool(sequence_parallel, false, "Whether to enable Sequence Parallel");
 DEFINE_uint32(pipeline_parallel, 1, "Pipeline Parallel world size, specified the number of PP stages.");
@@ -112,8 +118,6 @@ namespace {
 // validation
 const std::unordered_set<std::string> kSupportedModels
     = {"gpt2", "gpt2-medium", "gpt2-large", "gpt2-xl", "d12", "d24", "d36", "d48"};
-constexpr char kDeviceCPU[] = "cpu";
-constexpr char kDeviceCUDA[] = "cuda";
 constexpr char kDtypeFP32[] = "float32";
 constexpr char kDtypeBF16[] = "bfloat16";
 const std::unordered_set<std::string> kSupportedLRDecayStyles
@@ -127,11 +131,15 @@ const std::unordered_map<std::string, nn::TransformerConfig> kModelToConfigs = {
     {"d48", {.block_size = 1024, .vocab_size = 50257, .n_layer = 48, .n_head = 25, .n_embd = 1600}},
 };
 
+bool IsMacaBackend(Device::DeviceType device_type) {
+    return device_type == Device::DeviceType::kPrivateUse1 && core::HasPrivateUse1Backend()
+        && core::GetPrivateUse1BackendName() == "maca";
+}
+
 } // namespace
 
 DEFINE_validator(model, [](const char *, const std::string &value) { return kSupportedModels.contains(value); });
-DEFINE_validator(device,
-                 [](const char *, const std::string &value) { return value == kDeviceCPU || value == kDeviceCUDA; });
+DEFINE_validator(device, [](const char *, const std::string &value) { return Device::ParseType(value).has_value(); });
 DEFINE_validator(zero_stage, [](const char *, int32_t value) { return value >= 0 && value <= 3; });
 DEFINE_validator(lr_decay_style,
                  [](const char *, const std::string &value) { return kSupportedLRDecayStyles.contains(value); });
@@ -157,6 +165,7 @@ void Train(const nn::parallel::Rank &rank) {
 
     // select the device
     Device device;
+    const auto device_type = Device::ParseType(FLAGS_device).value();
 
     int ddp_world_size = global::GetDataParallelSize();
     int tp_world_size = global::GetTensorParallelSize();
@@ -181,7 +190,8 @@ void Train(const nn::parallel::Rank &rank) {
     const ProcessGroup *pp_pg = nullptr;
 
     if (rank.IsParallel()) {
-        device = Device(Device::DeviceType::kCUDA, global::GetDeviceIndex(rank.thread_rank()));
+        CHECK(device_type != Device::DeviceType::kCPU) << "Parallel training requires an accelerator backend";
+        device = Device(device_type, global::GetDeviceIndex(rank.thread_rank()));
         auto *pg_factory = ProcessGroupFactory::Instance(device.type());
 
         if (ddp_world_size > 1) {
@@ -206,7 +216,7 @@ void Train(const nn::parallel::Rank &rank) {
             nn::parallel::pp_rank = pp_rank;
         }
     } else {
-        device = FLAGS_device == kDeviceCPU ? Device() : Device(Device::DeviceType::kCUDA, 0);
+        device = Device(device_type, 0);
     }
 
     // calculate gradient accumulation from the desired total batch size and the current run configuration
@@ -564,11 +574,27 @@ void Train(const nn::parallel::Rank &rank) {
     Profiler::Instance().Report("gpt2.report", Profiler::SortBy::DeviceTimePercentage);
     Profiler::Instance().PrintRecords("gpt2.records.log");
 #endif
+
+    // FIXME(cx): MACA requires a step-boundary synchronization to flush pending mcFreeAsync operations.
+    // Replace this backend-name check with a provider step-completion hook.
+    // Releasing the pending operations ensures that ATU entries for
+    // activation/gradient tensors from this step are released before the next
+    // forward pass begins.  Without this, the ATU (address-translation unit)
+    // accumulates deferred frees across steps and becomes full, causing
+    // xnack(0x8) ATU-fault crashes in CastKernel and other large-tensor kernels.
+    if (IsMacaBackend(device.type())) {
+        impl->SynchronizeDevice(device);
+    }
 }
 
 int main(int argc, char *argv[]) {
-    gflags::ParseCommandLineFlags(&argc, &argv, true);
     google::InitGoogleLogging(argv[0]);
+    // Register provider metadata and implementations before gflags validates
+    // --device. The device runtime initializes lazily on first DeviceGuard use.
+#ifdef INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_REGISTRAR
+    INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_REGISTRAR();
+#endif
+    gflags::ParseCommandLineFlags(&argc, &argv, true);
 
     auto precision_config = utils::PrecisionCheckConfig::Parse(FLAGS_precision_check);
     nn::parallel::global::InitAllEnv(FLAGS_nthread_per_process, FLAGS_tensor_parallel, FLAGS_sequence_parallel,
@@ -592,8 +618,17 @@ int main(int argc, char *argv[]) {
         Train(rank);
     }
 
+    const bool bypass_maca_static_teardown
+        = IsMacaBackend(Device::ParseType(FLAGS_device).value()) && nn::parallel::global::GetWorldSize() > 1;
+
     gflags::ShutDownCommandLineFlags();
     google::ShutdownGoogleLogging();
 
+    // FIXME(cx): MACA parallel execution bypasses static destruction to avoid teardown failures.
+    // Replace this backend-name check with a provider shutdown hook.
+    if (bypass_maca_static_teardown) {
+        std::_Exit(0);
+    }
+
     return 0;
 }
diff --git a/example/llama3/main.cc b/example/llama3/main.cc
index c0a03958..b5992777 100644
--- a/example/llama3/main.cc
+++ b/example/llama3/main.cc
@@ -9,9 +9,16 @@
 #include "gflags/gflags.h"
 #include "glog/logging.h"
 
+// Out-of-tree builds inject the selected provider's declaration without adding
+// a vendor dependency to the upstream example.
+#ifdef INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_HEADER
+#include INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_HEADER
+#endif
+
 #include "infini_train/include/autocast.h"
 #include "infini_train/include/checkpoint/checkpoint.h"
 #include "infini_train/include/checkpoint/checkpoint_manager.h"
+#include "infini_train/include/core/privateuse1_backend.h"
 #include "infini_train/include/core/runtime/device_guard.h"
 #include "infini_train/include/dataloader.h"
 #include "infini_train/include/device.h"
@@ -75,12 +82,11 @@ DEFINE_uint32(sample_every, 0, "how often to sample from the model?");
 // debugging
 DEFINE_bool(overfit_single_batch, true, "overfit just one batch of data");
 // memory management
-DEFINE_string(device, "cuda", "device type (cpu/cuda), useless if using parallel training mode");
+DEFINE_string(device, "cuda", "device type, useless if using parallel training mode");
 // parallel
-DEFINE_int32(
-    nthread_per_process, 1,
-    "Number of threads to use for each process. "
-    "When set > 1, enables data parallelism with device=cuda on the specified number of visible CUDA devices.");
+DEFINE_int32(nthread_per_process, 1,
+             "Number of threads to use for each process. "
+             "When set > 1, enables data parallelism on the specified accelerator devices.");
 DEFINE_uint32(tensor_parallel, 1, "Tensor Parallel world size");
 DEFINE_bool(sequence_parallel, false, "Whether to enable Sequence Parallel");
 DEFINE_uint32(pipeline_parallel, 1, "Pipeline Parallel world size, specified the number of PP stages.");
@@ -110,17 +116,19 @@ using namespace infini_train;
 namespace {
 // validation
 const std::unordered_set<std::string> kSupportedModels = {"llama3"};
-constexpr char kDeviceCPU[] = "cpu";
-constexpr char kDeviceCUDA[] = "cuda";
 constexpr char kDtypeFP32[] = "float32";
 constexpr char kDtypeBF16[] = "bfloat16";
 const std::unordered_set<std::string> kSupportedLRDecayStyles
     = {"none", "constant", "linear", "cosine", "inverse-square-root"};
+
+bool IsMacaBackend(Device::DeviceType device_type) {
+    return device_type == Device::DeviceType::kPrivateUse1 && core::HasPrivateUse1Backend()
+        && core::GetPrivateUse1BackendName() == "maca";
+}
 } // namespace
 
 DEFINE_validator(model, [](const char *, const std::string &value) { return kSupportedModels.contains(value); });
-DEFINE_validator(device,
-                 [](const char *, const std::string &value) { return value == kDeviceCPU || value == kDeviceCUDA; });
+DEFINE_validator(device, [](const char *, const std::string &value) { return Device::ParseType(value).has_value(); });
 DEFINE_validator(zero_stage, [](const char *, int32_t value) { return value >= 0 && value <= 3; });
 DEFINE_validator(lr_decay_style,
                  [](const char *, const std::string &value) { return kSupportedLRDecayStyles.contains(value); });
@@ -146,6 +154,7 @@ void Train(const nn::parallel::Rank &rank) {
 
     // select the device
     Device device;
+    const auto device_type = Device::ParseType(FLAGS_device).value();
 
     int ddp_world_size = global::GetDataParallelSize();
     int tp_world_size = global::GetTensorParallelSize();
@@ -169,7 +178,8 @@ void Train(const nn::parallel::Rank &rank) {
     const ProcessGroup *pp_pg = nullptr;
 
     if (rank.IsParallel()) {
-        device = Device(Device::DeviceType::kCUDA, global::GetDeviceIndex(rank.thread_rank()));
+        CHECK(device_type != Device::DeviceType::kCPU) << "Parallel training requires an accelerator backend";
+        device = Device(device_type, global::GetDeviceIndex(rank.thread_rank()));
         auto *pg_factory = ProcessGroupFactory::Instance(device.type());
 
         if (ddp_world_size > 1) {
@@ -194,7 +204,7 @@ void Train(const nn::parallel::Rank &rank) {
             nn::parallel::pp_rank = pp_rank;
         }
     } else {
-        device = FLAGS_device == kDeviceCPU ? Device() : Device(Device::DeviceType::kCUDA, 0);
+        device = Device(device_type, 0);
     }
 
     // calculate gradient accumulation from the desired total batch size and the current run configuration
@@ -220,6 +230,13 @@ void Train(const nn::parallel::Rank &rank) {
 
     model->To(device);
 
+    // FIXME(cx): MACA requires model upload to finish before communication begins.
+    // Replace this backend-name check with a provider post-upload hook.
+    if (IsMacaBackend(device.type())) {
+        auto *upload_impl = core::GetDeviceGuardImpl(device.type());
+        upload_impl->SynchronizeDevice(device);
+    }
+
     utils::PrecisionChecker::BuildNameMap(model.get());
 
     // Apply LoRA using GetLoRAModel (in-place injection)
@@ -543,11 +560,27 @@ void Train(const nn::parallel::Rank &rank) {
     Profiler::Instance().Report("llama3.report", Profiler::SortBy::DeviceTimePercentage);
     Profiler::Instance().PrintRecords("llama3.records.log");
 #endif
+
+    // FIXME(cx): MACA requires a step-boundary synchronization to flush pending mcFreeAsync operations.
+    // Replace this backend-name check with a provider step-completion hook.
+    // Releasing the pending operations ensures that ATU entries for
+    // activation/gradient tensors from this step are released before the next
+    // forward pass begins.  Without this, the ATU (address-translation unit)
+    // accumulates deferred frees across steps and becomes full, causing
+    // xnack(0x8) ATU-fault crashes in CastKernel and other large-tensor kernels.
+    if (IsMacaBackend(device.type())) {
+        impl->SynchronizeDevice(device);
+    }
 }
 
 int main(int argc, char *argv[]) {
-    gflags::ParseCommandLineFlags(&argc, &argv, true);
     google::InitGoogleLogging(argv[0]);
+    // Register provider metadata and implementations before gflags validates
+    // --device. The device runtime initializes lazily on first DeviceGuard use.
+#ifdef INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_REGISTRAR
+    INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_REGISTRAR();
+#endif
+    gflags::ParseCommandLineFlags(&argc, &argv, true);
 
     auto precision_config = utils::PrecisionCheckConfig::Parse(FLAGS_precision_check);
     nn::parallel::global::InitAllEnv(FLAGS_nthread_per_process, FLAGS_tensor_parallel, FLAGS_sequence_parallel,
@@ -571,8 +604,17 @@ int main(int argc, char *argv[]) {
         Train(rank);
     }
 
+    const bool bypass_maca_static_teardown
+        = IsMacaBackend(Device::ParseType(FLAGS_device).value()) && nn::parallel::global::GetWorldSize() > 1;
+
     gflags::ShutDownCommandLineFlags();
     google::ShutdownGoogleLogging();
 
+    // FIXME(cx): MACA parallel execution bypasses static destruction to avoid teardown failures.
+    // Replace this backend-name check with a provider shutdown hook.
+    if (bypass_maca_static_teardown) {
+        std::_Exit(0);
+    }
+
     return 0;
 }
diff --git a/example/mixtral/main.cc b/example/mixtral/main.cc
index 553d7a62..8e6cc903 100644
--- a/example/mixtral/main.cc
+++ b/example/mixtral/main.cc
@@ -9,6 +9,12 @@
 #include "gflags/gflags.h"
 #include "glog/logging.h"
 
+// Out-of-tree builds inject the selected provider's declaration without adding
+// a vendor dependency to the upstream example.
+#ifdef INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_HEADER
+#include INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_HEADER
+#endif
+
 #include "infini_train/include/autocast.h"
 #include "infini_train/include/core/runtime/device_guard.h"
 #include "infini_train/include/dataloader.h"
@@ -34,7 +40,7 @@ DEFINE_uint32(num_iteration, 10, "number of training iterations");
 DEFINE_double(learning_rate, 1e-4, "Adam learning rate");
 DEFINE_string(llmc_filepath, "",
               "optional PyTorch-generated tiny Mixtral LLMC model file path to load before training");
-DEFINE_string(device, "cpu", "Training device: cpu or cuda.");
+DEFINE_string(device, "cpu", "Training device.");
 DEFINE_string(dtype, "float32", "precision used in training (float32/bfloat16)");
 DEFINE_uint32(log_interval, 1, "Print train loss every N steps. 0 disables step loss logging.");
 DEFINE_bool(print_timing, false, "Print training-loop elapsed time and token throughput.");
@@ -60,8 +66,13 @@ void ValidateRuntimeFlags(const infini_train::nn::TransformerConfig &config) {
 } // namespace
 
 int main(int argc, char *argv[]) {
-    gflags::ParseCommandLineFlags(&argc, &argv, true);
     google::InitGoogleLogging(argv[0]);
+    // Register provider metadata and implementations before gflags validates
+    // --device. The device runtime initializes lazily on first DeviceGuard use.
+#ifdef INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_REGISTRAR
+    INFINITRAIN_EXAMPLE_EXTERNAL_BACKEND_REGISTRAR();
+#endif
+    gflags::ParseCommandLineFlags(&argc, &argv, true);
 
     infini_train::nn::parallel::global::InitAllEnv(
         /*nthread_per_process=*/1,
@@ -80,13 +91,11 @@ int main(int argc, char *argv[]) {
     }
     ValidateRuntimeFlags(model_config);
 
-    Device train_device;
-    if (FLAGS_device == "cuda") {
-        train_device = Device(Device::DeviceType::kCUDA, 0);
+    const auto device_type = Device::ParseType(FLAGS_device);
+    CHECK(device_type.has_value()) << "Unsupported training device: " << FLAGS_device;
+    Device train_device(*device_type, 0);
+    if (!train_device.IsCPU()) {
         model->To(train_device);
-    } else {
-        CHECK_EQ(FLAGS_device, "cpu") << "Unsupported training device: " << FLAGS_device;
-        train_device = Device();
     }
 
     infini_train::DistributedDataLoader train_loader(
diff --git a/infini_train/include/autocast.h b/infini_train/include/autocast.h
index 0ce83e98..201a0347 100644
--- a/infini_train/include/autocast.h
+++ b/infini_train/include/autocast.h
@@ -1,9 +1,11 @@
 #pragma once
 
+#include <array>
 #include <string_view>
 #include <unordered_map>
 
 #include "infini_train/include/common/common.h"
+#include "infini_train/include/core/privateuse1_backend.h"
 #include "infini_train/include/datatype.h"
 #include "infini_train/include/device.h"
 #include "infini_train/include/tensor.h"
@@ -70,11 +72,19 @@ inline const std::unordered_map<std::string_view, CastPolicy> kOpCastPolicyMap =
     {"Layernorm", CastPolicy::kFP32},
 };
 
-// Default autocast data types for each device type
-inline constexpr std::array<DataType, static_cast<size_t>(Device::DeviceType::kCount)> kDeviceDefaultDtype = {
-    DataType::kBFLOAT16, // CPU
-    DataType::kFLOAT16,  // CUDA.
-};
+inline DataType GetDefaultAutocastDtype(Device::DeviceType device_type) {
+    if (device_type == Device::DeviceType::kPrivateUse1) {
+        return core::GetPrivateUse1BackendDefaultAutocastDtype();
+    }
+
+    static constexpr std::array kDeviceDefaultDtype = {
+        DataType::kBFLOAT16, // CPU
+        DataType::kFLOAT16,  // CUDA
+    };
+    const auto index = static_cast<size_t>(device_type);
+    CHECK_LT(index, kDeviceDefaultDtype.size()) << "Invalid device type for autocast";
+    return kDeviceDefaultDtype[index];
+}
 
 // Thread-local context to track autocast state
 struct AutocastContext {
@@ -160,8 +170,7 @@ class AutocastGuard {
         tls_autocast_context.autocast_dtype = autocast_dtype;
     }
 
-    AutocastGuard(Device::DeviceType device_type)
-        : AutocastGuard(device_type, kDeviceDefaultDtype[static_cast<size_t>(device_type)]) {}
+    AutocastGuard(Device::DeviceType device_type) : AutocastGuard(device_type, GetDefaultAutocastDtype(device_type)) {}
 
     // Disable autocast (restore previous state)
     ~AutocastGuard() { tls_autocast_context = saved_context_; }
diff --git a/infini_train/include/core/ccl/ccl.h b/infini_train/include/core/ccl/ccl.h
index 626cb078..899a12fc 100644
--- a/infini_train/include/core/ccl/ccl.h
+++ b/infini_train/include/core/ccl/ccl.h
@@ -6,6 +6,7 @@
 #include <string>
 #include <unordered_map>
 
+#include "infini_train/include/common/common.h"
 #include "infini_train/include/core/ccl/ccl_common.h"
 #include "infini_train/include/datatype.h"
 #include "infini_train/include/device.h"
@@ -79,6 +80,8 @@ class CclImplRegistry {
 
     void Register(Device::DeviceType type, std::unique_ptr<CclImpl> impl);
 
+    bool Has(Device::DeviceType type) const;
+
     CclImpl *Get(Device::DeviceType type) const;
 
 private:
@@ -94,7 +97,7 @@ CclImpl *GetCclImpl(Device::DeviceType type);
 } // namespace infini_train::core
 
 #define INFINI_TRAIN_REGISTER_CCL_IMPL(device_type, class_impl)                                                        \
-    static const bool __infini_train_ccl_registered##__COUNTER__ = []() {                                              \
+    [[maybe_unused]] static const bool CAT(infini_train_ccl_registered_, __COUNTER__) = []() {                         \
         infini_train::core::CclImplRegistry::Instance().Register(device_type, std::make_unique<class_impl>());         \
         return true;                                                                                                   \
     }();
diff --git a/infini_train/include/core/privateuse1_backend.h b/infini_train/include/core/privateuse1_backend.h
new file mode 100644
index 00000000..772dc950
--- /dev/null
+++ b/infini_train/include/core/privateuse1_backend.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <optional>
+#include <string>
+
+#include "infini_train/include/datatype.h"
+
+namespace infini_train::core {
+
+// A PrivateUse1 provider must expose an explicitly referenced, idempotent registration entry point
+// (conventionally RegisterBackend) and call it before parsing or using the provider device. Registration must not
+// rely solely on file-scope static initialization because an unreferenced static archive member may be discarded.
+using PrivateUse1RegistrationCallback = void (*)();
+
+struct PrivateUse1BackendRegistration {
+    std::string name;
+    // Required at registration; optional representation allows omission to be diagnosed.
+    std::optional<DataType> default_autocast_dtype;
+    PrivateUse1RegistrationCallback register_runtime = nullptr;
+    PrivateUse1RegistrationCallback register_kernels = nullptr;
+    PrivateUse1RegistrationCallback register_ccl = nullptr;
+};
+
+void RegisterPrivateUse1Backend(const PrivateUse1BackendRegistration &registration);
+
+bool HasPrivateUse1Backend();
+
+std::string GetPrivateUse1BackendName();
+
+DataType GetPrivateUse1BackendDefaultAutocastDtype();
+
+} // namespace infini_train::core
diff --git a/infini_train/include/core/runtime/device_guard.h b/infini_train/include/core/runtime/device_guard.h
index dc56fc6f..6590b141 100644
--- a/infini_train/include/core/runtime/device_guard.h
+++ b/infini_train/include/core/runtime/device_guard.h
@@ -4,6 +4,7 @@
 #include <memory>
 #include <unordered_map>
 
+#include "infini_train/include/common/common.h"
 #include "infini_train/include/core/runtime/runtime_common.h"
 #include "infini_train/include/device.h"
 
@@ -62,6 +63,10 @@ class DeviceGuardImpl {
 
     virtual ~DeviceGuardImpl() = default;
 
+    // Performs runtime initialization on first backend use. Implementations
+    // that need initialization should make this method idempotent.
+    virtual void Initialize();
+
     // ----------------------------------------------------------------------
     // Device management
     // ----------------------------------------------------------------------
@@ -202,6 +207,8 @@ class DeviceGuardImplRegistry {
 
     void Register(Device::DeviceType type, std::unique_ptr<DeviceGuardImpl> impl);
 
+    bool Has(Device::DeviceType type) const;
+
     DeviceGuardImpl *Get(Device::DeviceType type) const;
 
 private:
@@ -227,7 +234,7 @@ DeviceGuardImpl *GetDeviceGuardImpl(Device::DeviceType type);
 //   INFINI_TRAIN_REGISTER_DEVICE_GUARD_IMPL(Device::DeviceType::kCUDA, CudaGuardImpl)
 //
 #define INFINI_TRAIN_REGISTER_DEVICE_GUARD_IMPL(device_type, class_impl)                                               \
-    static const bool __infini_train_device_guard_registered##__COUNTER__ = []() {                                     \
+    [[maybe_unused]] static const bool CAT(infini_train_device_guard_registered_, __COUNTER__) = []() {                \
         infini_train::core::DeviceGuardImplRegistry::Instance().Register(device_type, std::make_unique<class_impl>()); \
         return true;                                                                                                   \
     }();
diff --git a/infini_train/include/device.h b/infini_train/include/device.h
index 28db395f..001f41ee 100644
--- a/infini_train/include/device.h
+++ b/infini_train/include/device.h
@@ -1,8 +1,10 @@
 #pragma once
 
 #include <cstdint>
+#include <optional>
 #include <ostream>
 #include <string>
+#include <string_view>
 
 #include "infini_train/include/nn/parallel/rank.h"
 
@@ -13,7 +15,8 @@ class Device {
     enum class DeviceType : int8_t {
         kCPU = 0,
         kCUDA = 1,
-        kCount = 2,
+        kPrivateUse1 = 2,
+        kCount = 3,
         kInvalid = -1,
     };
 
@@ -30,6 +33,9 @@ class Device {
 
     bool IsCPU() const;
     bool IsCUDA() const;
+    bool IsPrivateUse1() const;
+
+    static std::optional<DeviceType> ParseType(std::string_view name);
 
     std::string ToString() const;
 
diff --git a/infini_train/include/dispatcher.h b/infini_train/include/dispatcher.h
index 2c390ec8..6aa7e6e0 100644
--- a/infini_train/include/dispatcher.h
+++ b/infini_train/include/dispatcher.h
@@ -1,11 +1,13 @@
 #pragma once
 
 #include <map>
+#include <string>
 #include <type_traits>
 #include <utility>
 
 #include "glog/logging.h"
 
+#include "infini_train/include/common/common.h"
 #include "infini_train/include/device.h"
 #ifdef PROFILE_MODE
 #include "infini_train/include/profiler.h"
@@ -55,6 +57,8 @@ class Dispatcher {
         return instance;
     }
 
+    bool HasKernel(const KeyT &key) const { return key_to_kernel_map_.contains(key); }
+
     const KernelFunction &GetKernel(KeyT key) const {
         CHECK(key_to_kernel_map_.contains(key))
             << "Kernel not found: " << key.second << " on device: " << static_cast<int>(key.first);
@@ -85,7 +89,8 @@ class Dispatcher {
 } // namespace infini_train
 
 #define REGISTER_KERNEL(device, kernel_name, kernel_func)                                                              \
-    static const bool _##kernel_name##_registered##__COUNTER__ = []() {                                                \
-        infini_train::Dispatcher::Instance().Register({device, #kernel_name}, kernel_func);                            \
-        return true;                                                                                                   \
-    }();
+    [[maybe_unused]] static const bool CAT(infini_train_kernel_, CAT(kernel_name, CAT(_registered_, __COUNTER__)))     \
+        = []() {                                                                                                       \
+              infini_train::Dispatcher::Instance().Register({device, #kernel_name}, kernel_func);                      \
+              return true;                                                                                             \
+          }();
diff --git a/infini_train/src/core/ccl/ccl.cc b/infini_train/src/core/ccl/ccl.cc
index 92c14cc6..1bddee0e 100644
--- a/infini_train/src/core/ccl/ccl.cc
+++ b/infini_train/src/core/ccl/ccl.cc
@@ -85,6 +85,8 @@ void CclImplRegistry::Register(Device::DeviceType type, std::unique_ptr<CclImpl>
     impls_[type] = std::move(impl);
 }
 
+bool CclImplRegistry::Has(Device::DeviceType type) const { return impls_.contains(type); }
+
 CclImpl *CclImplRegistry::Get(Device::DeviceType type) const {
     auto it = impls_.find(type);
     if (it == impls_.end()) {
diff --git a/infini_train/src/core/privateuse1_backend.cc b/infini_train/src/core/privateuse1_backend.cc
new file mode 100644
index 00000000..d31e1c4d
--- /dev/null
+++ b/infini_train/src/core/privateuse1_backend.cc
@@ -0,0 +1,112 @@
+#include "infini_train/include/core/privateuse1_backend.h"
+
+#include <algorithm>
+#include <array>
+#include <mutex>
+#include <string_view>
+
+#include "glog/logging.h"
+
+#include "infini_train/include/core/ccl/ccl.h"
+#include "infini_train/include/core/runtime/device_guard.h"
+#include "infini_train/include/dispatcher.h"
+
+namespace infini_train::core {
+namespace {
+
+struct PrivateUse1BackendState {
+    enum class Status {
+        kUnregistered,
+        kRegistering,
+        kRegistered,
+    };
+
+    Status status = Status::kUnregistered;
+    std::string name;
+    std::optional<DataType> default_autocast_dtype;
+};
+
+PrivateUse1BackendState g_backend_state;
+std::mutex g_backend_mutex;
+
+constexpr std::array<std::string_view, 4> kRequiredKernels = {
+    "Cast",
+    "Fill",
+    "NoOpForward",
+    "NoOpBackward",
+};
+
+bool IsValidBackendName(std::string_view name) {
+    return !name.empty() && name != "cpu" && name != "cuda"
+        && std::all_of(name.begin(), name.end(),
+                       [](unsigned char c) { return (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_'; });
+}
+
+} // namespace
+
+void RegisterPrivateUse1Backend(const PrivateUse1BackendRegistration &registration) {
+    CHECK(IsValidBackendName(registration.name))
+        << "PrivateUse1 backend name must be non-reserved and contain only lowercase ASCII letters, digits, and "
+           "underscores";
+    CHECK(registration.default_autocast_dtype.has_value())
+        << "PrivateUse1 backend must declare a default autocast dtype";
+    CHECK(*registration.default_autocast_dtype == DataType::kFLOAT16
+          || *registration.default_autocast_dtype == DataType::kBFLOAT16)
+        << "PrivateUse1 default autocast dtype must be float16 or bfloat16";
+    CHECK(registration.register_runtime != nullptr) << "PrivateUse1 backend must register a runtime";
+    CHECK(registration.register_kernels != nullptr) << "PrivateUse1 backend must register kernels";
+
+    {
+        std::lock_guard<std::mutex> lock(g_backend_mutex);
+        CHECK(g_backend_state.status == PrivateUse1BackendState::Status::kUnregistered)
+            << "PrivateUse1 backend is already registered or registration is in progress as " << g_backend_state.name;
+        g_backend_state.status = PrivateUse1BackendState::Status::kRegistering;
+        g_backend_state.name = registration.name;
+        g_backend_state.default_autocast_dtype = registration.default_autocast_dtype;
+    }
+
+    // Backend callbacks may query the provider metadata, so they must run
+    // outside g_backend_mutex.
+    registration.register_runtime();
+    CHECK(DeviceGuardImplRegistry::Instance().Has(Device::DeviceType::kPrivateUse1))
+        << "PrivateUse1 runtime callback did not register DeviceGuardImpl";
+
+    if (registration.register_ccl != nullptr) {
+        registration.register_ccl();
+        CHECK(CclImplRegistry::Instance().Has(Device::DeviceType::kPrivateUse1))
+            << "PrivateUse1 CCL callback did not register CclImpl";
+    }
+
+    registration.register_kernels();
+    for (const auto kernel : kRequiredKernels) {
+        CHECK(Dispatcher::Instance().HasKernel({Device::DeviceType::kPrivateUse1, std::string(kernel)}))
+            << "PrivateUse1 backend is missing required kernel " << kernel;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(g_backend_mutex);
+        CHECK(g_backend_state.status == PrivateUse1BackendState::Status::kRegistering);
+        g_backend_state.status = PrivateUse1BackendState::Status::kRegistered;
+    }
+}
+
+bool HasPrivateUse1Backend() {
+    std::lock_guard<std::mutex> lock(g_backend_mutex);
+    return g_backend_state.status == PrivateUse1BackendState::Status::kRegistered;
+}
+
+std::string GetPrivateUse1BackendName() {
+    std::lock_guard<std::mutex> lock(g_backend_mutex);
+    return g_backend_state.status == PrivateUse1BackendState::Status::kUnregistered ? "privateuse1"
+                                                                                    : g_backend_state.name;
+}
+
+DataType GetPrivateUse1BackendDefaultAutocastDtype() {
+    std::lock_guard<std::mutex> lock(g_backend_mutex);
+    CHECK(g_backend_state.status != PrivateUse1BackendState::Status::kUnregistered)
+        << "PrivateUse1 backend is not registered";
+    CHECK(g_backend_state.default_autocast_dtype.has_value()) << "PrivateUse1 backend has no default autocast dtype";
+    return *g_backend_state.default_autocast_dtype;
+}
+
+} // namespace infini_train::core
diff --git a/infini_train/src/core/runtime/device_guard.cc b/infini_train/src/core/runtime/device_guard.cc
index d57b0d7c..d35dc74f 100644
--- a/infini_train/src/core/runtime/device_guard.cc
+++ b/infini_train/src/core/runtime/device_guard.cc
@@ -11,6 +11,8 @@
 namespace infini_train::core {
 
 // DeviceGuardImpl (base fallback: FATAL only)
+void DeviceGuardImpl::Initialize() {}
+
 void DeviceGuardImpl::SetDevice(Device) const { LOG(FATAL) << "DeviceGuardImpl::SetDevice is not implemented."; }
 
 int DeviceGuardImpl::DeviceCount() const {
@@ -143,18 +145,11 @@ void DeviceGuardImplRegistry::Register(Device::DeviceType type, std::unique_ptr<
         LOG(FATAL) << std::format("DeviceGuardImpl for type {} already registered", static_cast<int>(type));
     }
 
-    if (!impls_.empty()) {
-        for (auto &kv : impls_) {
-            if (kv.first != Device::DeviceType::kCPU) {
-                LOG(FATAL) << std::format("Only CPU and one GPU backend allowed. Already have GPU={}, new={} rejected.",
-                                          static_cast<int>(kv.first), static_cast<int>(type));
-            }
-        }
-    }
-
     impls_[type] = std::move(impl);
 }
 
+bool DeviceGuardImplRegistry::Has(Device::DeviceType type) const { return impls_.contains(type); }
+
 DeviceGuardImpl *DeviceGuardImplRegistry::Get(Device::DeviceType type) const {
     auto it = impls_.find(type);
     if (it == impls_.end()) {
@@ -163,6 +158,10 @@ DeviceGuardImpl *DeviceGuardImplRegistry::Get(Device::DeviceType type) const {
     return it->second.get();
 }
 
-DeviceGuardImpl *GetDeviceGuardImpl(Device::DeviceType type) { return DeviceGuardImplRegistry::Instance().Get(type); }
+DeviceGuardImpl *GetDeviceGuardImpl(Device::DeviceType type) {
+    auto *impl = DeviceGuardImplRegistry::Instance().Get(type);
+    impl->Initialize();
+    return impl;
+}
 
 } // namespace infini_train::core
diff --git a/infini_train/src/device.cc b/infini_train/src/device.cc
index 98021db5..d41f8539 100644
--- a/infini_train/src/device.cc
+++ b/infini_train/src/device.cc
@@ -7,6 +7,7 @@
 
 #include "glog/logging.h"
 
+#include "infini_train/include/core/privateuse1_backend.h"
 #include "infini_train/include/nn/parallel/global.h"
 
 namespace infini_train {
@@ -26,9 +27,38 @@ bool Device::IsCPU() const { return type_ == DeviceType::kCPU; }
 
 bool Device::IsCUDA() const { return type_ == DeviceType::kCUDA; }
 
+bool Device::IsPrivateUse1() const { return type_ == DeviceType::kPrivateUse1; }
+
+std::optional<Device::DeviceType> Device::ParseType(std::string_view name) {
+    if (name == "cpu") {
+        return DeviceType::kCPU;
+    }
+    if (name == "cuda") {
+        return DeviceType::kCUDA;
+    }
+    if (name == "privateuse1" || (core::HasPrivateUse1Backend() && name == core::GetPrivateUse1BackendName())) {
+        return DeviceType::kPrivateUse1;
+    }
+    return std::nullopt;
+}
+
 std::string Device::ToString() const {
+    std::string type_str = "Unknown";
+    switch (type_) {
+    case DeviceType::kCPU:
+        type_str = "CPU";
+        break;
+    case DeviceType::kCUDA:
+        type_str = "CUDA";
+        break;
+    case DeviceType::kPrivateUse1:
+        type_str = core::GetPrivateUse1BackendName();
+        break;
+    default:
+        break;
+    }
     std::ostringstream oss;
-    oss << std::format("Device({}, {})", type_ == DeviceType::kCPU ? "CPU" : "CUDA", index_);
+    oss << std::format("Device({}, {})", type_str, index_);
     return oss.str();
 }
 
diff --git a/scripts/run_models_and_profile.bash b/scripts/run_models_and_profile.bash
index 67bc7acd..1f3938fb 100755
--- a/scripts/run_models_and_profile.bash
+++ b/scripts/run_models_and_profile.bash
@@ -78,6 +78,7 @@ MIXTRAL_LLMC_FILEPATH="$(read_var MIXTRAL_LLMC_FILEPATH)"; : "${MIXTRAL_LLMC_FIL
 GPT2_TEST_GROUPS="$(read_var GPT2_TEST_GROUPS)";          : "${GPT2_TEST_GROUPS:=basic,zero,lora,checkpoint}"
 LLAMA3_TEST_GROUPS="$(read_var LLAMA3_TEST_GROUPS)";      : "${LLAMA3_TEST_GROUPS:=basic,zero,lora,checkpoint}"
 MIXTRAL_TEST_GROUPS="$(read_var MIXTRAL_TEST_GROUPS)";    : "${MIXTRAL_TEST_GROUPS:=moe}"
+DEVICE_BACKEND="$(read_var DEVICE_BACKEND)";             : "${DEVICE_BACKEND:=cuda}"
 
 # export custom variables from config first. LOG_DIR/PROFILE_LOG_DIR are normalized below.
 while IFS="=" read -r k v; do
@@ -446,9 +447,9 @@ infini_run_cmd_for_test() {
     local arg_str="$4"
     local nproc_per_node="$5"
 
-    printf './infini_run --nproc_per_node=%s %s --input_bin %q --llmc_filepath %q --device cuda %s' \
+    printf './infini_run --nproc_per_node=%s %s --input_bin %q --llmc_filepath %q --device %q %s' \
         "$nproc_per_node" "$model_bin" \
-        "$input_bin" "$llmc_filepath" "$arg_str"
+        "$input_bin" "$llmc_filepath" "$DEVICE_BACKEND" "$arg_str"
 }
 
 # Run tests
@@ -529,7 +530,7 @@ for ((id=0; id<num_basic_compile_commands; ++id)); do
                     if [[ -n "$nproc_per_node" ]]; then
                         gpt2_cmd="$(infini_run_cmd_for_test "./gpt2" "$GPT2_INPUT_BIN" "$GPT2_LLMC_FILEPATH" "$gpt2_arg_str" "$nproc_per_node")"
                     else
-                        gpt2_cmd="${prefix}./gpt2 --input_bin ${GPT2_INPUT_BIN} --llmc_filepath ${GPT2_LLMC_FILEPATH} --device cuda ${gpt2_arg_str}"
+                        gpt2_cmd="${prefix}./gpt2 --input_bin ${GPT2_INPUT_BIN} --llmc_filepath ${GPT2_LLMC_FILEPATH} --device ${DEVICE_BACKEND} ${gpt2_arg_str}"
                     fi
                     run_and_log "$gpt2_cmd" "gpt2_${test_id}${log_suffix}" "$profile_flag" "$group_tag"
                 fi
@@ -540,7 +541,7 @@ for ((id=0; id<num_basic_compile_commands; ++id)); do
                     if [[ -n "$nproc_per_node" ]]; then
                         llama3_cmd="$(infini_run_cmd_for_test "./llama3" "$LLAMA3_INPUT_BIN" "$LLAMA3_LLMC_FILEPATH" "$llama3_arg_str" "$nproc_per_node")"
                     else
-                        llama3_cmd="${prefix}./llama3 --input_bin ${LLAMA3_INPUT_BIN} --llmc_filepath ${LLAMA3_LLMC_FILEPATH} --device cuda ${llama3_arg_str}"
+                        llama3_cmd="${prefix}./llama3 --input_bin ${LLAMA3_INPUT_BIN} --llmc_filepath ${LLAMA3_LLMC_FILEPATH} --device ${DEVICE_BACKEND} ${llama3_arg_str}"
                     fi
                     run_and_log "$llama3_cmd" "llama3_${test_id}${log_suffix}" "$profile_flag" "$group_tag"
                 fi
@@ -550,7 +551,7 @@ for ((id=0; id<num_basic_compile_commands; ++id)); do
                     if [[ -n "$nproc_per_node" ]]; then
                         mixtral_cmd="$(infini_run_cmd_for_test "./mixtral" "$MIXTRAL_INPUT_BIN" "$MIXTRAL_LLMC_FILEPATH" "$mixtral_arg_str" "$nproc_per_node")"
                     else
-                        mixtral_cmd="${prefix}./mixtral --input_bin ${MIXTRAL_INPUT_BIN} --llmc_filepath ${MIXTRAL_LLMC_FILEPATH} --device cuda ${mixtral_arg_str}"
+                        mixtral_cmd="${prefix}./mixtral --input_bin ${MIXTRAL_INPUT_BIN} --llmc_filepath ${MIXTRAL_LLMC_FILEPATH} --device ${DEVICE_BACKEND} ${mixtral_arg_str}"
                     fi
                     run_and_log "$mixtral_cmd" "mixtral_${test_id}${log_suffix}" "$profile_flag" "$group_tag"
                 fi
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 3bfaa548..b18cc2be 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -2,7 +2,7 @@
 # This file manages the test infrastructure for InfiniTrain
 
 # Include shared test macros (must be before any test subdirectory)
-include(${CMAKE_SOURCE_DIR}/cmake/test_macros.cmake)
+include(${PROJECT_SOURCE_DIR}/cmake/test_macros.cmake)
 
 # Common test utilities
 add_subdirectory(common)
@@ -11,6 +11,8 @@ add_subdirectory(common)
 add_subdirectory(distributed)
 # Module tests
 add_subdirectory(module)
+# Backend extension contract tests
+add_subdirectory(backend)
 
 # Tensor tests
 add_subdirectory(tensor)
@@ -35,3 +37,26 @@ add_subdirectory(transformer)
 
 # Checkpoint tests
 add_subdirectory(checkpoint)
+
+# Suite declaration above is device-independent. Instantiate the built-in
+# devices after every test subdirectory has registered its sources.
+_infini_train_instantiate_test_suites(
+  SUITE_REGISTRY INFINI_TRAIN_CPU_TEST_SUITES
+  TARGET_SUFFIX cpu
+  GTEST_PREFIX CPU
+  DEVICE_TYPE kCPU
+  DEVICE_INDEX 0
+  LABELS cpu
+)
+
+if(USE_CUDA)
+  _infini_train_instantiate_test_suites(
+    SUITE_REGISTRY INFINI_TRAIN_CUDA_TEST_SUITES
+    TARGET_SUFFIX cuda
+    GTEST_PREFIX CUDA
+    DEVICE_TYPE kCUDA
+    DEVICE_INDEX 0
+    LABELS cuda accelerator hardware
+    ACCELERATOR
+  )
+endif()
diff --git a/tests/autograd/test_autograd.cc b/tests/autograd/test_autograd.cc
index e7ca5d81..b03b392e 100644
--- a/tests/autograd/test_autograd.cc
+++ b/tests/autograd/test_autograd.cc
@@ -235,7 +235,7 @@ TEST_P(AutogradForwardTest, FunctionCtxRecordsForwardAutocastContext) {
     input->Fill(1.0f);
 
     auto fn = std::make_shared<ObserveAutocastContextFunction>();
-    const auto forward_dtype = kDeviceDefaultDtype[static_cast<size_t>(GetDevice().type())];
+    const auto forward_dtype = GetDefaultAutocastDtype(GetDevice().type());
     {
         AutocastGuard autocast_guard(GetDevice().type(), forward_dtype);
         auto outputs = fn->Apply({input});
@@ -253,7 +253,7 @@ TEST_P(AutogradForwardTest, FunctionCtxRestoresForwardAutocastContextForRecomput
     input->Fill(1.0f);
 
     auto fn = std::make_shared<ObserveAutocastContextFunction>();
-    const auto forward_dtype = kDeviceDefaultDtype[static_cast<size_t>(GetDevice().type())];
+    const auto forward_dtype = GetDefaultAutocastDtype(GetDevice().type());
     {
         AutocastGuard autocast_guard(GetDevice().type(), forward_dtype);
         auto outputs = fn->Apply({input});
@@ -273,7 +273,7 @@ TEST_P(AutogradForwardTest, AutocastGuardRestoresCallerContextAfterForwardAutoca
     input->Fill(1.0f);
 
     auto fn = std::make_shared<ObserveAutocastContextFunction>();
-    const auto forward_dtype = kDeviceDefaultDtype[static_cast<size_t>(GetDevice().type())];
+    const auto forward_dtype = GetDefaultAutocastDtype(GetDevice().type());
     {
         AutocastGuard autocast_guard(GetDevice().type(), forward_dtype);
         auto outputs = fn->Apply({input});
diff --git a/tests/autograd/test_autograd_elementwise_backward.cc b/tests/autograd/test_autograd_elementwise_backward.cc
index 8623fe97..5e7741cf 100644
--- a/tests/autograd/test_autograd_elementwise_backward.cc
+++ b/tests/autograd/test_autograd_elementwise_backward.cc
@@ -77,7 +77,7 @@ TEST_P(AutogradElementwiseBackwardTest, MulBackward) {
 }
 
 TEST_P(AutogradElementwiseBackwardTest, BFloat16MulBroadcastBackwardLargeBlock) {
-    ONLY_CUDA();
+    SKIP_CPU();
     auto a = std::make_shared<Tensor>(std::vector<int64_t>{512, 8192}, DataType::kBFLOAT16, GetDevice(), true);
     a->Fill(2.0f);
     auto b = std::make_shared<Tensor>(std::vector<int64_t>{8192}, DataType::kBFLOAT16, GetDevice(), true);
diff --git a/tests/backend/CMakeLists.txt b/tests/backend/CMakeLists.txt
new file mode 100644
index 00000000..8ddd4575
--- /dev/null
+++ b/tests/backend/CMakeLists.txt
@@ -0,0 +1,9 @@
+infini_train_add_test(test_privateuse1_backend
+  SOURCES test_privateuse1_backend.cc
+  LABELS cpu
+)
+
+infini_train_add_test(test_privateuse1_backend_validation
+  SOURCES test_privateuse1_backend_validation.cc
+  LABELS cpu
+)
diff --git a/tests/backend/test_privateuse1_backend.cc b/tests/backend/test_privateuse1_backend.cc
new file mode 100644
index 00000000..88ac5e37
--- /dev/null
+++ b/tests/backend/test_privateuse1_backend.cc
@@ -0,0 +1,186 @@
+#include <cstring>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+#include "infini_train/include/autocast.h"
+#include "infini_train/include/core/privateuse1_backend.h"
+#include "infini_train/include/core/runtime/device_guard.h"
+#include "infini_train/include/core/runtime/runtime_common.h"
+#include "infini_train/include/dispatcher.h"
+#include "infini_train/include/tensor.h"
+
+namespace infini_train::test {
+namespace {
+
+int g_fake_runtime_initialize_count = 0;
+
+class FakeStream final : public core::Stream {};
+class FakeEvent final : public core::Event {};
+
+class FakePrivateUse1GuardImpl final : public core::DeviceGuardImpl {
+public:
+    void Initialize() override {
+        std::call_once(initialize_once_, [] { ++g_fake_runtime_initialize_count; });
+    }
+
+    Device GetDevice() const override { return Device(Type(), current_device_); }
+
+    void SetDevice(Device device) const override {
+        CHECK(device.type() == Type());
+        CHECK_EQ(device.index(), 0);
+        current_device_ = device.index();
+    }
+
+    int DeviceCount() const override { return 1; }
+
+    Device::DeviceType Type() const override { return Device::DeviceType::kPrivateUse1; }
+
+    core::Stream *GetStream(Device device) const override {
+        CHECK(device.type() == Type());
+        return const_cast<FakeStream *>(&default_stream_);
+    }
+
+    core::Stream *CreateStream(Device device) const override {
+        CHECK(device.type() == Type());
+        return new FakeStream();
+    }
+
+    core::Stream *CreateStreamWithPriority(Device device, int) const override { return CreateStream(device); }
+
+    void DestroyStream(core::Stream *stream) const override { delete stream; }
+
+    void GetStreamPriorityRange(int *low, int *high) const override {
+        *low = 0;
+        *high = 0;
+    }
+
+    void EventCreate(core::Event **event) const override { *event = new FakeEvent(); }
+
+    void EventCreateWithFlags(core::Event **event, core::EventFlag) const override { EventCreate(event); }
+
+    void EventDestroy(core::Event *event) const override { delete event; }
+
+    void EventRecord(core::Event *, core::Stream *) const override {}
+
+    void StreamWaitEvent(core::Stream *, core::Event *, uint32_t) const override {}
+
+    core::RuntimeStatus EventSynchronize(core::Event *) const override { return core::RuntimeStatus::kSuccess; }
+
+    core::RuntimeStatus EventQuery(core::Event *) const override { return core::RuntimeStatus::kSuccess; }
+
+    float EventElapsedTime(core::Event *, core::Event *) const override { return 0.0F; }
+
+    void SynchronizeDevice(Device) const override {}
+
+    void SynchronizeStream(core::Stream *) const override {}
+
+    void Malloc(void **dev_ptr, size_t size) override { *dev_ptr = ::operator new(size == 0 ? 1 : size); }
+
+    void MallocAsync(void **dev_ptr, size_t size, core::Stream *) override { Malloc(dev_ptr, size); }
+
+    void Free(void *dev_ptr) override { ::operator delete(dev_ptr); }
+
+    void FreeAsync(void *dev_ptr, core::Stream *) override { Free(dev_ptr); }
+
+    void Memcpy(void *dst, const void *src, size_t count, core::MemcpyKind) override { std::memcpy(dst, src, count); }
+
+    void MemcpyAsync(void *dst, const void *src, size_t count, core::MemcpyKind kind, core::Stream *) override {
+        Memcpy(dst, src, count, kind);
+    }
+
+    void ResetMemPoolHighWatermarks(Device) const override {}
+
+    std::pair<size_t, size_t> GetMemPoolPeakMB(Device) const override { return {0, 0}; }
+
+private:
+    inline static thread_local int8_t current_device_ = 0;
+    std::once_flag initialize_once_;
+    FakeStream default_stream_;
+};
+
+void FakeFill(std::shared_ptr<Tensor> tensor, Scalar value) {
+    CHECK(tensor->Dtype() == DataType::kFLOAT32);
+    auto *data = static_cast<float *>(tensor->DataPtr());
+    for (size_t i = 0; i < tensor->NumElements(); ++i) { data[i] = value.to<float>(); }
+}
+
+std::shared_ptr<Tensor> FakeCast(std::shared_ptr<Tensor> input, DataType dtype) {
+    CHECK(input->Dtype() == dtype);
+    auto output = std::make_shared<Tensor>(input->Dims(), dtype, input->GetDevice());
+    std::memcpy(output->DataPtr(), input->DataPtr(), input->SizeInBytes());
+    return output;
+}
+
+std::shared_ptr<Tensor> FakeNoOpForward(const std::shared_ptr<Tensor> &input, const std::vector<int64_t> &dims) {
+    return std::make_shared<Tensor>(*input, 0, dims);
+}
+
+std::shared_ptr<Tensor> FakeNoOpBackward(const std::vector<int64_t> &dims, const std::shared_ptr<Tensor> &grad_output) {
+    return std::make_shared<Tensor>(*grad_output, 0, dims);
+}
+
+void RegisterFakeRuntime() {
+    CHECK_EQ(core::GetPrivateUse1BackendName(), "fake");
+    CHECK_EQ(Device(Device::DeviceType::kPrivateUse1, 0).ToString(), "Device(fake, 0)");
+    INFINI_TRAIN_REGISTER_DEVICE_GUARD_IMPL(Device::DeviceType::kPrivateUse1, FakePrivateUse1GuardImpl)
+}
+
+void RegisterFakeKernels() {
+    REGISTER_KERNEL(Device::DeviceType::kPrivateUse1, Cast, FakeCast)
+    REGISTER_KERNEL(Device::DeviceType::kPrivateUse1, Fill, FakeFill)
+    REGISTER_KERNEL(Device::DeviceType::kPrivateUse1, NoOpForward, FakeNoOpForward)
+    REGISTER_KERNEL(Device::DeviceType::kPrivateUse1, NoOpBackward, FakeNoOpBackward)
+}
+
+void InitializeFakeBackend() {
+    static std::once_flag once;
+    std::call_once(once, [] {
+        core::PrivateUse1BackendRegistration registration;
+        registration.name = "fake";
+        registration.default_autocast_dtype = DataType::kBFLOAT16;
+        registration.register_runtime = &RegisterFakeRuntime;
+        registration.register_kernels = &RegisterFakeKernels;
+        core::RegisterPrivateUse1Backend(registration);
+    });
+}
+
+TEST(PrivateUse1BackendTest, RegistersRuntimeMetadataAndBasicKernels) {
+    InitializeFakeBackend();
+
+    EXPECT_EQ(g_fake_runtime_initialize_count, 0);
+    EXPECT_TRUE(core::HasPrivateUse1Backend());
+    EXPECT_EQ(core::GetPrivateUse1BackendName(), "fake");
+    EXPECT_EQ(core::GetPrivateUse1BackendDefaultAutocastDtype(), DataType::kBFLOAT16);
+    EXPECT_EQ(GetDefaultAutocastDtype(Device::DeviceType::kCPU), DataType::kBFLOAT16);
+    EXPECT_EQ(GetDefaultAutocastDtype(Device::DeviceType::kCUDA), DataType::kFLOAT16);
+    EXPECT_EQ(GetDefaultAutocastDtype(Device::DeviceType::kPrivateUse1), DataType::kBFLOAT16);
+    EXPECT_EQ(Device::ParseType("fake"), Device::DeviceType::kPrivateUse1);
+    EXPECT_EQ(Device::ParseType("privateuse1"), Device::DeviceType::kPrivateUse1);
+    EXPECT_FALSE(Device::ParseType("missing").has_value());
+
+    Device device(Device::DeviceType::kPrivateUse1, 0);
+    EXPECT_EQ(device.ToString(), "Device(fake, 0)");
+    EXPECT_TRUE(core::DeviceGuardImplRegistry::Instance().Has(device.type()));
+    EXPECT_EQ(core::GetDeviceGuardImpl(device.type())->Type(), device.type());
+    EXPECT_EQ(g_fake_runtime_initialize_count, 1);
+
+    {
+        AutocastGuard guard(device.type());
+        EXPECT_EQ(GetCurrentAutocastContext().autocast_dtype, DataType::kBFLOAT16);
+    }
+
+    auto tensor = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, device);
+    tensor->Fill(Scalar(3.0F));
+    const auto *data = static_cast<const float *>(tensor->DataPtr());
+    for (size_t i = 0; i < tensor->NumElements(); ++i) { EXPECT_FLOAT_EQ(data[i], 3.0F); }
+
+    auto view = tensor->View({3, 2});
+    EXPECT_EQ(view->Dims(), (std::vector<int64_t>{3, 2}));
+    EXPECT_EQ(view->DataPtr(), tensor->DataPtr());
+}
+
+} // namespace
+} // namespace infini_train::test
diff --git a/tests/backend/test_privateuse1_backend_validation.cc b/tests/backend/test_privateuse1_backend_validation.cc
new file mode 100644
index 00000000..94bacde9
--- /dev/null
+++ b/tests/backend/test_privateuse1_backend_validation.cc
@@ -0,0 +1,48 @@
+#include "gtest/gtest.h"
+
+#include "infini_train/include/core/privateuse1_backend.h"
+
+namespace infini_train::test {
+namespace {
+
+void UnusedRegistrationCallback() {}
+
+core::PrivateUse1BackendRegistration MinimalRegistration() {
+    core::PrivateUse1BackendRegistration registration;
+    registration.name = "valid_name";
+    registration.default_autocast_dtype = DataType::kBFLOAT16;
+    registration.register_runtime = &UnusedRegistrationCallback;
+    registration.register_kernels = &UnusedRegistrationCallback;
+    return registration;
+}
+
+TEST(PrivateUse1BackendValidationTest, RejectsReservedBackendNames) {
+    auto registration = MinimalRegistration();
+    registration.name = "cuda";
+    EXPECT_DEATH(core::RegisterPrivateUse1Backend(registration), "non-reserved");
+}
+
+TEST(PrivateUse1BackendValidationTest, RejectsNonAsciiBackendNames) {
+    auto registration = MinimalRegistration();
+    registration.name = "invalid-name";
+    EXPECT_DEATH(core::RegisterPrivateUse1Backend(registration), "lowercase ASCII");
+}
+
+TEST(PrivateUse1BackendValidationTest, RequiresDefaultAutocastDtype) {
+    auto registration = MinimalRegistration();
+    registration.default_autocast_dtype.reset();
+    EXPECT_DEATH(core::RegisterPrivateUse1Backend(registration), "must declare a default autocast dtype");
+}
+
+TEST(PrivateUse1BackendValidationTest, RejectsNonLowPrecisionDefaultAutocastDtype) {
+    auto registration = MinimalRegistration();
+    registration.default_autocast_dtype = DataType::kFLOAT32;
+    EXPECT_DEATH(core::RegisterPrivateUse1Backend(registration), "must be float16 or bfloat16");
+}
+
+TEST(PrivateUse1BackendValidationTest, RejectsDefaultAutocastDtypeQueryBeforeRegistration) {
+    EXPECT_DEATH(core::GetPrivateUse1BackendDefaultAutocastDtype(), "is not registered");
+}
+
+} // namespace
+} // namespace infini_train::test
diff --git a/tests/common/CMakeLists.txt b/tests/common/CMakeLists.txt
index 84c92e51..6f91e891 100644
--- a/tests/common/CMakeLists.txt
+++ b/tests/common/CMakeLists.txt
@@ -1,7 +1,7 @@
 # Common test utilities + custom test main (initializes GlobalEnv before RUN_ALL_TESTS).
 add_library(test_main OBJECT test_main.cc)
 target_include_directories(test_main PUBLIC
-  ${CMAKE_SOURCE_DIR}
+  ${PROJECT_SOURCE_DIR}
   ${glog_SOURCE_DIR}/src
 )
 target_link_libraries(test_main PUBLIC GTest::gtest)
diff --git a/tests/common/test_main.cc b/tests/common/test_main.cc
index 54ef48dd..04e168b6 100644
--- a/tests/common/test_main.cc
+++ b/tests/common/test_main.cc
@@ -1,9 +1,22 @@
 #include "gtest/gtest.h"
 
+#if defined(INFINI_TRAIN_TEST_BACKEND_HEADER) && !defined(INFINI_TRAIN_TEST_BACKEND_REGISTRAR)
+#error "INFINI_TRAIN_TEST_BACKEND_REGISTRAR must be defined with INFINI_TRAIN_TEST_BACKEND_HEADER"
+#elif !defined(INFINI_TRAIN_TEST_BACKEND_HEADER) && defined(INFINI_TRAIN_TEST_BACKEND_REGISTRAR)
+#error "INFINI_TRAIN_TEST_BACKEND_HEADER must be defined with INFINI_TRAIN_TEST_BACKEND_REGISTRAR"
+#endif
+
+#if defined(INFINI_TRAIN_TEST_BACKEND_HEADER)
+#include INFINI_TRAIN_TEST_BACKEND_HEADER
+#endif
+
 #include "infini_train/include/nn/parallel/global.h"
 
 int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
+#if defined(INFINI_TRAIN_TEST_BACKEND_REGISTRAR)
+    INFINI_TRAIN_TEST_BACKEND_REGISTRAR();
+#endif
     infini_train::nn::parallel::global::GlobalEnv::Instance().Init(1, 1, false, 1, 1);
     return RUN_ALL_TESTS();
 }
diff --git a/tests/common/test_utils.h b/tests/common/test_utils.h
index 0774622a..ff8ef3a3 100644
--- a/tests/common/test_utils.h
+++ b/tests/common/test_utils.h
@@ -3,10 +3,7 @@
 #include <memory>
 #include <vector>
 
-#if defined(USE_CUDA)
-#include <cuda_runtime_api.h>
-#endif
-
+#include "infini_train/include/core/runtime/device_guard.h"
 #include "infini_train/include/device.h"
 #include "infini_train/include/tensor.h"
 #include "gtest/gtest.h"
@@ -70,54 +67,54 @@ inline void ExpectTensorNear(const std::shared_ptr<Tensor> &val1, float val2, fl
     }
 }
 
-#if defined(USE_CUDA)
 #define REQUIRE_MIN_DEVICES(n)                                                                                         \
     do {                                                                                                               \
-        int available_gpus = 0;                                                                                        \
-        cudaGetDeviceCount(&available_gpus);                                                                           \
-        if (available_gpus < (n)) {                                                                                    \
-            GTEST_SKIP() << "requires at least " << (n) << " GPUs (found " << available_gpus << ")";                   \
+        const int required_devices = (n);                                                                              \
+        const int available_devices = DeviceCount();                                                                   \
+        if (available_devices < required_devices) {                                                                    \
+            GTEST_SKIP() << "requires at least " << required_devices << " devices (found " << available_devices        \
+                         << ")";                                                                                       \
         }                                                                                                              \
     } while (0)
-#else
-#define REQUIRE_MIN_DEVICES(n)                                                                                         \
-    do { GTEST_SKIP() << "requires at least " << (n) << " GPUs (CUDA disabled)"; } while (0)
-#endif
 
 #define SKIP_CPU()                                                                                                     \
     do {                                                                                                               \
-        if (GetParam() == infini_train::Device::DeviceType::kCPU) {                                                    \
+        if (!IsAccelerator()) {                                                                                        \
             GTEST_SKIP() << "skipped on CPU";                                                                          \
         }                                                                                                              \
     } while (0)
 
 #define ONLY_CPU()                                                                                                     \
     do {                                                                                                               \
-        if (GetParam() != infini_train::Device::DeviceType::kCPU) {                                                    \
+        if (IsAccelerator()) {                                                                                         \
             GTEST_SKIP() << "CPU-only test";                                                                           \
         }                                                                                                              \
     } while (0)
 
-#define ONLY_CUDA()                                                                                                    \
-    do {                                                                                                               \
-        if (GetParam() != infini_train::Device::DeviceType::kCUDA) {                                                   \
-            GTEST_SKIP() << "CUDA-only test";                                                                          \
-        }                                                                                                              \
-    } while (0)
-
 class InfiniTrainTest : public ::testing::TestWithParam<Device::DeviceType> {
 protected:
-    Device GetDevice() const { return Device(GetParam(), 0); }
+    Device GetDevice() const {
+#if defined(INFINI_TRAIN_TEST_DEVICE_INDEX)
+        return Device(GetParam(), INFINI_TRAIN_TEST_DEVICE_INDEX);
+#else
+        return Device(GetParam(), 0);
+#endif
+    }
+
+    int DeviceCount() const { return core::GetDeviceGuardImpl(GetDevice().type())->DeviceCount(); }
+
+    bool IsAccelerator() const { return GetDevice().type() != Device::DeviceType::kCPU; }
 };
 
 } // namespace test
 } // namespace infini_train
 
-#if defined(USE_CUDA)
-#define INFINI_TRAIN_REGISTER_TEST(TestName)                                                                           \
-    INSTANTIATE_TEST_SUITE_P(CPU, TestName, ::testing::Values(infini_train::Device::DeviceType::kCPU));                \
-    INSTANTIATE_TEST_SUITE_P(CUDA, TestName, ::testing::Values(infini_train::Device::DeviceType::kCUDA))
-#else
-#define INFINI_TRAIN_REGISTER_TEST(TestName)                                                                           \
-    INSTANTIATE_TEST_SUITE_P(CPU, TestName, ::testing::Values(infini_train::Device::DeviceType::kCPU))
+#define INFINI_TRAIN_INSTANTIATE_TEST(Prefix, TestName, DeviceType)                                                    \
+    INSTANTIATE_TEST_SUITE_P(Prefix, TestName, ::testing::Values(DeviceType))
+
+#if defined(INFINI_TRAIN_TEST_DEVICE_TYPE) != defined(INFINI_TRAIN_TEST_DEVICE_PREFIX)
+#error "INFINI_TRAIN_TEST_DEVICE_TYPE and INFINI_TRAIN_TEST_DEVICE_PREFIX must be defined together"
 #endif
+
+#define INFINI_TRAIN_REGISTER_TEST(TestName)                                                                           \
+    INFINI_TRAIN_INSTANTIATE_TEST(INFINI_TRAIN_TEST_DEVICE_PREFIX, TestName, INFINI_TRAIN_TEST_DEVICE_TYPE)
diff --git a/tests/tensor/CMakeLists.txt b/tests/tensor/CMakeLists.txt
index d697c7ee..11a4b926 100644
--- a/tests/tensor/CMakeLists.txt
+++ b/tests/tensor/CMakeLists.txt
@@ -3,11 +3,10 @@
 # ==========================================================================
 #
 # File layout:
-#   tests/tensor/*.cc            shared tests (compiled for both CPU and CUDA)
+#   tests/tensor/*.cc            shared tests (compiled for all configured devices)
 #   tests/tensor/cpu_only/*.cc   CPU-only tests (test_tensor_cpu_only target)
-#   tests/tensor/cuda_only/*.cc  CUDA-only tests (test_tensor_cuda_only, USE_CUDA=ON only)
 
-# Shared parameterized tests — produces test_tensor_cpu / test_tensor_cuda.
+# Shared parameterized tests - produces one target per configured test device.
 file(GLOB TENSOR_SHARED_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/test_*.cc)
 infini_train_add_test_suite(test_tensor SOURCES ${TENSOR_SHARED_SOURCES})
 
@@ -19,14 +18,3 @@ if(TENSOR_CPU_ONLY_SOURCES)
     LABELS cpu
   )
 endif()
-
-# CUDA-only tests — only built when USE_CUDA is enabled.
-if(USE_CUDA)
-  file(GLOB TENSOR_CUDA_ONLY_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/cuda_only/test_*.cc)
-  if(TENSOR_CUDA_ONLY_SOURCES)
-    infini_train_add_test(test_tensor_cuda_only
-      SOURCES ${TENSOR_CUDA_ONLY_SOURCES}
-      LABELS cuda
-    )
-  endif()
-endif()
diff --git a/tests/tensor/cuda_only/test_tensor_copy.cc b/tests/tensor/cuda_only/test_tensor_copy.cc
deleted file mode 100644
index a730c4b3..00000000
--- a/tests/tensor/cuda_only/test_tensor_copy.cc
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <memory>
-#include <vector>
-
-#include "gtest/gtest.h"
-
-#include "infini_train/include/tensor.h"
-
-#include "tests/common/test_utils.h"
-
-using namespace infini_train;
-
-class TensorCopyCudaTest : public ::testing::Test {};
-
-TEST_F(TensorCopyCudaTest, CopiesCPUToCUDA) {
-    auto cpu_tensor
-        = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, Device(Device::DeviceType::kCPU, 0));
-    auto cuda_tensor = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32,
-                                                Device(Device::DeviceType::kCUDA, 0));
-    cpu_tensor->Fill(0.0f);
-    cuda_tensor->CopyFrom(cpu_tensor);
-    EXPECT_TRUE(cuda_tensor->GetDevice().IsCUDA());
-}
-
-TEST_F(TensorCopyCudaTest, CopiesCUDAtoCPU) {
-    auto cuda_tensor = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32,
-                                                Device(Device::DeviceType::kCUDA, 0));
-    auto cpu_tensor
-        = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, Device(Device::DeviceType::kCPU, 0));
-    cuda_tensor->Fill(1.0f);
-    cpu_tensor->CopyFrom(cuda_tensor);
-    EXPECT_TRUE(cpu_tensor->GetDevice().IsCPU());
-}
-
-TEST_F(TensorCopyCudaTest, CopiesCUDAtoCUDA) {
-    auto source = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32,
-                                           Device(Device::DeviceType::kCUDA, 0));
-    auto target = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32,
-                                           Device(Device::DeviceType::kCUDA, 0));
-    source->Fill(2.0f);
-    target->CopyFrom(source);
-    EXPECT_TRUE(target->GetDevice().IsCUDA());
-}
-
-TEST_F(TensorCopyCudaTest, CopiesWithDifferentDeviceId) {
-    REQUIRE_MIN_DEVICES(2);
-    auto source = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32,
-                                           Device(Device::DeviceType::kCUDA, 0));
-    auto target = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32,
-                                           Device(Device::DeviceType::kCUDA, 1));
-    source->Fill(5.0f);
-    target->CopyFrom(source);
-    EXPECT_EQ(source->GetDevice().index(), 0);
-    EXPECT_EQ(target->GetDevice().index(), 1);
-}
diff --git a/tests/tensor/test_tensor.cc b/tests/tensor/test_tensor.cc
index 8b66e0d1..4f614cd4 100644
--- a/tests/tensor/test_tensor.cc
+++ b/tests/tensor/test_tensor.cc
@@ -10,7 +10,7 @@
 using namespace infini_train;
 
 // ============================================================================
-// Op tests — CPU + CUDA
+// Op tests - all configured test devices
 // ============================================================================
 
 class TensorOpTest : public infini_train::test::InfiniTrainTest {};
diff --git a/tests/tensor/test_tensor_accelerator_copy.cc b/tests/tensor/test_tensor_accelerator_copy.cc
new file mode 100644
index 00000000..3732db34
--- /dev/null
+++ b/tests/tensor/test_tensor_accelerator_copy.cc
@@ -0,0 +1,59 @@
+#include <memory>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+#include "infini_train/include/tensor.h"
+
+#include "tests/common/test_utils.h"
+
+using namespace infini_train;
+
+class TensorAcceleratorCopyTest : public infini_train::test::InfiniTrainTest {};
+
+TEST_P(TensorAcceleratorCopyTest, CopiesCPUToAccelerator) {
+    SKIP_CPU();
+    const Device accelerator = GetDevice();
+    auto cpu_tensor
+        = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, Device(Device::DeviceType::kCPU, 0));
+    auto accelerator_tensor = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, accelerator);
+    cpu_tensor->Fill(0.0f);
+    accelerator_tensor->CopyFrom(cpu_tensor);
+    EXPECT_EQ(accelerator_tensor->GetDevice(), accelerator);
+}
+
+TEST_P(TensorAcceleratorCopyTest, CopiesAcceleratorToCPU) {
+    SKIP_CPU();
+    const Device accelerator = GetDevice();
+    auto accelerator_tensor = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, accelerator);
+    auto cpu_tensor
+        = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, Device(Device::DeviceType::kCPU, 0));
+    accelerator_tensor->Fill(1.0f);
+    cpu_tensor->CopyFrom(accelerator_tensor);
+    EXPECT_TRUE(cpu_tensor->GetDevice().IsCPU());
+}
+
+TEST_P(TensorAcceleratorCopyTest, CopiesWithinAccelerator) {
+    SKIP_CPU();
+    const Device accelerator = GetDevice();
+    auto source = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, accelerator);
+    auto target = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, accelerator);
+    source->Fill(2.0f);
+    target->CopyFrom(source);
+    EXPECT_EQ(target->GetDevice(), accelerator);
+}
+
+TEST_P(TensorAcceleratorCopyTest, CopiesAcrossAcceleratorDevices) {
+    SKIP_CPU();
+    REQUIRE_MIN_DEVICES(2);
+    const Device source_device = GetDevice();
+    const Device target_device(source_device.type(), 1);
+    auto source = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, source_device);
+    auto target = std::make_shared<Tensor>(std::vector<int64_t>{2, 3}, DataType::kFLOAT32, target_device);
+    source->Fill(5.0f);
+    target->CopyFrom(source);
+    EXPECT_EQ(source->GetDevice(), source_device);
+    EXPECT_EQ(target->GetDevice(), target_device);
+}
+
+INFINI_TRAIN_REGISTER_TEST(TensorAcceleratorCopyTest);