diff --git a/cpp/cmake/templates/cuda_fatbin.ld b/cpp/cmake/templates/cuda_fatbin.ld
new file mode 100644
index 000000000000..f3a8920fe436
--- /dev/null
+++ b/cpp/cmake/templates/cuda_fatbin.ld
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* CUDA payloads can exceed 2 GiB. Place them before all host code so that
+ * code, unwind tables, the GOT, and code appended by BOLT remain close to
+ * each other. Keep .nvFatBinSegment (the registration wrappers containing
+ * pointers to the payloads) near host data.
+ * .dynsym precedes both code and unwind sections in GNU ld and LLD layouts.
+ */
+SECTIONS
+{
+    .nv_fatbin : { *(.nv_fatbin) }
+    __nv_relfatbin : { *(__nv_relfatbin) }
+}
+INSERT BEFORE .dynsym;
diff --git a/cpp/tensorrt_llm/CMakeLists.txt b/cpp/tensorrt_llm/CMakeLists.txt
index 8fa6c33c8eee..cc9a64e71544 100644
--- a/cpp/tensorrt_llm/CMakeLists.txt
+++ b/cpp/tensorrt_llm/CMakeLists.txt
@@ -259,6 +259,20 @@ set_target_properties(
   PROPERTIES CXX_STANDARD "20" CXX_STANDARD_REQUIRED "YES" CXX_EXTENSIONS "NO"
              LINK_FLAGS "${AS_NEEDED_FLAG} ${UNDEFINED_FLAG}")
 
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  # Keep host code, unwind tables, and the GOT within PC-relative addressing
+  # range, including after BOLT appends code, by placing CUDA payloads first.
+  set(CUDA_FATBIN_LINKER_SCRIPT
+      "${PROJECT_SOURCE_DIR}/cmake/templates/cuda_fatbin.ld")
+  foreach(target ${SHARED_TARGET} ${DECODER_SHARED_TARGET_0}
+                 ${DECODER_SHARED_TARGET_1})
+    target_link_options(${target} PRIVATE
+                        "LINKER:-T,${CUDA_FATBIN_LINKER_SCRIPT}")
+    set_property(TARGET ${target} APPEND
+                 PROPERTY LINK_DEPENDS "${CUDA_FATBIN_LINKER_SCRIPT}")
+  endforeach()
+endif()
+
 # Keep statically linked NVRTC symbols local so they cannot be interposed by a
 # dynamic NVRTC loaded elsewhere in the process.
 if(NOT WIN32 AND NOT NVRTC_DYNAMIC_LINKING)
@@ -270,15 +284,43 @@ endif()
 
 target_link_libraries(${SHARED_TARGET} PUBLIC ${TRTLLM_LINK_LIBS})
 
-target_link_libraries(
-  ${SHARED_TARGET}
-  PRIVATE
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,tllm_common_error,tllm_common_logging,tllm_common_cuda,tllm_executor_types,tllm_executor_serialization,tllm_runtime_memory,tllm_runtime_buffers,tllm_runtime_distributed,tllm_runtime_topology>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,tllm_common_environment,tllm_executor_values,tllm_executor_transfer_agent,tllm_kv_cache_host_memory,tllm_kv_cache,tllm_kv_cache_legacy,tllm_batch_scheduler,tllm_kernel_kv_cache_copy>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,${BATCH_MANAGER_TARGET}>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,${EXECUTOR_TARGET}>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,fp8_blockscale_gemm_src>
-    $<LINK_LIBRARY:WHOLE_ARCHIVE,${INTERNAL_CUTLASS_KERNELS_TARGET}>)
+foreach(
+  component
+  tllm_common_error
+  tllm_common_logging
+  tllm_common_cuda
+  tllm_executor_types
+  tllm_executor_serialization
+  tllm_runtime_memory
+  tllm_runtime_buffers
+  tllm_runtime_distributed
+  tllm_runtime_topology
+  tllm_common_cublas
+  tllm_common_environment
+  tllm_executor_values
+  tllm_executor_transfer_agent
+  tllm_kv_cache_host_memory
+  tllm_kv_cache
+  tllm_kv_cache_legacy
+  tllm_batch_scheduler
+  tllm_kernel_kv_cache_copy
+  ${BATCH_MANAGER_TARGET}
+  ${EXECUTOR_TARGET}
+  fp8_blockscale_gemm_src
+  ${INTERNAL_CUTLASS_KERNELS_TARGET})
+  target_link_libraries(${SHARED_TARGET}
+                        PRIVATE $<LINK_LIBRARY:WHOLE_ARCHIVE,${component}>)
+endforeach()
+
+foreach(component IN LISTS TLLM_KERNEL_COMPONENT_TARGETS)
+  target_link_libraries(${SHARED_TARGET}
+                        PRIVATE $<LINK_LIBRARY:WHOLE_ARCHIVE,${component}>)
+  set_property(TARGET ${SHARED_TARGET}
+               PROPERTY LINK_LIBRARY_OVERRIDE_${component} WHOLE_ARCHIVE)
+endforeach()
+
+set_property(TARGET ${SHARED_TARGET}
+             PROPERTY LINK_LIBRARY_OVERRIDE_tllm_common_cublas WHOLE_ARCHIVE)
 
 # Components also link each other normally; retain all component exports here.
 set_property(TARGET ${SHARED_TARGET}
diff --git a/cpp/tensorrt_llm/common/CMakeLists.txt b/cpp/tensorrt_llm/common/CMakeLists.txt
index 6b63f13eaf3a..8a266e2bdbea 100644
--- a/cpp/tensorrt_llm/common/CMakeLists.txt
+++ b/cpp/tensorrt_llm/common/CMakeLists.txt
@@ -74,10 +74,21 @@ target_link_libraries(tllm_common_environment PUBLIC tllm::common_cuda)
 set_target_properties(tllm_common_environment
                       PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
+add_library(tllm_common_cublas STATIC cublasMMWrapper.cpp)
+add_library(tllm::common_cublas ALIAS tllm_common_cublas)
+target_link_libraries(tllm_common_cublas PUBLIC tllm::common_cuda CUDA::cublas
+                                                CUDA::cublasLt)
+target_compile_features(tllm_common_cublas PUBLIC cxx_std_20)
+set_target_properties(tllm_common_cublas PROPERTIES POSITION_INDEPENDENT_CODE
+                                                    ON)
+if(ENABLE_CUBLASLT_FP4_GEMM)
+  target_compile_definitions(tllm_common_cublas
+                             PRIVATE ENABLE_CUBLASLT_FP4_GEMM)
+endif()
+
 add_library(
   common_src OBJECT
   attentionOp.cpp
-  cublasMMWrapper.cpp
   cudaFp8Utils.cu
   cudaProfilerUtils.cpp
   mcastDevMemUtils.cpp
@@ -88,7 +99,8 @@ add_library(
 add_cuda_architectures(common_src 89)
 set_property(TARGET common_src PROPERTY POSITION_INDEPENDENT_CODE ON)
 set_property(TARGET common_src PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)
-target_link_libraries(common_src PUBLIC trtllm_gen_fmha_interface)
+target_link_libraries(common_src PUBLIC trtllm_gen_fmha_interface
+                                        tllm::common_cublas)
 
 if(ENABLE_CUBLASLT_FP4_GEMM)
   target_compile_definitions(common_src PRIVATE ENABLE_CUBLASLT_FP4_GEMM)
diff --git a/cpp/tensorrt_llm/kernels/CMakeLists.txt b/cpp/tensorrt_llm/kernels/CMakeLists.txt
index 5f2190da30bf..314b92643072 100644
--- a/cpp/tensorrt_llm/kernels/CMakeLists.txt
+++ b/cpp/tensorrt_llm/kernels/CMakeLists.txt
@@ -105,6 +105,11 @@ if(FAST_BUILD)
     STATUS "FAST_BUILD enabled for kernels: using -O1 for CUDA compilation")
 endif()
 
+include(kernelComponents.cmake)
+set(TLLM_KERNEL_COMPONENT_TARGETS
+    ${TLLM_KERNEL_COMPONENT_TARGETS}
+    PARENT_SCOPE)
+
 # Marlin NVFP4: build Ada/Hopper kernels and the dense W4A16/repack kernels used
 # on SM12x. Unsupported device passes emit empty kernel stubs.
 file(GLOB_RECURSE MARLIN_SRC "marlin/*.cu" "marlin/*.cpp")
diff --git a/cpp/tensorrt_llm/kernels/cutlass_kernels/CMakeLists.txt b/cpp/tensorrt_llm/kernels/cutlass_kernels/CMakeLists.txt
index 20aedcd1e321..e9a552545e69 100644
--- a/cpp/tensorrt_llm/kernels/cutlass_kernels/CMakeLists.txt
+++ b/cpp/tensorrt_llm/kernels/cutlass_kernels/CMakeLists.txt
@@ -163,7 +163,8 @@ file(GLOB_RECURSE MIXED_SRC_CU fpA_intB_gemm/*.cu)
 # Get the sources for MOE Grouped GEMM launchers. They live in the MoE domain
 # directory; the targets stay here, next to the CUTLASS instantiation generator
 # and the helpers (process_target, add_instantiations) they use.
-set(MOE_CUTLASS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../moe/cutlass)
+get_filename_component(MOE_CUTLASS_DIR
+                       "${CMAKE_CURRENT_SOURCE_DIR}/../moe/cutlass" ABSOLUTE)
 file(GLOB_RECURSE GROUPED_SRC_CPP ${MOE_CUTLASS_DIR}/*.cpp)
 file(GLOB_RECURSE GROUPED_SRC_CU ${MOE_CUTLASS_DIR}/*.cu)
 
@@ -171,7 +172,10 @@ file(GLOB_RECURSE GROUPED_SRC_CU ${MOE_CUTLASS_DIR}/*.cu)
 file(GLOB_RECURSE FBGEMM_SRC_CU fp8_rowwise_gemm/*.cu)
 
 # Get the sources for FP8 Blockwise GEMM launchers
-file(GLOB_RECURSE FP8_BLOCKSCALE_GEMM_SRC_CU fp8_blockscale_gemm/*.cu)
+set(FP8_BLOCKSCALE_GEMM_SRC_CU
+    ${CMAKE_CURRENT_SOURCE_DIR}/fp8_blockscale_gemm/fp8_blockscale_gemm.cu
+    ${CMAKE_CURRENT_SOURCE_DIR}/fp8_blockscale_gemm/fp8_blockscale_quant_packed.cu
+)
 
 # Get the sources for FP4 GEMM launchers
 file(GLOB_RECURSE FP4_SRC_CU fp4_gemm/*.cu)
@@ -183,6 +187,15 @@ file(GLOB_RECURSE ARGEMM_SRC_CU allreduce_gemm/*.cu)
 file(GLOB_RECURSE SRC_CPP *.cpp)
 file(GLOB_RECURSE SRC_CU *.cu)
 set(ALL_SRCS ${SRC_CPP};${SRC_CU})
+list(
+  REMOVE_ITEM
+  ALL_SRCS
+  "${CMAKE_CURRENT_SOURCE_DIR}/int8_gemm/int8_gemm_bf16.cu"
+  "${CMAKE_CURRENT_SOURCE_DIR}/int8_gemm/int8_gemm_fp16.cu"
+  "${CMAKE_CURRENT_SOURCE_DIR}/int8_gemm/int8_gemm_fp32.cu"
+  "${CMAKE_CURRENT_SOURCE_DIR}/int8_gemm/int8_gemm_int32.cu")
+list(REMOVE_ITEM ALL_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/cutlass_heuristic.cpp"
+     "${CMAKE_CURRENT_SOURCE_DIR}/cutlass_preprocessors.cpp")
 list(FILTER ALL_SRCS EXCLUDE REGEX "fpA_intB_gemm/.*")
 list(FILTER ALL_SRCS EXCLUDE REGEX "fp8_rowwise_gemm/.*")
 list(FILTER ALL_SRCS EXCLUDE REGEX "fp8_blockscale_gemm/.*")
@@ -205,9 +218,20 @@ message(VERBOSE "FP4 srcs ${FP4_SRC_CU} ${FP4_CU_INSTANTIATIONS}")
 message(VERBOSE "ARgemm srcs ${ARGEMM_SRC_CU}")
 message(VERBOSE "All srcs ${ALL_SRCS}")
 
-add_library(cutlass_src STATIC ${ALL_SRCS})
+if(ALL_SRCS)
+  add_library(cutlass_src STATIC ${ALL_SRCS})
+  target_link_libraries(cutlass_src PUBLIC tllm::kernel_gemm_utilities
+                                           tllm::kernel_int8_gemm)
+else()
+  add_library(cutlass_src INTERFACE)
+  target_link_libraries(cutlass_src INTERFACE tllm::kernel_gemm_utilities
+                                              tllm::kernel_int8_gemm)
+endif()
 
 add_library(fpA_intB_gemm_src STATIC ${MIXED_SRC_CPP} ${MIXED_SRC_CU})
+add_library(tllm::kernel_weight_only_gemm ALIAS fpA_intB_gemm_src)
+target_link_libraries(fpA_intB_gemm_src PUBLIC tllm::kernel_gemm_utilities
+                                               tllm::common_environment)
 add_cuda_architectures(fpA_intB_gemm_src 89)
 add_instantiations(fpA_intB_gemm_src ${INSTANTIATION_GENERATION_DIR}/gemm)
 
@@ -217,11 +241,18 @@ set_cuda_architectures(fb_gemm_src ${CUTLASS_COMMON_ARCHS})
 # ${INSTANTIATION_GENERATION_DIR}/fp8_rowwise_gemm)
 
 add_library(fp8_blockscale_gemm_src STATIC ${FP8_BLOCKSCALE_GEMM_SRC_CU})
+add_library(tllm::kernel_fp8_block_scale_gemm ALIAS fp8_blockscale_gemm_src)
+target_link_libraries(
+  fp8_blockscale_gemm_src
+  PUBLIC tllm::kernel_gemm_utilities tllm::common_environment CUDA::cuda_driver
+         ${NVRTC_LIB} ${NVRTC_BUILTINS_LIB})
 set_cuda_architectures(fp8_blockscale_gemm_src ${CUTLASS_COMMON_ARCHS})
 
 set(GEMM_SWIGLU_SM90_SRC_CU
     ${CMAKE_CURRENT_SOURCE_DIR}/fused_gated_gemm/gemm_swiglu_e4m3.cu)
 add_library(gemm_swiglu_sm90_src STATIC ${GEMM_SWIGLU_SM90_SRC_CU})
+add_library(tllm::kernel_gated_gemm ALIAS gemm_swiglu_sm90_src)
+target_link_libraries(gemm_swiglu_sm90_src PUBLIC tllm::kernel_gemm_utilities)
 set_cuda_architectures(gemm_swiglu_sm90_src 90)
 
 if(USING_OSS_CUTLASS_LOW_LATENCY_GEMM)
@@ -241,7 +272,30 @@ if(USING_OSS_CUTLASS_FP4_GEMM)
 endif()
 
 if(USING_OSS_CUTLASS_MOE_GEMM)
-  file(GLOB MOE_GEMM_SRC_CU "${MOE_CUTLASS_DIR}/*.cu")
+  set(MOE_GEMM_SRC_CU
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_bf16.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_fp4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_fp8.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_uint4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_bf16_uint8.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp16_fp16.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp16_fp4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp16_uint4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp16_uint8.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp32_fp32.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp4_fp4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp8_fp4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp8_fp8.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_kernels_fp8_uint4.cu"
+      "${MOE_CUTLASS_DIR}/moe_gemm_tma_warp_specialized_input.cu"
+      "${MOE_CUTLASS_DIR}/moe_kernels.cu"
+      "${MOE_CUTLASS_DIR}/moe_lora_pointer_expand.cu"
+      "${MOE_CUTLASS_DIR}/moe_lora_problem_builder.cu"
+      "${MOE_CUTLASS_DIR}/moe_lora_slot_expand.cu")
+  list(
+    REMOVE_ITEM MOE_GEMM_SRC_CU "${MOE_CUTLASS_DIR}/moe_lora_pointer_expand.cu"
+    "${MOE_CUTLASS_DIR}/moe_lora_problem_builder.cu"
+    "${MOE_CUTLASS_DIR}/moe_lora_slot_expand.cu")
   set(MOE_GEMM_SRC_CU_LAUNCHER ${MOE_GEMM_SRC_CU})
   list(FILTER MOE_GEMM_SRC_CU_LAUNCHER EXCLUDE REGEX ".*moe_gemm_kernels_.*")
   list(FILTER MOE_GEMM_SRC_CU INCLUDE REGEX ".*moe_gemm_kernels_.*")
@@ -258,6 +312,12 @@ if(USING_OSS_CUTLASS_MOE_GEMM)
   list(FILTER MOE_GEMM_SRC_CU EXCLUDE REGEX ".*fp8.*")
 
   add_library(moe_gemm_src STATIC ${MOE_GEMM_SRC_CU} ${GROUPED_SRC_CPP})
+  add_library(tllm::kernel_moe ALIAS moe_gemm_src)
+  target_link_libraries(
+    moe_gemm_src
+    PUBLIC tllm::kernel_gemm_utilities tllm::kernel_fp8_block_scale_gemm
+           tllm::kernel_lora tllm::kernel_pre_quant_scale
+           tllm::common_environment)
 
   add_library(_moe_gemm_launcher OBJECT ${MOE_GEMM_SRC_CU_LAUNCHER})
   add_cuda_architectures(_moe_gemm_launcher 89)
@@ -276,8 +336,8 @@ if(USING_OSS_CUTLASS_MOE_GEMM)
 
   add_instantiations(moe_gemm_src ${INSTANTIATION_GENERATION_DIR}/gemm_grouped)
   target_link_libraries(
-    moe_gemm_src PRIVATE _moe_gemm_launcher _moe_gemm_hopper_fp4 _moe_gemm_fp4
-                         _moe_gemm_fp8)
+    moe_gemm_src PRIVATE tllm::kernel_moe_lora _moe_gemm_launcher
+                         _moe_gemm_hopper_fp4 _moe_gemm_fp4 _moe_gemm_fp8)
   target_include_directories(
     moe_gemm_src
     PUBLIC ${PROJECT_SOURCE_DIR}/tensorrt_llm/cutlass_extensions/include)
diff --git a/cpp/tensorrt_llm/kernels/decoderMaskedMultiheadAttention/CMakeLists.txt b/cpp/tensorrt_llm/kernels/decoderMaskedMultiheadAttention/CMakeLists.txt
index 51776bc00a50..54fb3fcb1e03 100644
--- a/cpp/tensorrt_llm/kernels/decoderMaskedMultiheadAttention/CMakeLists.txt
+++ b/cpp/tensorrt_llm/kernels/decoderMaskedMultiheadAttention/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# SPDX-FileCopyrightText: Copyright (c) 1993-2024 NVIDIA CORPORATION &
+# SPDX-FileCopyrightText: Copyright (c) 1993-2026 NVIDIA CORPORATION &
 # AFFILIATES. All rights reserved. SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not
@@ -40,11 +40,6 @@ foreach(HEAD ${basic_heads})
   list(APPEND SRC_CU ${HEAD_SRCS})
 endforeach()
 
-# Cascade attention kernel. Compiled together with the basic heads so it lives
-# in the same shared library as the MMHA dispatcher that calls into it. Uses Dh
-# in {64, 128}.
-list(APPEND SRC_CU ${CMAKE_CURRENT_SOURCE_DIR}/cascadeAttentionKernel.cu)
-
 # skip mmha 48, 80, 96, 104, 112, 144, 160, 192 and 224 for fast build
 if(FAST_BUILD)
   set(extra_heads 256)
@@ -82,9 +77,18 @@ if(NOT WIN32)
                PROPERTY POSITION_INDEPENDENT_CODE ON)
   set_property(TARGET ${DECODER_SHARED_TARGET_1}
                PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)
+  foreach(target ${DECODER_SHARED_TARGET_0} ${DECODER_SHARED_TARGET_1})
+    target_link_libraries(${target} PUBLIC tllm::common_environment
+                                           tllm::kernel_cascade_attention)
+  endforeach()
 else()
-  target_sources(decoder_attention_src PRIVATE ${SRC_CPP} ${SRC_CU}
-                                               ${SRC_CU_EXTRA})
+  target_sources(decoder_attention_src PRIVATE ${SRC_CPP})
+  add_library(tllm_mmha STATIC ${SRC_CU} ${SRC_CU_EXTRA})
+  target_link_libraries(tllm_mmha PUBLIC tllm::common_environment
+                                         tllm::kernel_cascade_attention)
+  set_target_properties(tllm_mmha PROPERTIES POSITION_INDEPENDENT_CODE ON
+                                             CUDA_RESOLVE_DEVICE_SYMBOLS ON)
+  target_link_libraries(decoder_attention_src PUBLIC tllm_mmha)
 endif()
 
 target_link_libraries(decoder_attention_src PUBLIC nvrtc_wrapper_src
diff --git a/cpp/tensorrt_llm/kernels/kernelComponents.cmake b/cpp/tensorrt_llm/kernels/kernelComponents.cmake
new file mode 100644
index 000000000000..206346bfbf78
--- /dev/null
+++ b/cpp/tensorrt_llm/kernels/kernelComponents.cmake
@@ -0,0 +1,253 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 1993-2026 NVIDIA CORPORATION &
+# AFFILIATES. All rights reserved. SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+#
+
+add_library(tllm_kernel_cutlass_headers INTERFACE)
+add_library(tllm::kernel_cutlass_headers ALIAS tllm_kernel_cutlass_headers)
+target_include_directories(
+  tllm_kernel_cutlass_headers
+  INTERFACE ${CMAKE_BINARY_DIR}/_deps/cutlass-src/include
+            ${CMAKE_BINARY_DIR}/_deps/cutlass-src/tools/util/include
+            ${CMAKE_CURRENT_LIST_DIR}/../cutlass_extensions/include)
+target_link_libraries(tllm_kernel_cutlass_headers INTERFACE tllm::common_cuda)
+
+function(add_tllm_kernel_library target)
+  set(multi_value_args SOURCES LINK_LIBRARIES INCLUDE_DIRECTORIES)
+  cmake_parse_arguments(PARSE_ARGV 1 ARG "" "" "${multi_value_args}")
+  if(ARG_UNPARSED_ARGUMENTS
+     OR ARG_KEYWORDS_MISSING_VALUES
+     OR NOT ARG_SOURCES)
+    message(FATAL_ERROR "${target}: explicit kernel sources are required")
+  endif()
+
+  set(sources)
+  foreach(source IN LISTS ARG_SOURCES)
+    list(APPEND sources "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/${source}")
+  endforeach()
+  add_library(${target} STATIC ${sources})
+  string(REGEX REPLACE "^tllm_" "tllm::" alias ${target})
+  add_library(${alias} ALIAS ${target})
+  target_link_libraries(${target} PUBLIC tllm::common_cuda
+                                         ${ARG_LINK_LIBRARIES})
+  target_include_directories(${target} PRIVATE ${ARG_INCLUDE_DIRECTORIES})
+  target_compile_features(${target} PUBLIC cxx_std_20)
+  target_compile_options(
+    ${target} PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--expt-relaxed-constexpr>)
+  set_target_properties(
+    ${target}
+    PROPERTIES POSITION_INDEPENDENT_CODE ON CUDA_STANDARD 20
+               CUDA_STANDARD_REQUIRED ON CUDA_RESOLVE_DEVICE_SYMBOLS ON)
+  add_cuda_architectures(${target} 89)
+
+  foreach(source_list SRC_CPP SRC_CU MOE_KERNELS_SRC)
+    list(REMOVE_ITEM ${source_list} ${sources})
+    set(${source_list}
+        ${${source_list}}
+        PARENT_SCOPE)
+  endforeach()
+  set(TLLM_KERNEL_COMPONENT_TARGETS
+      ${TLLM_KERNEL_COMPONENT_TARGETS} ${target}
+      PARENT_SCOPE)
+endfunction()
+
+add_tllm_kernel_library(tllm_kernel_logits SOURCES logitsBitmask.cu)
+
+add_tllm_kernel_library(
+  tllm_kernel_nvfp4_cold_page SOURCES nvfp4ColdPageKernels.cu LINK_LIBRARIES
+  tllm::common_environment)
+
+add_tllm_kernel_library(
+  tllm_kernel_rope
+  SOURCES
+  attentionMask.cu
+  gptKernels.cu
+  unfusedAttentionKernels.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_bf16_bf16.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_bf16_fp4.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_bf16_fp8.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_bf16_int8.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_float_float.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_float_fp8.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_float_int8.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_half_fp4.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_half_fp8.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_half_half.cu
+  unfusedAttentionKernels/unfusedAttentionKernels_2_half_int8.cu
+  LINK_LIBRARIES
+  tllm::common_environment)
+
+add_tllm_kernel_library(tllm_kernel_sparse_attention SOURCES
+                        sparseAttentionKernels.cu)
+
+add_tllm_kernel_library(tllm_kernel_mla SOURCES mlaKernels.cu LINK_LIBRARIES
+                        tllm::common_environment)
+
+add_tllm_kernel_library(
+  tllm_kernel_mla_chunked_prefill SOURCES mlaChunkedPrefill.cu
+  INCLUDE_DIRECTORIES ${CMAKE_BINARY_DIR}/_deps/cutlass-src/include)
+
+add_tllm_kernel_library(
+  tllm_kernel_moe_communication SOURCES
+  moe/communication/fusedMoeCommKernels.cu LINK_LIBRARIES
+  tllm::common_environment CUDA::cuda_driver)
+
+add_tllm_kernel_library(
+  tllm_kernel_moe_load_balance SOURCES moe/loadBalance/moeLoadBalanceKernels.cu
+  LINK_LIBRARIES tllm::common_environment)
+
+if(USING_OSS_CUTLASS_MOE_GEMM)
+  add_tllm_kernel_library(
+    tllm_kernel_moe_lora SOURCES moe/cutlass/moe_lora_pointer_expand.cu
+    moe/cutlass/moe_lora_problem_builder.cu moe/cutlass/moe_lora_slot_expand.cu)
+  target_include_directories(
+    tllm_kernel_moe_lora PUBLIC ${CMAKE_BINARY_DIR}/_deps/cutlass-src/include)
+endif()
+
+add_tllm_kernel_library(
+  tllm_kernel_attention_mask SOURCES trtllmGenKernels/fmha/prepareCustomMask.cu
+  LINK_LIBRARIES trtllm_gen_fmha_interface)
+target_include_directories(tllm_kernel_attention_mask
+                           PUBLIC ${CMAKE_BINARY_DIR}/_deps/cutlass-src/include)
+
+add_tllm_kernel_library(
+  tllm_kernel_cuda_core_gemm SOURCES weightOnlyBatchedGemv/cudaCoreGemm.cu
+  LINK_LIBRARIES tllm::common_environment tllm::kernel_cutlass_headers)
+
+add_tllm_kernel_library(
+  tllm_kernel_gemm_utilities SOURCES cutlass_kernels/cutlass_heuristic.cpp
+  cutlass_kernels/cutlass_preprocessors.cpp LINK_LIBRARIES
+  tllm::kernel_cutlass_headers)
+
+list(APPEND TLLM_KERNEL_COMPONENT_TARGETS gemm_swiglu_sm90_src)
+
+add_tllm_kernel_library(
+  tllm_kernel_int8_gemm
+  SOURCES
+  cutlass_kernels/int8_gemm/int8_gemm_bf16.cu
+  cutlass_kernels/int8_gemm/int8_gemm_fp16.cu
+  cutlass_kernels/int8_gemm/int8_gemm_fp32.cu
+  cutlass_kernels/int8_gemm/int8_gemm_int32.cu
+  LINK_LIBRARIES
+  tllm::kernel_gemm_utilities)
+
+add_tllm_kernel_library(
+  tllm_kernel_smooth_quant SOURCES weightOnlyBatchedGemv/int8SQ.cu
+  LINK_LIBRARIES tllm::kernel_cutlass_headers)
+
+set_property(TARGET tllm_kernel_int8_gemm
+             PROPERTY CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}")
+
+add_tllm_kernel_library(
+  tllm_kernel_weight_only
+  SOURCES
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int4GroupwiseColumnMajorFalse.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int4GroupwiseColumnMajorInterleavedForHopperTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int4GroupwiseColumnMajorInterleavedTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int4PerChannelColumnMajorFalse.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int4PerChannelColumnMajorInterleavedForHopperTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int4PerChannelColumnMajorInterleavedTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int8GroupwiseColumnMajoInterleavedForHopperTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int8GroupwiseColumnMajorFalse.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int8GroupwiseColumnMajorInterleavedTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int8PerChannelColumnMajorFalse.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int8PerChannelColumnMajorInterleavedForHopperTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherBf16Int8PerChannelColumnMajorInterleavedTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int4GroupwiseColumnMajorFalse.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int4GroupwiseColumnMajorInterleavedForHopperTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int4GroupwiseColumnMajorInterleavedTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int4PerChannelColumnMajorFalse.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int4PerChannelColumnMajorInterleavedForHopperTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int4PerChannelColumnMajorInterleavedTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int8GroupwiseColumnMajorFalse.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int8GroupwiseColumnMajorInterleavedForHopperTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int8GroupwiseColumnMajorInterleavedTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int8PerChannelColumnMajorFalse.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int8PerChannelColumnMajorInterleavedForHopperTrue.cu
+  weightOnlyBatchedGemv/kernelDispatcherFp16Int8PerChannelColumnMajorInterleavedTrue.cu
+  LINK_LIBRARIES
+  tllm::kernel_cutlass_headers
+  tllm::common_environment)
+
+list(APPEND TLLM_KERNEL_COMPONENT_TARGETS
+     trtllm_gen_fp8_block_scale_moe_routing)
+
+add_tllm_kernel_library(
+  tllm_kernel_moe_block_scale SOURCES moe/trtllmGen/DevKernel.cu LINK_LIBRARIES
+  tllm::kernel_cutlass_headers)
+
+set_property(TARGET tllm_kernel_moe_block_scale
+             PROPERTY CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}")
+target_compile_options(tllm_kernel_moe_block_scale
+                       PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--split-compile=0>)
+
+add_tllm_kernel_library(
+  tllm_kernel_cascade_attention SOURCES
+  decoderMaskedMultiheadAttention/cascadeAttentionKernel.cu LINK_LIBRARIES
+  tllm::common_environment)
+set_property(TARGET tllm_kernel_cascade_attention
+             PROPERTY CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}")
+
+if(WIN32)
+  set(mmha_targets tllm_mmha)
+  list(APPEND TLLM_KERNEL_COMPONENT_TARGETS tllm_mmha)
+else()
+  set(mmha_targets ${DECODER_SHARED_TARGET_0} ${DECODER_SHARED_TARGET_1})
+endif()
+add_tllm_kernel_library(
+  tllm_kernel_attention_decode SOURCES decoderMaskedMultiheadAttention.cu
+  LINK_LIBRARIES ${mmha_targets})
+
+list(APPEND TLLM_KERNEL_COMPONENT_TARGETS trtllm_gen_fmha)
+
+add_tllm_kernel_library(
+  tllm_kernel_lora
+  SOURCES
+  groupGemm.cu
+  splitkGroupGemm.cu
+  lora/lora.cpp
+  lora/dora.cpp
+  lora/loraGroupGEMMParamFillRowReorderFusion.cu
+  doraScaling.cu
+  LINK_LIBRARIES
+  tllm::common_cublas
+  tllm::kernel_cutlass_headers
+  tllm::runtime_buffers
+  tllm::common_environment)
+
+add_tllm_kernel_library(tllm_kernel_quantization SOURCES quantization.cu
+                        LINK_LIBRARIES tllm::common_environment)
+
+add_tllm_kernel_library(tllm_kernel_pre_quant_scale SOURCES
+                        preQuantScaleKernel.cu)
+target_link_libraries(tllm_kernel_weight_only
+                      PUBLIC tllm::kernel_pre_quant_scale)
+
+add_library(tllm_kernel_moe_internal INTERFACE)
+add_library(tllm::kernel_moe_internal ALIAS tllm_kernel_moe_internal)
+target_link_libraries(
+  tllm_kernel_moe_internal
+  INTERFACE ${INTERNAL_CUTLASS_KERNELS_TARGET}
+            CUDA::cuda_driver
+            tllm::kernel_gemm_utilities
+            tllm::kernel_fp8_block_scale_gemm
+            tllm::kernel_lora
+            tllm::kernel_pre_quant_scale
+            tllm::common_environment)
+if(USING_OSS_CUTLASS_MOE_GEMM)
+  list(APPEND TLLM_KERNEL_COMPONENT_TARGETS moe_gemm_src)
+else()
+  add_library(tllm::kernel_moe ALIAS tllm_kernel_moe_internal)
+endif()
diff --git a/cpp/tensorrt_llm/kernels/moe/trtllmGen/CMakeLists.txt b/cpp/tensorrt_llm/kernels/moe/trtllmGen/CMakeLists.txt
index 88bd120d0724..3fc045b2d6ec 100644
--- a/cpp/tensorrt_llm/kernels/moe/trtllmGen/CMakeLists.txt
+++ b/cpp/tensorrt_llm/kernels/moe/trtllmGen/CMakeLists.txt
@@ -15,8 +15,6 @@
 # the License.
 #
 
-file(GLOB_RECURSE SRC_CPP *.cpp)
-file(GLOB_RECURSE SRC_CU *.cu)
 set(ROUTING_CUSTOM_SRC_CU
     ${CMAKE_CURRENT_SOURCE_DIR}/routing/RoutingCustomBlock.cu
     ${CMAKE_CURRENT_SOURCE_DIR}/routing/RoutingCustomCluster.cu
@@ -24,21 +22,36 @@ set(ROUTING_CUSTOM_SRC_CU
     ${CMAKE_CURRENT_SOURCE_DIR}/routing/RoutingCustomEntry.cu
     ${CMAKE_CURRENT_SOURCE_DIR}/routing/RoutingCustomSmallToken.cu)
 
-list(REMOVE_ITEM SRC_CU ${ROUTING_CUSTOM_SRC_CU})
+set(ROUTING_OTHER_SRC_CU
+    ${CMAKE_CURRENT_SOURCE_DIR}/routing/RoutingDeepSeek.cu
+    ${CMAKE_CURRENT_SOURCE_DIR}/routing/RoutingFromTopKIds.cu
+    ${CMAKE_CURRENT_SOURCE_DIR}/routing/RoutingLlama4.cu)
+set(ROUTING_SRC_CU ${ROUTING_CUSTOM_SRC_CU} ${ROUTING_OTHER_SRC_CU})
 
-# Build routing as multiple translation units without NVCC's internal parallel
-# split pipeline: one TU per heavy kernel family (block group, small cluster,
-# large cluster, small-token, entry) so ptxas runs them in parallel.
-add_library(trtllm_gen_fp8_block_scale_moe_routing OBJECT
-            ${ROUTING_CUSTOM_SRC_CU})
+# Custom routing uses one translation unit per kernel family and disables NVCC's
+# internal split pipeline so ptxas can process the families in parallel.
+add_library(trtllm_gen_fp8_block_scale_moe_routing STATIC ${ROUTING_SRC_CU})
+add_library(tllm::kernel_moe_routing ALIAS
+            trtllm_gen_fp8_block_scale_moe_routing)
+target_link_libraries(trtllm_gen_fp8_block_scale_moe_routing
+                      PUBLIC tllm::kernel_cutlass_headers)
+target_compile_features(trtllm_gen_fp8_block_scale_moe_routing
+                        PUBLIC cxx_std_20)
 set_property(TARGET trtllm_gen_fp8_block_scale_moe_routing
              PROPERTY POSITION_INDEPENDENT_CODE ON)
 set_property(TARGET trtllm_gen_fp8_block_scale_moe_routing
              PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)
-target_compile_options(trtllm_gen_fp8_block_scale_moe_routing
-                       PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--split-compile=1>)
+set_source_files_properties(
+  ${ROUTING_CUSTOM_SRC_CU}
+  PROPERTIES COMPILE_OPTIONS "$<$<COMPILE_LANGUAGE:CUDA>:--split-compile=1>")
+set_source_files_properties(
+  ${ROUTING_OTHER_SRC_CU}
+  PROPERTIES COMPILE_OPTIONS "$<$<COMPILE_LANGUAGE:CUDA>:--split-compile=0>")
 
-add_library(trtllm_gen_fp8_block_scale_moe OBJECT ${SRC_CPP} ${SRC_CU})
+add_library(trtllm_gen_fp8_block_scale_moe OBJECT runner.cu)
+target_link_libraries(
+  trtllm_gen_fp8_block_scale_moe PUBLIC tllm::kernel_moe_routing
+                                        tllm::kernel_moe_block_scale)
 set_property(TARGET trtllm_gen_fp8_block_scale_moe
              PROPERTY POSITION_INDEPENDENT_CODE ON)
 set_property(TARGET trtllm_gen_fp8_block_scale_moe
diff --git a/cpp/tensorrt_llm/kernels/trtllmGenKernels/fmha/CMakeLists.txt b/cpp/tensorrt_llm/kernels/trtllmGenKernels/fmha/CMakeLists.txt
index 5731ed4f0549..6a0ada3ccb00 100644
--- a/cpp/tensorrt_llm/kernels/trtllmGenKernels/fmha/CMakeLists.txt
+++ b/cpp/tensorrt_llm/kernels/trtllmGenKernels/fmha/CMakeLists.txt
@@ -46,8 +46,8 @@ configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/trtllmGen_fmha_export/KernelParamsDecl.h
   ${CMAKE_CURRENT_BINARY_DIR}/KernelParamsDecl.h COPYONLY)
 
-file(GLOB_RECURSE SRC_CPP *.cpp)
-file(GLOB_RECURSE SRC_CU *.cu)
+set(SRC_CPP ${CMAKE_CURRENT_SOURCE_DIR}/fmhaRunner.cpp)
+set(SRC_CU ${CMAKE_CURRENT_SOURCE_DIR}/fmhaReduction.cu)
 
 # Archs listed here are pruned when the build does not enable them. Sm100f has
 # no context FMHA kernel, so Rubin needs the prebuilt Sm107a cubins kept
@@ -64,10 +64,16 @@ target_include_directories(
   trtllm_gen_fmha_interface
   INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/trtllmGen_fmha_export)
 
-add_library(trtllm_gen_fmha OBJECT ${SRC_CPP} ${SRC_CU})
+add_library(trtllm_gen_fmha STATIC ${SRC_CPP} ${SRC_CU})
+add_library(tllm::kernel_attention ALIAS trtllm_gen_fmha)
+target_compile_features(trtllm_gen_fmha PUBLIC cxx_std_20)
 set_property(TARGET trtllm_gen_fmha PROPERTY POSITION_INDEPENDENT_CODE ON)
 set_property(TARGET trtllm_gen_fmha PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)
-target_link_libraries(trtllm_gen_fmha PUBLIC trtllm_gen_fmha_interface)
+target_link_libraries(
+  trtllm_gen_fmha
+  PUBLIC trtllm_gen_fmha_interface tllm::kernel_attention_mask
+         tllm::common_environment tllm::kernel_cutlass_headers
+         CUDA::cuda_driver)
 target_include_directories(
   trtllm_gen_fmha PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/trtllmGen_fmha_export)
 
diff --git a/cpp/tests/CMakeLists.txt b/cpp/tests/CMakeLists.txt
index 5ba58455a7a8..ae59fd4a9c34 100644
--- a/cpp/tests/CMakeLists.txt
+++ b/cpp/tests/CMakeLists.txt
@@ -40,9 +40,31 @@ foreach(owner common runtime executor batch-manager kernel)
   add_custom_target(${owner}-tests)
 endforeach()
 
+function(tllm_assert_test_is_component_local target)
+  get_target_property(link_libraries ${target} LINK_LIBRARIES)
+  if("${SHARED_TARGET}" IN_LIST link_libraries)
+    message(
+      FATAL_ERROR
+        "${target} links the full TensorRT-LLM library; use FULL_STACK explicitly"
+    )
+  endif()
+  foreach(dep IN LISTS link_libraries)
+    if(NOT TARGET ${dep})
+      continue()
+    endif()
+    get_target_property(dep_interface ${dep} INTERFACE_LINK_LIBRARIES)
+    if("${SHARED_TARGET}" IN_LIST dep_interface)
+      message(
+        FATAL_ERROR
+          "${target} links ${dep}, which interface-links the full TensorRT-LLM library; use FULL_STACK explicitly"
+      )
+    endif()
+  endforeach()
+endfunction()
+
 function(add_tllm_gtest test_name)
   set(options FULL_STACK NO_GTEST_MAIN REQUIRES_GPU)
-  set(one_value_args TIMEOUT OWNER)
+  set(one_value_args TIMEOUT OWNER TEST_PREFIX)
   set(multi_value_args SOURCES LINK_LIBRARIES LABELS)
   cmake_parse_arguments(PARSE_ARGV 1 ARG "${options}" "${one_value_args}"
                         "${multi_value_args}")
@@ -77,6 +99,13 @@ function(add_tllm_gtest test_name)
     endif()
   endif()
   target_link_libraries(${test_name} PRIVATE ${ARG_LINK_LIBRARIES})
+  if(NOT ARG_FULL_STACK)
+    cmake_language(
+      EVAL
+      CODE
+      "cmake_language(DEFER CALL tllm_assert_test_is_component_local [[${test_name}]])"
+    )
+  endif()
   target_compile_features(${test_name} PRIVATE cxx_std_20)
   target_compile_definitions(${test_name}
                              PRIVATE TOP_LEVEL_DIR="${TOP_LEVEL_DIR}")
@@ -88,8 +117,13 @@ function(add_tllm_gtest test_name)
   if(ARG_TIMEOUT)
     list(APPEND test_properties TIMEOUT "${ARG_TIMEOUT}")
   endif()
-  gtest_discover_tests(${test_name} DISCOVERY_MODE PRE_TEST DISCOVERY_TIMEOUT 30
-                       PROPERTIES LABELS "${ARG_LABELS}" ${test_properties})
+  set(discovery_args)
+  if(NOT "${ARG_TEST_PREFIX}" STREQUAL "")
+    list(APPEND discovery_args TEST_PREFIX "${ARG_TEST_PREFIX}")
+  endif()
+  gtest_discover_tests(
+    ${test_name} ${discovery_args} DISCOVERY_MODE PRE_TEST DISCOVERY_TIMEOUT 30
+    PROPERTIES LABELS "${ARG_LABELS}" ${test_properties})
 
   add_dependencies(google-tests ${test_name})
   if(ARG_OWNER)
@@ -127,9 +161,12 @@ function(add_gtest test_name test_src)
     list(APPEND test_properties TIMEOUT "${ARGS_TIMEOUT}")
   endif()
 
+  set(discovery_args)
+  if(NOT "${ARGS_TEST_PREFIX}" STREQUAL "")
+    list(APPEND discovery_args TEST_PREFIX "${ARGS_TEST_PREFIX}")
+  endif()
   gtest_discover_tests(
-    ${test_name}
-    TEST_PREFIX "${ARGS_TEST_PREFIX}"
+    ${test_name} ${discovery_args}
     PROPERTIES ${test_properties}
                DISCOVERY_MODE
                PRE_TEST # WAR for DLL discovery on windows.
diff --git a/cpp/tests/unit_tests/kernels/CMakeLists.txt b/cpp/tests/unit_tests/kernels/CMakeLists.txt
index c0c393a2634a..4bf3f2d8e906 100644
--- a/cpp/tests/unit_tests/kernels/CMakeLists.txt
+++ b/cpp/tests/unit_tests/kernels/CMakeLists.txt
@@ -13,9 +13,38 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-add_gtest(logitsBitmaskTest logitsBitmaskTest.cpp)
-add_gtest(cascadeAttentionKernelTest cascadeAttentionKernelTest.cpp)
-add_gtest(cascadeAttentionNumericsTest cascadeAttentionNumericsTest.cu)
+add_tllm_gtest(
+  logitsBitmaskTest
+  OWNER
+  kernel
+  SOURCES
+  logitsBitmaskTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_logits
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;logits;gpu")
+add_tllm_gtest(
+  cascadeAttentionKernelTest
+  OWNER
+  kernel
+  SOURCES
+  cascadeAttentionKernelTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_cascade_attention
+  LABELS
+  "unit;kernels;cascade-attention;gpu")
+add_tllm_gtest(
+  cascadeAttentionNumericsTest
+  OWNER
+  kernel
+  SOURCES
+  cascadeAttentionNumericsTest.cu
+  LINK_LIBRARIES
+  tllm::kernel_cascade_attention
+  tllm::kernel_attention_decode
+  LABELS
+  "unit;kernels;cascade-attention;gpu")
 
 macro(remove_compile_definition TARGET_NAME DEFINITION)
   get_target_property(DEFS ${TARGET_NAME} COMPILE_DEFINITIONS)
@@ -26,40 +55,168 @@ macro(remove_compile_definition TARGET_NAME DEFINITION)
   endif()
 endmacro()
 
-add_gtest(mixtureOfExpertsTest moe/mixtureOfExpertsTest.cu)
+add_tllm_gtest(
+  mixtureOfExpertsTest
+  OWNER
+  kernel
+  SOURCES
+  moe/mixtureOfExpertsTest.cu
+  LINK_LIBRARIES
+  tllm::kernel_moe
+  tllm::kernel_quantization
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;moe;gpu")
 
 # If we are using oss cutlass, build an explicit internal test
 if(USING_OSS_CUTLASS_MOE_GEMM)
   target_compile_definitions(mixtureOfExpertsTest
                              PUBLIC USING_OSS_CUTLASS_MOE_GEMM)
 
-  add_gtest(mixtureOfExpertsInternalTest moe/mixtureOfExpertsTest.cu
-            TEST_PREFIX "Internal.")
+  add_tllm_gtest(
+    mixtureOfExpertsInternalTest
+    TEST_PREFIX
+    "Internal."
+    OWNER
+    kernel
+    SOURCES
+    moe/mixtureOfExpertsTest.cu
+    LINK_LIBRARIES
+    tllm::kernel_moe_internal
+    tllm::kernel_quantization
+    tllm::runtime_buffers
+    LABELS
+    "unit;kernels;moe;gpu")
   remove_compile_definition(mixtureOfExpertsInternalTest
                             USING_OSS_CUTLASS_MOE_GEMM)
 endif()
 
-add_gtest(ropeTest ropeTest.cu)
-add_gtest(shiftKCacheKernelTest shiftKCacheKernelTest.cu)
-add_gtest(smoothQuantKernelTest smoothQuant/smoothQuantKernelTest.cpp)
-add_gtest(weightOnlyKernelTest weightOnly/weightOnlyKernelTest.cpp)
-add_gtest(mlaPreprocessTest mlaPreprocessTest.cu)
-add_gtest(sparseAttentionKernelsTest sparseAttentionKernelsTest.cpp)
+add_tllm_gtest(
+  ropeTest
+  OWNER
+  kernel
+  SOURCES
+  ropeTest.cu
+  LINK_LIBRARIES
+  tllm::kernel_rope
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;rope;gpu")
+add_tllm_gtest(
+  shiftKCacheKernelTest
+  OWNER
+  kernel
+  SOURCES
+  shiftKCacheKernelTest.cu
+  LINK_LIBRARIES
+  tllm::kernel_rope
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;rope;gpu")
+add_tllm_gtest(
+  smoothQuantKernelTest
+  OWNER
+  kernel
+  SOURCES
+  smoothQuant/smoothQuantKernelTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_smooth_quant
+  tllm::kernel_int8_gemm
+  LABELS
+  "unit;kernels;smooth-quant;gpu")
+add_tllm_gtest(
+  weightOnlyKernelTest
+  OWNER
+  kernel
+  SOURCES
+  weightOnly/weightOnlyKernelTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_weight_only
+  tllm::kernel_weight_only_gemm
+  LABELS
+  "unit;kernels;weight-only;gpu")
+add_tllm_gtest(
+  mlaPreprocessTest
+  OWNER
+  kernel
+  SOURCES
+  mlaPreprocessTest.cu
+  LINK_LIBRARIES
+  tllm::kernel_mla
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;mla;gpu")
+add_tllm_gtest(
+  sparseAttentionKernelsTest
+  OWNER
+  kernel
+  SOURCES
+  sparseAttentionKernelsTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_sparse_attention
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;sparse-attention;gpu")
 
-add_gtest(cudaCoreGemmKernelTest cudaCoreGemm/cudaCoreGemmKernelTest.cpp)
+add_tllm_gtest(
+  cudaCoreGemmKernelTest
+  OWNER
+  kernel
+  SOURCES
+  cudaCoreGemm/cudaCoreGemmKernelTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_cuda_core_gemm
+  CUDA::cublasLt
+  LABELS
+  "unit;kernels;cuda-core-gemm;gpu")
 
-add_gtest(mlaChunkedPrefillTest mlaChunkedPrefillTest.cu)
+add_tllm_gtest(
+  mlaChunkedPrefillTest
+  OWNER
+  kernel
+  SOURCES
+  mlaChunkedPrefillTest.cu
+  LINK_LIBRARIES
+  tllm::kernel_mla_chunked_prefill
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;mla-chunked-prefill;gpu")
 
-add_gtest(fusedMoeCommKernelTest moe/fusedMoeCommKernelTest.cpp)
+add_tllm_gtest(
+  fusedMoeCommKernelTest
+  OWNER
+  kernel
+  SOURCES
+  moe/fusedMoeCommKernelTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_moe_communication
+  Threads::Threads
+  LABELS
+  "unit;kernels;moe-communication;gpu")
 
-add_gtest(
+add_tllm_gtest(
   gemmSwigluRunnerTest
+  OWNER
+  kernel
+  SOURCES
   fused_gated_gemm/gemmSwigluRunnerTest.cu
-  ${PROJECT_SOURCE_DIR}/tensorrt_llm/cutlass_extensions/kernels/fused_gated_gemm/gemm_swiglu_e4m3.cu
+  LINK_LIBRARIES
+  tllm::kernel_gated_gemm
+  LABELS
+  "unit;kernels;gated-gemm;gpu"
   NO_GTEST_MAIN)
-add_gtest(gemmSwigluKernelTestSm90Fp8
-          fused_gated_gemm/gemmSwigluKernelTestSm90Fp8.cu NO_GTEST_MAIN
-          NO_TLLM_LINKAGE)
+
+add_executable(gemmSwigluKernelTestSm90Fp8 EXCLUDE_FROM_ALL
+               fused_gated_gemm/gemmSwigluKernelTestSm90Fp8.cu)
+target_link_libraries(gemmSwigluKernelTestSm90Fp8
+                      PRIVATE gtest tllm::kernel_cutlass_headers)
+target_compile_features(gemmSwigluKernelTestSm90Fp8 PRIVATE cxx_std_20)
+add_test(NAME gemmSwigluKernelTestSm90Fp8 COMMAND gemmSwigluKernelTestSm90Fp8)
+set_tests_properties(
+  gemmSwigluKernelTestSm90Fp8 PROPERTIES ENVIRONMENT "CUDA_MODULE_LOADING=LAZY"
+                                         LABELS "unit;kernels;gated-gemm;gpu")
+add_dependencies(kernel-tests gemmSwigluKernelTestSm90Fp8)
+add_dependencies(google-tests gemmSwigluKernelTestSm90Fp8)
 
 foreach(target_name gemmSwigluRunnerTest;gemmSwigluKernelTestSm90Fp8)
   set_property(TARGET ${target_name} PROPERTY CUDA_RESOLVE_DEVICE_SYMBOLS ON)
@@ -81,47 +238,132 @@ foreach(target_name gemmSwigluRunnerTest;gemmSwigluKernelTestSm90Fp8)
   endif()
 endforeach()
 
-set(ROUTING_KERNEL_TEST_SRC
-    moe/routing/routingTest.cpp moe/routing/routingLlama4Test.cpp
-    moe/routing/routingCustomTest.cpp moe/routing/routingDeepSeekTest.cpp)
-add_gtest(routingKernelsTest "${ROUTING_KERNEL_TEST_SRC}")
-target_link_libraries(routingKernelsTest PRIVATE Python3::Python)
+add_tllm_gtest(
+  routingKernelsTest
+  OWNER
+  kernel
+  SOURCES
+  moe/routing/routingTest.cpp
+  moe/routing/routingLlama4Test.cpp
+  moe/routing/routingCustomTest.cpp
+  moe/routing/routingDeepSeekTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_moe_routing
+  tllm::runtime_buffers
+  Python3::Python
+  LABELS
+  "unit;kernels;moe-routing;gpu")
 
-add_gtest(blockScaleMoeActivationTest moe/blockScaleMoeActivationTest.cu)
-add_gtest(blockScaleMoeFinalizeTest moe/blockScaleMoeFinalizeTest.cu)
+add_tllm_gtest(
+  blockScaleMoeActivationTest
+  OWNER
+  kernel
+  SOURCES
+  moe/blockScaleMoeActivationTest.cu
+  LINK_LIBRARIES
+  tllm::kernel_moe_block_scale
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;moe-block-scale;gpu")
+add_tllm_gtest(
+  blockScaleMoeFinalizeTest
+  OWNER
+  kernel
+  SOURCES
+  moe/blockScaleMoeFinalizeTest.cu
+  LINK_LIBRARIES
+  tllm::kernel_moe_block_scale
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;moe-block-scale;gpu")
 
-add_gtest(moeLoadBalanceKernelTest moe/moeLoadBalanceKernelTest.cpp)
+add_tllm_gtest(
+  moeLoadBalanceKernelTest
+  OWNER
+  kernel
+  SOURCES
+  moe/moeLoadBalanceKernelTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_moe_load_balance
+  Threads::Threads
+  LABELS
+  "unit;kernels;moe-load-balance;gpu")
 
 if(USING_OSS_CUTLASS_MOE_GEMM)
-  add_gtest(moeLoraPointerExpandTest moe/moeLoraPointerExpandTest.cu)
-  add_gtest(moeLoraProblemBuilderTest moe/moeLoraProblemBuilderTest.cu)
-  add_gtest(moeLoraSlotExpandTest moe/moeLoraSlotExpandTest.cu)
+  add_tllm_gtest(
+    moeLoraPointerExpandTest
+    OWNER
+    kernel
+    SOURCES
+    moe/moeLoraPointerExpandTest.cu
+    LINK_LIBRARIES
+    tllm::kernel_moe_lora
+    LABELS
+    "unit;kernels;moe-lora;gpu")
+  add_tllm_gtest(
+    moeLoraProblemBuilderTest
+    OWNER
+    kernel
+    SOURCES
+    moe/moeLoraProblemBuilderTest.cu
+    LINK_LIBRARIES
+    tllm::kernel_moe_lora
+    LABELS
+    "unit;kernels;moe-lora;gpu")
+  add_tllm_gtest(
+    moeLoraSlotExpandTest
+    OWNER
+    kernel
+    SOURCES
+    moe/moeLoraSlotExpandTest.cu
+    LINK_LIBRARIES
+    tllm::kernel_moe_lora
+    LABELS
+    "unit;kernels;moe-lora;gpu")
 endif()
 
-add_gtest(sparseKvCacheTest sparseKvCacheTest.cu)
-add_gtest(prepareCustomMaskTest prepareCustomMaskTest.cpp)
-add_gtest(fmhaDsv4EpilogueFusionTest fmhaDsv4EpilogueFusionTest.cpp)
-
-set(NVFP4_COLD_PAGE_KERNEL_TEST_SRC
-    nvfp4ColdPageKernelsTest.cpp
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/kernels/nvfp4ColdPageKernels.cu
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/batch_manager/kv_cache_manager_v2/utils/hostMem.cpp
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/batch_manager/kv_cache_manager_v2/utils/hostMemBacking.cpp
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/runtime/moeLoadBalancer/topologyDetector.cpp
-    # ~HostMem reports a failed cleanup through the poison latch, so this target
-    # needs the latch itself: NO_TLLM_LINKAGE means nothing else supplies it.
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/batch_manager/kv_cache_manager_v2/utils/poison.cpp
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/common/assert.cpp
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/common/envUtils.cpp
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/common/logger.cpp
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/common/stringUtils.cpp
-    ${PROJECT_SOURCE_DIR}/tensorrt_llm/common/tllmException.cpp)
-add_gtest(nvfp4ColdPageKernelsTest "${NVFP4_COLD_PAGE_KERNEL_TEST_SRC}"
-          NO_TLLM_LINKAGE)
-target_include_directories(
+add_tllm_gtest(
+  sparseKvCacheTest
+  OWNER
+  kernel
+  SOURCES
+  sparseKvCacheTest.cu
+  LINK_LIBRARIES
+  tllm::kernel_rope
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;rope;sparse-kv-cache;gpu")
+add_tllm_gtest(
+  prepareCustomMaskTest
+  OWNER
+  kernel
+  SOURCES
+  prepareCustomMaskTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_attention_mask
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;attention-mask;gpu")
+add_tllm_gtest(
+  fmhaDsv4EpilogueFusionTest
+  OWNER
+  kernel
+  SOURCES
+  fmhaDsv4EpilogueFusionTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_attention
+  tllm::runtime_buffers
+  LABELS
+  "unit;kernels;fmha;gpu")
+
+add_tllm_gtest(
   nvfp4ColdPageKernelsTest
-  PRIVATE ${PROJECT_SOURCE_DIR}/tensorrt_llm/batch_manager)
-# numa: the backing places pages with mbind and the topology detector reads the
-# node layout through libnuma.
-target_link_libraries(nvfp4ColdPageKernelsTest PRIVATE CUDA::cudart
-                                                       CUDA::cuda_driver numa)
+  OWNER
+  kernel
+  SOURCES
+  nvfp4ColdPageKernelsTest.cpp
+  LINK_LIBRARIES
+  tllm::kernel_nvfp4_cold_page
+  tllm::kv_cache_host_memory
+  LABELS
+  "unit;kernels;nvfp4-cold-page;gpu")