romerojosh · Oct 6, 2026 · Oct 6, 2026 · Oct 6, 2026 · Oct 6, 2026 · Oct 6, 2026
diff --git a/CMakeLists.txt b/CMakeLists.txt
diff --git a/README.md b/README.md
@@ -28,7 +28,24 @@ $ cmake -DCUDECOMP_BUILD_EXTRAS=1 -DCUDECOMP_ENABLE_NVSHMEM=1 ..
 
 
 ### GPU dependencies
-We strongly recommend building this library using NVHPC SDK compilers and libraries, as the SDK contains all required dependencies for this library and is the focus of our testing. GPU Fortran bindings require NVHPC SDK compilers.
+The NVHPC SDK remains the primary tested environment and provides all required
+GPU dependencies, but the C++ library does not require the NVHPC C++ compiler.
+GPU Fortran bindings require `nvfortran`. CMake 3.18 or newer is required.
+When no C++ compiler or toolchain is selected explicitly, CMake prefers
+`nvc++` when it is available.
+
+The CUDA Toolkit location is inferred from the selected NVIDIA CUDA compiler.
+To select a specific CUDA installation, set `CUDACXX` or
+`CMAKE_CUDA_COMPILER` when configuring a fresh build directory. When building
+the Fortran bindings against an external CUDA Toolkit, also set
+`NVHPC_CUDA_HOME` or `NVCOMPILER_CUDA_HOME` to an installation with the same
+CUDA major and minor version.
+
+CMake automatically searches system locations and paths exposed by the current
+environment, including `CPATH`, `LIBRARY_PATH`, and `LD_LIBRARY_PATH`. If
+dependencies cannot be found there, use `CUDECOMP_CUTENSOR_HOME`/`CUTENSOR_ROOT`,
+`CUDECOMP_NCCL_HOME`/`NCCL_ROOT`, or `CUDECOMP_NVSHMEM_HOME`/`NVSHMEM_ROOT`. The
+`CUDECOMP_*_HOME` setting takes precedence when both forms are provided.
 
 One exception is cuDecomp builds using NVSHMEM versions older than v3.0, which require the use of a bootstrapping layer that depends on your MPI distribution. The NVSHMEM library packaged within NVHPC SDK
 supports OpenMPI only. If you require usage of a different MPI implementation (e.g. Spectrum MPI or Cray MPICH), you need to either build

diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
@@ -7,11 +7,7 @@ set(benchmark_targets
 
 foreach(tgt ${benchmark_targets})
   add_executable(${tgt})
-  if (CMAKE_VERSION VERSION_LESS 3.18)
-    target_compile_options(${tgt} PRIVATE $<$<COMPILE_LANGUAGE:CUDA>: ${CUDA_CC_FLAGS}>)
-  else()
-    set_target_properties(${tgt} PROPERTIES CUDA_ARCHITECTURES "${CUDECOMP_CUDA_CC_LIST}")
-  endif()
+  set_target_properties(${tgt} PROPERTIES CUDA_ARCHITECTURES "${CUDECOMP_CUDA_CC_LIST}")
   target_compile_options(${tgt} PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-Wno-deprecated-gpu-targets >)
   target_sources(${tgt}
     PRIVATE
@@ -20,11 +16,11 @@ foreach(tgt ${benchmark_targets})
   target_include_directories(${tgt}
 	                     PRIVATE
 			     ${CMAKE_CURRENT_SOURCE_DIR}/../include
-			     ${NVHPC_CUFFT_INCLUDE_DIR}
+			     ${CUDECOMP_CUFFT_INCLUDE_DIR}
 			     ${NCCL_INCLUDE_DIR}
 			     ${MPI_CXX_INCLUDE_DIRS})
   target_link_libraries(${tgt} PRIVATE cudecomp)
-  target_link_libraries(${tgt} PRIVATE NVHPC::CUFFT)
+  target_link_libraries(${tgt} PRIVATE ${CUDECOMP_CUFFT_TARGET})
   set_target_properties(${tgt} PROPERTIES LINKER_LANGUAGE CXX)
 endforeach()
 
@@ -35,5 +31,5 @@ target_compile_definitions(benchmark_c2c_f PRIVATE C2C USE_FLOAT)
 
 install(
   TARGETS ${benchmark_targets}
-  RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin/benchmark
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}/benchmark
 )
diff --git a/cmake/FindCUTENSOR.cmake b/cmake/FindCUTENSOR.cmake
@@ -0,0 +1,99 @@
+# Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+include(FindPackageHandleStandardArgs)
+
+set(_CUTENSOR_ROOT "${CUTENSOR_ROOT}")
+if (NOT _CUTENSOR_ROOT AND NOT "$ENV{CUTENSOR_ROOT}" STREQUAL "")
+  set(_CUTENSOR_ROOT "$ENV{CUTENSOR_ROOT}")
+elseif (NOT _CUTENSOR_ROOT AND NOT "$ENV{NVCOMPILER_MATH_LIBS_HOME}" STREQUAL "")
+  set(_CUTENSOR_ROOT "$ENV{NVCOMPILER_MATH_LIBS_HOME}")
+endif()
+
+set(_CUTENSOR_TARGET_NAMES "${CMAKE_SYSTEM_PROCESSOR}-linux")
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64)$")
+  list(APPEND _CUTENSOR_TARGET_NAMES sbsa-linux)
+elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "^(AMD64|x86_64)$")
+  list(APPEND _CUTENSOR_TARGET_NAMES x86_64-linux)
+endif()
+
+set(_CUTENSOR_INCLUDE_SUFFIXES include)
+set(_CUTENSOR_LIBRARY_SUFFIXES lib lib64)
+foreach(_CUTENSOR_TARGET_NAME IN LISTS _CUTENSOR_TARGET_NAMES)
+  list(APPEND _CUTENSOR_INCLUDE_SUFFIXES "targets/${_CUTENSOR_TARGET_NAME}/include")
+  list(APPEND _CUTENSOR_LIBRARY_SUFFIXES "targets/${_CUTENSOR_TARGET_NAME}/lib")
+endforeach()
+list(APPEND _CUTENSOR_LIBRARY_SUFFIXES
+  "lib/${CUDAToolkit_VERSION_MAJOR}"
+  "lib/${CUDAToolkit_VERSION_MAJOR}.${CUDAToolkit_VERSION_MINOR}"
+)
+
+if (_CUTENSOR_ROOT)
+  find_path(CUTENSOR_INCLUDE_DIR
+    NAMES cutensor.h
+    HINTS "${_CUTENSOR_ROOT}"
+    PATH_SUFFIXES ${_CUTENSOR_INCLUDE_SUFFIXES}
+    NO_DEFAULT_PATH
+  )
+  find_library(CUTENSOR_LIBRARY
+    NAMES cutensor
+    HINTS "${_CUTENSOR_ROOT}"
+    PATH_SUFFIXES ${_CUTENSOR_LIBRARY_SUFFIXES}
+    NO_DEFAULT_PATH
+  )
+else()
+  set(_CUTENSOR_NVHPC_ROOT
+      "${CUDECOMP_NVHPC_SDK_ROOT}/math_libs/${CUDAToolkit_VERSION_MAJOR}.${CUDAToolkit_VERSION_MINOR}")
+  if (CUDECOMP_NVHPC_SDK_ROOT AND IS_DIRECTORY "${_CUTENSOR_NVHPC_ROOT}")
+    list(APPEND _CUTENSOR_PATHS "${_CUTENSOR_NVHPC_ROOT}")
+  endif()
+  find_path(CUTENSOR_INCLUDE_DIR
+    NAMES cutensor.h
+    PATHS ${_CUTENSOR_PATHS} ENV CPATH
+    PATH_SUFFIXES ${_CUTENSOR_INCLUDE_SUFFIXES}
+  )
+  find_library(CUTENSOR_LIBRARY
+    NAMES cutensor
+    PATHS ${_CUTENSOR_PATHS} ENV LIBRARY_PATH ENV LD_LIBRARY_PATH
+    PATH_SUFFIXES ${_CUTENSOR_LIBRARY_SUFFIXES}
+  )
+endif()
+
+if (CUTENSOR_INCLUDE_DIR)
+  file(STRINGS "${CUTENSOR_INCLUDE_DIR}/cutensor.h" _CUTENSOR_VERSION_LINES
+       REGEX "^#define CUTENSOR_(MAJOR|MINOR|PATCH) +[0-9]+")
+  foreach(_CUTENSOR_COMPONENT MAJOR MINOR PATCH)
+    string(REGEX MATCH "#define CUTENSOR_${_CUTENSOR_COMPONENT} +([0-9]+)" _CUTENSOR_VERSION_LINE
+                 "${_CUTENSOR_VERSION_LINES}")
+    set(CUTENSOR_VERSION_${_CUTENSOR_COMPONENT} "${CMAKE_MATCH_1}")
+  endforeach()
+  if (DEFINED CUTENSOR_VERSION_MAJOR AND DEFINED CUTENSOR_VERSION_MINOR AND DEFINED CUTENSOR_VERSION_PATCH)
+    set(CUTENSOR_VERSION "${CUTENSOR_VERSION_MAJOR}.${CUTENSOR_VERSION_MINOR}.${CUTENSOR_VERSION_PATCH}")
+  endif()
+endif()
+
+find_package_handle_standard_args(CUTENSOR
+  REQUIRED_VARS CUTENSOR_LIBRARY CUTENSOR_INCLUDE_DIR
+  VERSION_VAR CUTENSOR_VERSION
+)
+
+if (CUTENSOR_FOUND AND NOT TARGET CUTENSOR::CUTENSOR)
+  add_library(CUTENSOR::CUTENSOR UNKNOWN IMPORTED)
+  set_target_properties(CUTENSOR::CUTENSOR PROPERTIES
+    IMPORTED_LOCATION "${CUTENSOR_LIBRARY}"
+    INTERFACE_INCLUDE_DIRECTORIES "${CUTENSOR_INCLUDE_DIR}"
+  )
+endif()
+
+mark_as_advanced(CUTENSOR_INCLUDE_DIR CUTENSOR_LIBRARY)
+unset(_CUTENSOR_ROOT)
+unset(_CUTENSOR_TARGET_NAMES)
+unset(_CUTENSOR_TARGET_NAME)
+unset(_CUTENSOR_INCLUDE_SUFFIXES)
+unset(_CUTENSOR_LIBRARY_SUFFIXES)
+unset(_CUTENSOR_NVHPC_ROOT)
+unset(_CUTENSOR_PATHS)
+unset(_CUTENSOR_VERSION_LINES)
+unset(_CUTENSOR_VERSION_LINE)
+unset(_CUTENSOR_COMPONENT)
diff --git a/cmake/FindNCCL.cmake b/cmake/FindNCCL.cmake
@@ -0,0 +1,79 @@
+# Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+include(FindPackageHandleStandardArgs)
+
+set(_NCCL_ROOT "${NCCL_ROOT}")
+if (NOT _NCCL_ROOT AND NOT "$ENV{NCCL_ROOT}" STREQUAL "")
+  set(_NCCL_ROOT "$ENV{NCCL_ROOT}")
+elseif (NOT _NCCL_ROOT AND NOT "$ENV{NVCOMPILER_NCCL_HOME}" STREQUAL "")
+  set(_NCCL_ROOT "$ENV{NVCOMPILER_NCCL_HOME}")
+elseif (NOT _NCCL_ROOT AND NOT "$ENV{NVCOMPILER_COMM_LIBS_HOME}" STREQUAL "")
+  set(_NCCL_ROOT "$ENV{NVCOMPILER_COMM_LIBS_HOME}")
+endif()
+
+if (_NCCL_ROOT)
+  find_path(NCCL_INCLUDE_DIR
+    NAMES nccl.h
+    HINTS "${_NCCL_ROOT}"
+    PATH_SUFFIXES include nccl/include
+    NO_DEFAULT_PATH
+  )
+  find_library(NCCL_LIBRARY
+    NAMES nccl
+    HINTS "${_NCCL_ROOT}"
+    PATH_SUFFIXES lib lib64 nccl/lib nccl/lib64
+    NO_DEFAULT_PATH
+  )
+else()
+  set(_NCCL_NVHPC_ROOT
+      "${CUDECOMP_NVHPC_SDK_ROOT}/comm_libs/${CUDAToolkit_VERSION_MAJOR}.${CUDAToolkit_VERSION_MINOR}/nccl")
+  if (CUDECOMP_NVHPC_SDK_ROOT AND IS_DIRECTORY "${_NCCL_NVHPC_ROOT}")
+    list(APPEND _NCCL_PATHS "${_NCCL_NVHPC_ROOT}")
+  endif()
+  find_path(NCCL_INCLUDE_DIR
+    NAMES nccl.h
+    PATHS ${_NCCL_PATHS} ENV CPATH
+    PATH_SUFFIXES include
+  )
+  find_library(NCCL_LIBRARY
+    NAMES nccl
+    PATHS ${_NCCL_PATHS} ENV LIBRARY_PATH ENV LD_LIBRARY_PATH
+    PATH_SUFFIXES lib lib64
+  )
+endif()
+
+if (NCCL_INCLUDE_DIR)
+  file(STRINGS "${NCCL_INCLUDE_DIR}/nccl.h" _NCCL_VERSION_LINES
+       REGEX "^#define NCCL_(MAJOR|MINOR|PATCH) +[0-9]+$")
+  foreach(_NCCL_COMPONENT MAJOR MINOR PATCH)
+    string(REGEX MATCH "#define NCCL_${_NCCL_COMPONENT} +([0-9]+)" _NCCL_VERSION_LINE
+                 "${_NCCL_VERSION_LINES}")
+    set(NCCL_VERSION_${_NCCL_COMPONENT} "${CMAKE_MATCH_1}")
+  endforeach()
+  if (DEFINED NCCL_VERSION_MAJOR AND DEFINED NCCL_VERSION_MINOR AND DEFINED NCCL_VERSION_PATCH)
+    set(NCCL_VERSION "${NCCL_VERSION_MAJOR}.${NCCL_VERSION_MINOR}.${NCCL_VERSION_PATCH}")
+  endif()
+endif()
+
+find_package_handle_standard_args(NCCL
+  REQUIRED_VARS NCCL_LIBRARY NCCL_INCLUDE_DIR
+  VERSION_VAR NCCL_VERSION
+)
+
+if (NCCL_FOUND AND NOT TARGET NCCL::NCCL)
+  add_library(NCCL::NCCL UNKNOWN IMPORTED)
+  set_target_properties(NCCL::NCCL PROPERTIES
+    IMPORTED_LOCATION "${NCCL_LIBRARY}"
+    INTERFACE_INCLUDE_DIRECTORIES "${NCCL_INCLUDE_DIR}"
+  )
+endif()
+
+mark_as_advanced(NCCL_INCLUDE_DIR NCCL_LIBRARY)
+unset(_NCCL_ROOT)
+unset(_NCCL_NVHPC_ROOT)
+unset(_NCCL_PATHS)
+unset(_NCCL_VERSION_LINES)
+unset(_NCCL_VERSION_LINE)
+unset(_NCCL_COMPONENT)
diff --git a/cmake/FindNVSHMEM.cmake b/cmake/FindNVSHMEM.cmake
@@ -0,0 +1,81 @@
+# Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+include(FindPackageHandleStandardArgs)
+
+set(_NVSHMEM_ROOT "${NVSHMEM_ROOT}")
+if (NOT _NVSHMEM_ROOT AND NOT "$ENV{NVSHMEM_ROOT}" STREQUAL "")
+  set(_NVSHMEM_ROOT "$ENV{NVSHMEM_ROOT}")
+elseif (NOT _NVSHMEM_ROOT AND NOT "$ENV{NVCOMPILER_SHMEM_HOME}" STREQUAL "")
+  set(_NVSHMEM_ROOT "$ENV{NVCOMPILER_SHMEM_HOME}")
+elseif (NOT _NVSHMEM_ROOT AND NOT "$ENV{NVCOMPILER_COMM_LIBS_HOME}" STREQUAL "")
+  set(_NVSHMEM_ROOT "$ENV{NVCOMPILER_COMM_LIBS_HOME}")
+endif()
+
+if (_NVSHMEM_ROOT)
+  find_path(NVSHMEM_INCLUDE_DIR
+    NAMES nvshmem.h
+    HINTS "${_NVSHMEM_ROOT}"
+    PATH_SUFFIXES include nvshmem/include
+    NO_DEFAULT_PATH
+  )
+  find_library(NVSHMEM_HOST_LIBRARY
+    NAMES nvshmem_host
+    HINTS "${_NVSHMEM_ROOT}"
+    PATH_SUFFIXES lib lib64 nvshmem/lib nvshmem/lib64
+    NO_DEFAULT_PATH
+  )
+  find_library(NVSHMEM_DEVICE_LIBRARY
+    NAMES nvshmem_device
+    HINTS "${_NVSHMEM_ROOT}"
+    PATH_SUFFIXES lib lib64 nvshmem/lib nvshmem/lib64
+    NO_DEFAULT_PATH
+  )
+else()
+  set(_NVSHMEM_NVHPC_ROOT
+      "${CUDECOMP_NVHPC_SDK_ROOT}/comm_libs/${CUDAToolkit_VERSION_MAJOR}.${CUDAToolkit_VERSION_MINOR}/nvshmem")
+  if (CUDECOMP_NVHPC_SDK_ROOT AND IS_DIRECTORY "${_NVSHMEM_NVHPC_ROOT}")
+    list(APPEND _NVSHMEM_PATHS "${_NVSHMEM_NVHPC_ROOT}")
+  endif()
+  find_path(NVSHMEM_INCLUDE_DIR
+    NAMES nvshmem.h
+    PATHS ${_NVSHMEM_PATHS} ENV CPATH
+    PATH_SUFFIXES include
+  )
+  find_library(NVSHMEM_HOST_LIBRARY
+    NAMES nvshmem_host
+    PATHS ${_NVSHMEM_PATHS} ENV LIBRARY_PATH ENV LD_LIBRARY_PATH
+    PATH_SUFFIXES lib lib64
+  )
+  find_library(NVSHMEM_DEVICE_LIBRARY
+    NAMES nvshmem_device
+    PATHS ${_NVSHMEM_PATHS} ENV LIBRARY_PATH ENV LD_LIBRARY_PATH
+    PATH_SUFFIXES lib lib64
+  )
+endif()
+
+find_package_handle_standard_args(NVSHMEM
+  REQUIRED_VARS NVSHMEM_HOST_LIBRARY NVSHMEM_DEVICE_LIBRARY NVSHMEM_INCLUDE_DIR
+)
+
+if (NVSHMEM_FOUND AND NOT TARGET NVSHMEM::host)
+  add_library(NVSHMEM::host UNKNOWN IMPORTED)
+  set_target_properties(NVSHMEM::host PROPERTIES
+    IMPORTED_LOCATION "${NVSHMEM_HOST_LIBRARY}"
+    INTERFACE_INCLUDE_DIRECTORIES "${NVSHMEM_INCLUDE_DIR}"
+  )
+endif()
+
+if (NVSHMEM_FOUND AND NOT TARGET NVSHMEM::device)
+  add_library(NVSHMEM::device UNKNOWN IMPORTED)
+  set_target_properties(NVSHMEM::device PROPERTIES
+    IMPORTED_LOCATION "${NVSHMEM_DEVICE_LIBRARY}"
+    INTERFACE_INCLUDE_DIRECTORIES "${NVSHMEM_INCLUDE_DIR}"
+  )
+endif()
+
+mark_as_advanced(NVSHMEM_INCLUDE_DIR NVSHMEM_HOST_LIBRARY NVSHMEM_DEVICE_LIBRARY)
+unset(_NVSHMEM_ROOT)
+unset(_NVSHMEM_NVHPC_ROOT)
+unset(_NVSHMEM_PATHS)
diff --git a/examples/cc/basic_usage/CMakeLists.txt b/examples/cc/basic_usage/CMakeLists.txt
@@ -18,11 +18,7 @@ target_sources(basic_usage_autotune_cc
 foreach(tgt ${basic_usage_targets_cc})
   string(REPLACE "_cc" "" bin_name ${tgt})
   set_target_properties(${tgt} PROPERTIES OUTPUT_NAME ${bin_name})
-  if (CMAKE_VERSION VERSION_LESS 3.18)
-    target_compile_options(${tgt} PRIVATE $<$<COMPILE_LANGUAGE:CUDA>: ${CUDA_CC_FLAGS}>)
-  else()
-    set_target_properties(${tgt} PROPERTIES CUDA_ARCHITECTURES "${CUDECOMP_CUDA_CC_LIST}")
-  endif()
+  set_target_properties(${tgt} PROPERTIES CUDA_ARCHITECTURES "${CUDECOMP_CUDA_CC_LIST}")
   target_compile_options(${tgt} PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-Wno-deprecated-gpu-targets >)
   target_include_directories(${tgt}
     PRIVATE
@@ -36,5 +32,5 @@ endforeach()
 
 install(
   TARGETS ${basic_usage_targets_cc}
-  RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin/examples/cc/basic_usage
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}/examples/cc/basic_usage
 )
diff --git a/examples/cc/taylor_green/CMakeLists.txt b/examples/cc/taylor_green/CMakeLists.txt
@@ -5,26 +5,22 @@ target_sources(tg
   tg.cu
 )
 
-if (CMAKE_VERSION VERSION_LESS 3.18)
-  target_compile_options(tg PRIVATE $<$<COMPILE_LANGUAGE:CUDA>: ${CUDA_CC_FLAGS}>)
-else()
-  set_target_properties(tg PROPERTIES CUDA_ARCHITECTURES "${CUDECOMP_CUDA_CC_LIST}")
-endif()
+set_target_properties(tg PROPERTIES CUDA_ARCHITECTURES "${CUDECOMP_CUDA_CC_LIST}")
 target_compile_options(tg PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-Wno-deprecated-gpu-targets >)
 target_compile_options(tg PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-diag-suppress 177>) # Silence unused function warning
 
 target_include_directories(tg
   PRIVATE
   ${CMAKE_BINARY_DIR}/include
   ${MPI_CXX_INCLUDE_DIRS}
-  ${NVHPC_CUFFT_INCLUDE_DIR}
+  ${CUDECOMP_CUFFT_INCLUDE_DIR}
 )
 target_link_libraries(tg PRIVATE MPI::MPI_CXX)
-target_link_libraries(tg PRIVATE NVHPC::CUFFT)
+target_link_libraries(tg PRIVATE ${CUDECOMP_CUFFT_TARGET})
 target_link_libraries(tg PRIVATE cudecomp)
 set_target_properties(tg PROPERTIES LINKER_LANGUAGE CXX)
 
 install(
   TARGETS tg
-  RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin/examples/cc/taylor_green
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}/examples/cc/taylor_green
 )
diff --git a/examples/fortran/basic_usage/CMakeLists.txt b/examples/fortran/basic_usage/CMakeLists.txt
@@ -32,5 +32,5 @@ endforeach()
 
 install(
   TARGETS ${basic_usage_targets_f}
-  RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin/examples/fortran/basic_usage
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}/examples/fortran/basic_usage
 )
diff --git a/examples/fortran/poisson/CMakeLists.txt b/examples/fortran/poisson/CMakeLists.txt
@@ -8,16 +8,16 @@ target_include_directories(poisson
   PRIVATE
   ${CMAKE_BINARY_DIR}/include
   ${MPI_Fortran_INCLUDE_DIRS}
-  ${NVHPC_CUFFT_INCLUDE_DIR}
+  ${CUDECOMP_CUFFT_INCLUDE_DIR}
 )
 target_link_libraries(poisson PRIVATE MPI::MPI_Fortran)
-target_link_libraries(poisson PRIVATE NVHPC::CUFFT)
+target_link_libraries(poisson PRIVATE ${CUDECOMP_CUFFT_TARGET})
 target_link_libraries(poisson PRIVATE cudecomp)
 target_link_libraries(poisson PRIVATE cudecomp_fort)
 target_compile_options(poisson PRIVATE $<$<COMPILE_LANGUAGE:Fortran>:-cpp -cuda -gpu=${CUF_GPU_ARG}>)
 target_link_options(poisson PRIVATE $<$<COMPILE_LANGUAGE:Fortran>:-cpp -cuda -gpu=${CUF_GPU_ARG}>)
 
 install(
   TARGETS poisson
-  RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin/examples/fortran/poisson
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}/examples/fortran/poisson
 )