diff --git a/Samples/0_Introduction/CMakeLists.txt b/Samples/0_Introduction/CMakeLists.txt
index 6f1823dd..0ae2d30f 100644
--- a/Samples/0_Introduction/CMakeLists.txt
+++ b/Samples/0_Introduction/CMakeLists.txt
@@ -6,18 +6,11 @@ project(simpleCallback LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 
 add_subdirectory(UnifiedMemoryStreams)
 add_subdirectory(asyncAPI)
diff --git a/Samples/0_Introduction/UnifiedMemoryStreams/CMakeLists.txt b/Samples/0_Introduction/UnifiedMemoryStreams/CMakeLists.txt
index 48e4a7a7..470f7834 100644
--- a/Samples/0_Introduction/UnifiedMemoryStreams/CMakeLists.txt
+++ b/Samples/0_Introduction/UnifiedMemoryStreams/CMakeLists.txt
@@ -6,31 +6,25 @@ project(UnifiedMemoryStreams LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    UnifiedMemoryStreams.cu
-)
-
 find_package(OpenMP REQUIRED)
 
 if(${OpenMP_FOUND})
     # Add target for UnifiedMemoryStreams
-    add_executable(UnifiedMemoryStreams ${SRC_FILES})
+    add_executable(UnifiedMemoryStreams UnifiedMemoryStreams.cu)
+
+target_compile_options(UnifiedMemoryStreams PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(UnifiedMemoryStreams PRIVATE cxx_std_17 cuda_std_17)
+
     set_target_properties(UnifiedMemoryStreams PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
     target_link_libraries(UnifiedMemoryStreams PUBLIC
diff --git a/Samples/0_Introduction/asyncAPI/CMakeLists.txt b/Samples/0_Introduction/asyncAPI/CMakeLists.txt
index f26a5dd3..7625809a 100644
--- a/Samples/0_Introduction/asyncAPI/CMakeLists.txt
+++ b/Samples/0_Introduction/asyncAPI/CMakeLists.txt
@@ -6,26 +6,20 @@ project(asyncAPI LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    asyncAPI.cu
-)
-
 # Add target for asyncAPI
-add_executable(asyncAPI ${SRC_FILES})
+add_executable(asyncAPI asyncAPI.cu)
+
+target_compile_options(asyncAPI PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(asyncAPI PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(asyncAPI PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/clock/CMakeLists.txt b/Samples/0_Introduction/clock/CMakeLists.txt
index b8eccff0..7f6ad6b1 100644
--- a/Samples/0_Introduction/clock/CMakeLists.txt
+++ b/Samples/0_Introduction/clock/CMakeLists.txt
@@ -6,26 +6,20 @@ project(clock LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    clock.cu
-)
-
 # Add target for asyncAPI
-add_executable(clock ${SRC_FILES})
+add_executable(clock clock.cu)
+
+target_compile_options(clock PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(clock PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(clock PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/clock_nvrtc/CMakeLists.txt b/Samples/0_Introduction/clock_nvrtc/CMakeLists.txt
index 0d57ddfd..3be02ac0 100644
--- a/Samples/0_Introduction/clock_nvrtc/CMakeLists.txt
+++ b/Samples/0_Introduction/clock_nvrtc/CMakeLists.txt
@@ -6,28 +6,22 @@ project(clock_nvrtc LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    clock.cpp
-)
-
 # Add sample target executable
-add_executable(clock_nvrtc ${SRC_FILES})
+add_executable(clock_nvrtc clock.cpp)
+
+target_compile_options(clock_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(clock_nvrtc PRIVATE cxx_std_17 cuda_std_17)
+
 target_link_libraries(clock_nvrtc PRIVATE
     CUDA::nvrtc
 )
diff --git a/Samples/0_Introduction/cudaOpenMP/CMakeLists.txt b/Samples/0_Introduction/cudaOpenMP/CMakeLists.txt
index 9b53b427..38b27810 100644
--- a/Samples/0_Introduction/cudaOpenMP/CMakeLists.txt
+++ b/Samples/0_Introduction/cudaOpenMP/CMakeLists.txt
@@ -6,31 +6,25 @@ project(cudaOpenMP LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 find_package(OpenMP)
 
 # Source file
-set(SRC_FILES
-    cudaOpenMP.cu
-)
-
 if(OpenMP_CXX_FOUND)
 # Add target for asyncAPI
-    add_executable(cudaOpenMP ${SRC_FILES})
+    add_executable(cudaOpenMP cudaOpenMP.cu)
+
+target_compile_options(cudaOpenMP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(cudaOpenMP PRIVATE cxx_std_17 cuda_std_17)
+
     set_target_properties(cudaOpenMP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
     target_link_libraries(cudaOpenMP PUBLIC
         OpenMP::OpenMP_CXX
diff --git a/Samples/0_Introduction/fp16ScalarProduct/CMakeLists.txt b/Samples/0_Introduction/fp16ScalarProduct/CMakeLists.txt
index f06e6419..543810f5 100644
--- a/Samples/0_Introduction/fp16ScalarProduct/CMakeLists.txt
+++ b/Samples/0_Introduction/fp16ScalarProduct/CMakeLists.txt
@@ -6,26 +6,20 @@ project(fp16ScalarProduct LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    fp16ScalarProduct.cu
-)
-
 # Add target for asyncAPI
-add_executable(fp16ScalarProduct ${SRC_FILES})
+add_executable(fp16ScalarProduct fp16ScalarProduct.cu)
+
+target_compile_options(fp16ScalarProduct PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(fp16ScalarProduct PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(fp16ScalarProduct PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/matrixMul/CMakeLists.txt b/Samples/0_Introduction/matrixMul/CMakeLists.txt
index 30b78d0c..cfa3b181 100644
--- a/Samples/0_Introduction/matrixMul/CMakeLists.txt
+++ b/Samples/0_Introduction/matrixMul/CMakeLists.txt
@@ -6,26 +6,20 @@ project(matrixMul LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    matrixMul.cu
-)
-
 # Add target for asyncAPI
-add_executable(matrixMul ${SRC_FILES})
+add_executable(matrixMul matrixMul.cu)
+
+target_compile_options(matrixMul PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(matrixMul PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(matrixMul PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/matrixMulDrv/CMakeLists.txt b/Samples/0_Introduction/matrixMulDrv/CMakeLists.txt
index 40f3c0e7..c2cb9ba7 100644
--- a/Samples/0_Introduction/matrixMulDrv/CMakeLists.txt
+++ b/Samples/0_Introduction/matrixMulDrv/CMakeLists.txt
@@ -6,28 +6,22 @@ project(matrixMulDrv LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    matrixMulDrv.cpp
-)
-
 # Add target for matrixMulDrv
-add_executable(matrixMulDrv ${SRC_FILES})
+add_executable(matrixMulDrv matrixMulDrv.cpp)
+
+target_compile_options(matrixMulDrv PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(matrixMulDrv PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(matrixMulDrv PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
 target_include_directories(matrixMulDrv PRIVATE
diff --git a/Samples/0_Introduction/matrixMulDynlinkJIT/CMakeLists.txt b/Samples/0_Introduction/matrixMulDynlinkJIT/CMakeLists.txt
index 430c9fcf..ea2f6221 100644
--- a/Samples/0_Introduction/matrixMulDynlinkJIT/CMakeLists.txt
+++ b/Samples/0_Introduction/matrixMulDynlinkJIT/CMakeLists.txt
@@ -6,34 +6,22 @@ project(matrixMulDynlinkJIT LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    cuda_drvapi_dynlink.c
-    matrixMulDynlinkJIT.cpp
-    matrixMul_gold.cpp
-    matrixMul_kernel_32_ptxdump.c
-    matrixMul_kernel_64_ptxdump.c
-)
-
-
-
 # Add target for matrixMulDynlinkJIT
-add_executable(matrixMulDynlinkJIT ${SRC_FILES})
+add_executable(matrixMulDynlinkJIT cuda_drvapi_dynlink.c matrixMulDynlinkJIT.cpp matrixMul_gold.cpp matrixMul_kernel_32_ptxdump.c matrixMul_kernel_64_ptxdump.c)
+
+target_compile_options(matrixMulDynlinkJIT PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(matrixMulDynlinkJIT PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(matrixMulDynlinkJIT PROPERTIES
     CUDA_SEPARABLE_COMPILATION ON
     POSITION_INDEPENDENT_CODE OFF
diff --git a/Samples/0_Introduction/matrixMul_nvrtc/CMakeLists.txt b/Samples/0_Introduction/matrixMul_nvrtc/CMakeLists.txt
index cd3c6540..f2c936f4 100644
--- a/Samples/0_Introduction/matrixMul_nvrtc/CMakeLists.txt
+++ b/Samples/0_Introduction/matrixMul_nvrtc/CMakeLists.txt
@@ -6,28 +6,22 @@ project(matrixMul_nvrtc LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    matrixMul.cpp
-)
-
 # Add sample target executable
-add_executable(matrixMul_nvrtc ${SRC_FILES})
+add_executable(matrixMul_nvrtc matrixMul.cpp)
+
+target_compile_options(matrixMul_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(matrixMul_nvrtc PRIVATE cxx_std_17 cuda_std_17)
+
 target_link_libraries(matrixMul_nvrtc PRIVATE
     CUDA::nvrtc
 )
diff --git a/Samples/0_Introduction/mergeSort/CMakeLists.txt b/Samples/0_Introduction/mergeSort/CMakeLists.txt
index ebdb13cb..d0843206 100644
--- a/Samples/0_Introduction/mergeSort/CMakeLists.txt
+++ b/Samples/0_Introduction/mergeSort/CMakeLists.txt
@@ -6,31 +6,22 @@ project(mergeSort LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    mergeSort.cu
-    main.cpp
-    mergeSort_host.cpp
-    mergeSort_validate.cpp
-)
-
 # Add target for mergeSort
-add_executable(mergeSort ${SRC_FILES})
+add_executable(mergeSort mergeSort.cu main.cpp mergeSort_host.cpp mergeSort_validate.cpp)
+
+target_compile_options(mergeSort PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(mergeSort PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(mergeSort PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 target_include_directories(mergeSort PRIVATE
     ${CUDAToolkit_INCLUDE_DIRS}
diff --git a/Samples/0_Introduction/simpleAWBarrier/CMakeLists.txt b/Samples/0_Introduction/simpleAWBarrier/CMakeLists.txt
index abb1b853..b44725fd 100644
--- a/Samples/0_Introduction/simpleAWBarrier/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleAWBarrier/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleAWBarrier LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleAWBarrier.cu
-)
-
 # Add target for simpleAWBarrier
-add_executable(simpleAWBarrier ${SRC_FILES})
+add_executable(simpleAWBarrier simpleAWBarrier.cu)
+
+target_compile_options(simpleAWBarrier PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleAWBarrier PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleAWBarrier PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleAssert/CMakeLists.txt b/Samples/0_Introduction/simpleAssert/CMakeLists.txt
index 9d175d94..f3df5d16 100644
--- a/Samples/0_Introduction/simpleAssert/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleAssert/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleAssert LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleAssert.cu
-)
-
 # Add target for simpleAssert
-add_executable(simpleAssert ${SRC_FILES})
+add_executable(simpleAssert simpleAssert.cu)
+
+target_compile_options(simpleAssert PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleAssert PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleAssert PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleAssert_nvrtc/CMakeLists.txt b/Samples/0_Introduction/simpleAssert_nvrtc/CMakeLists.txt
index 5074b57f..3d9c8bb2 100644
--- a/Samples/0_Introduction/simpleAssert_nvrtc/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleAssert_nvrtc/CMakeLists.txt
@@ -6,28 +6,22 @@ project(simpleAssert_nvrtc LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleAssert.cpp
-)
-
 # Add sample target executable
-add_executable(simpleAssert_nvrtc ${SRC_FILES})
+add_executable(simpleAssert_nvrtc simpleAssert.cpp)
+
+target_compile_options(simpleAssert_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleAssert_nvrtc PRIVATE cxx_std_17 cuda_std_17)
+
 target_link_libraries(simpleAssert_nvrtc PRIVATE
     CUDA::nvrtc
 )
diff --git a/Samples/0_Introduction/simpleAtomicIntrinsics/CMakeLists.txt b/Samples/0_Introduction/simpleAtomicIntrinsics/CMakeLists.txt
index 45ce4e8d..76b11433 100644
--- a/Samples/0_Introduction/simpleAtomicIntrinsics/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleAtomicIntrinsics/CMakeLists.txt
@@ -6,27 +6,20 @@ project(simpleAtomicIntrinsics LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleAtomicIntrinsics.cu
-    simpleAtomicIntrinsics_cpu.cpp
-)
-
 # Add target for simpleAtomicIntrinsics
-add_executable(simpleAtomicIntrinsics ${SRC_FILES})
+add_executable(simpleAtomicIntrinsics simpleAtomicIntrinsics.cu simpleAtomicIntrinsics_cpu.cpp)
+
+target_compile_options(simpleAtomicIntrinsics PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleAtomicIntrinsics PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleAtomicIntrinsics PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleAtomicIntrinsics_nvrtc/CMakeLists.txt b/Samples/0_Introduction/simpleAtomicIntrinsics_nvrtc/CMakeLists.txt
index a4c545c8..928fb0ee 100644
--- a/Samples/0_Introduction/simpleAtomicIntrinsics_nvrtc/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleAtomicIntrinsics_nvrtc/CMakeLists.txt
@@ -6,29 +6,22 @@ project(simpleAtomicIntrinsics_nvrtc LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleAtomicIntrinsics_cpu.cpp
-    simpleAtomicIntrinsics.cpp
-)
-
 # Add sample target executable
-add_executable(simpleAtomicIntrinsics_nvrtc ${SRC_FILES})
+add_executable(simpleAtomicIntrinsics_nvrtc simpleAtomicIntrinsics_cpu.cpp simpleAtomicIntrinsics.cpp)
+
+target_compile_options(simpleAtomicIntrinsics_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleAtomicIntrinsics_nvrtc PRIVATE cxx_std_17 cuda_std_17)
+
 target_link_libraries(simpleAtomicIntrinsics_nvrtc PRIVATE
     CUDA::nvrtc
 )
diff --git a/Samples/0_Introduction/simpleAttributes/CMakeLists.txt b/Samples/0_Introduction/simpleAttributes/CMakeLists.txt
index 1b330cbd..630f66c2 100644
--- a/Samples/0_Introduction/simpleAttributes/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleAttributes/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleAttributes LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleAttributes.cu
-)
-
 # Add target for simpleAttributes
-add_executable(simpleAttributes ${SRC_FILES})
+add_executable(simpleAttributes simpleAttributes.cu)
+
+target_compile_options(simpleAttributes PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleAttributes PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleAttributes PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleCUDA2GL/CMakeLists.txt b/Samples/0_Introduction/simpleCUDA2GL/CMakeLists.txt
index 26631841..bab3bea7 100644
--- a/Samples/0_Introduction/simpleCUDA2GL/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleCUDA2GL/CMakeLists.txt
@@ -6,18 +6,11 @@ project(simpleCUDA2GL LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
@@ -25,16 +18,15 @@ find_package(OpenGL)
 find_package(GLUT)
 
 # Source file
-set(SRC_FILES
-    simpleCUDA2GL.cu
-    main.cpp
-)
-
-
 if(${OpenGL_FOUND})
     if (${GLUT_FOUND})
         # Add target for simpleCUDA2GL
-        add_executable(simpleCUDA2GL ${SRC_FILES})
+        add_executable(simpleCUDA2GL simpleCUDA2GL.cu main.cpp)
+
+target_compile_options(simpleCUDA2GL PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCUDA2GL PRIVATE cxx_std_17 cuda_std_17)
+
         set_target_properties(simpleCUDA2GL PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
         target_include_directories(simpleCUDA2GL PUBLIC
diff --git a/Samples/0_Introduction/simpleCallback/CMakeLists.txt b/Samples/0_Introduction/simpleCallback/CMakeLists.txt
index 8d7cab7f..5dae6646 100644
--- a/Samples/0_Introduction/simpleCallback/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleCallback/CMakeLists.txt
@@ -6,27 +6,20 @@ project(simpleCallback LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleCallback.cu
-    multithreading.cpp
-)
-
 # Add target for simpleCallback
-add_executable(simpleCallback ${SRC_FILES})
+add_executable(simpleCallback simpleCallback.cu multithreading.cpp)
+
+target_compile_options(simpleCallback PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCallback PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCallback PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleCooperativeGroups/CMakeLists.txt b/Samples/0_Introduction/simpleCooperativeGroups/CMakeLists.txt
index c99c2f77..8459b54c 100644
--- a/Samples/0_Introduction/simpleCooperativeGroups/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleCooperativeGroups/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleCooperativeGroups LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleCooperativeGroups.cu
-)
-
 # Add target for simpleCooperativeGroups
-add_executable(simpleCooperativeGroups ${SRC_FILES})
+add_executable(simpleCooperativeGroups simpleCooperativeGroups.cu)
+
+target_compile_options(simpleCooperativeGroups PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCooperativeGroups PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCooperativeGroups PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleCubemapTexture/CMakeLists.txt b/Samples/0_Introduction/simpleCubemapTexture/CMakeLists.txt
index e2c6fe37..50277e0d 100644
--- a/Samples/0_Introduction/simpleCubemapTexture/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleCubemapTexture/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleCubemapTexture LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleCubemapTexture.cu
-)
-
 # Add target for simpleCubemapTexture
-add_executable(simpleCubemapTexture ${SRC_FILES})
+add_executable(simpleCubemapTexture simpleCubemapTexture.cu)
+
+target_compile_options(simpleCubemapTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleCubemapTexture PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleCubemapTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleDrvRuntime/CMakeLists.txt b/Samples/0_Introduction/simpleDrvRuntime/CMakeLists.txt
index 0c3b2b1e..83cd6258 100644
--- a/Samples/0_Introduction/simpleDrvRuntime/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleDrvRuntime/CMakeLists.txt
@@ -6,29 +6,24 @@ project(simpleDrvRuntime LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleDrvRuntime.cpp
-)
-
 # Add target for simpleDrvRuntime
-add_executable(simpleDrvRuntime ${SRC_FILES})
+add_executable(simpleDrvRuntime simpleDrvRuntime.cpp)
+
+target_compile_options(simpleDrvRuntime PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleDrvRuntime PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleDrvRuntime PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
 target_include_directories(simpleDrvRuntime PRIVATE
     ${CUDAToolkit_INCLUDE_DIRS}
 )
diff --git a/Samples/0_Introduction/simpleHyperQ/CMakeLists.txt b/Samples/0_Introduction/simpleHyperQ/CMakeLists.txt
index f6b74620..7f1157b9 100644
--- a/Samples/0_Introduction/simpleHyperQ/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleHyperQ/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleHyperQ LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleHyperQ.cu
-)
-
 # Add target for simpleHyperQ
-add_executable(simpleHyperQ ${SRC_FILES})
+add_executable(simpleHyperQ simpleHyperQ.cu)
+
+target_compile_options(simpleHyperQ PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleHyperQ PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleHyperQ PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleIPC/CMakeLists.txt b/Samples/0_Introduction/simpleIPC/CMakeLists.txt
index efd89142..cefd36f8 100644
--- a/Samples/0_Introduction/simpleIPC/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleIPC/CMakeLists.txt
@@ -6,27 +6,20 @@ project(simpleIPC LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleIPC.cu
-    ../../../Common/helper_multiprocess.cpp
-)
-
 # Add target for simpleIPC
-add_executable(simpleIPC ${SRC_FILES})
+add_executable(simpleIPC simpleIPC.cu ../../../Common/helper_multiprocess.cpp)
+
+target_compile_options(simpleIPC PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleIPC PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleIPC PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleLayeredTexture/CMakeLists.txt b/Samples/0_Introduction/simpleLayeredTexture/CMakeLists.txt
index 6a1a199d..772ed79c 100644
--- a/Samples/0_Introduction/simpleLayeredTexture/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleLayeredTexture/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleLayeredTexture LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleLayeredTexture.cu
-)
-
 # Add target for simpleLayeredTexture
-add_executable(simpleLayeredTexture ${SRC_FILES})
+add_executable(simpleLayeredTexture simpleLayeredTexture.cu)
+
+target_compile_options(simpleLayeredTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleLayeredTexture PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleLayeredTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleMPI/CMakeLists.txt b/Samples/0_Introduction/simpleMPI/CMakeLists.txt
index ffe162df..87d64144 100644
--- a/Samples/0_Introduction/simpleMPI/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleMPI/CMakeLists.txt
@@ -6,32 +6,25 @@ project(simpleMPI LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 find_package(MPI)
 
 # Source file
-set(SRC_FILES
-    simpleMPI.cpp
-    simpleMPI.cu
-)
-
 if(${MPI_FOUND})
     # Add target for simpleMPI
-    add_executable(simpleMPI ${SRC_FILES})
+    add_executable(simpleMPI simpleMPI.cpp simpleMPI.cu)
+
+target_compile_options(simpleMPI PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleMPI PRIVATE cxx_std_17 cuda_std_17)
+
     set_target_properties(simpleMPI PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
     target_include_directories(simpleMPI PUBLIC
diff --git a/Samples/0_Introduction/simpleMultiCopy/CMakeLists.txt b/Samples/0_Introduction/simpleMultiCopy/CMakeLists.txt
index f7390dc4..28734922 100644
--- a/Samples/0_Introduction/simpleMultiCopy/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleMultiCopy/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleMultiCopy LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleMultiCopy.cu
-)
-
 # Add target for simpleMultiCopy
-add_executable(simpleMultiCopy ${SRC_FILES})
+add_executable(simpleMultiCopy simpleMultiCopy.cu)
+
+target_compile_options(simpleMultiCopy PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleMultiCopy PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleMultiCopy PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleMultiGPU/CMakeLists.txt b/Samples/0_Introduction/simpleMultiGPU/CMakeLists.txt
index a060abea..e77c5ddc 100644
--- a/Samples/0_Introduction/simpleMultiGPU/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleMultiGPU/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleMultiGPU LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleMultiGPU.cu
-)
-
 # Add target for simpleMultiGPU
-add_executable(simpleMultiGPU ${SRC_FILES})
+add_executable(simpleMultiGPU simpleMultiGPU.cu)
+
+target_compile_options(simpleMultiGPU PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleMultiGPU PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleMultiGPU PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleOccupancy/CMakeLists.txt b/Samples/0_Introduction/simpleOccupancy/CMakeLists.txt
index 22b0cb28..d842a78b 100644
--- a/Samples/0_Introduction/simpleOccupancy/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleOccupancy/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleOccupancy LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleOccupancy.cu
-)
-
 # Add target for simpleOccupancy
-add_executable(simpleOccupancy ${SRC_FILES})
+add_executable(simpleOccupancy simpleOccupancy.cu)
+
+target_compile_options(simpleOccupancy PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleOccupancy PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleOccupancy PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleP2P/CMakeLists.txt b/Samples/0_Introduction/simpleP2P/CMakeLists.txt
index 9d486c07..e310bd7a 100644
--- a/Samples/0_Introduction/simpleP2P/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleP2P/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleP2P LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleP2P.cu
-)
-
 # Add target for simpleP2P
-add_executable(simpleP2P ${SRC_FILES})
+add_executable(simpleP2P simpleP2P.cu)
+
+target_compile_options(simpleP2P PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleP2P PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleP2P PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simplePitchLinearTexture/CMakeLists.txt b/Samples/0_Introduction/simplePitchLinearTexture/CMakeLists.txt
index 980d488e..0e8e93d2 100644
--- a/Samples/0_Introduction/simplePitchLinearTexture/CMakeLists.txt
+++ b/Samples/0_Introduction/simplePitchLinearTexture/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simplePitchLinearTexture LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simplePitchLinearTexture.cu
-)
-
 # Add target for simplePitchLinearTexture
-add_executable(simplePitchLinearTexture ${SRC_FILES})
+add_executable(simplePitchLinearTexture simplePitchLinearTexture.cu)
+
+target_compile_options(simplePitchLinearTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simplePitchLinearTexture PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simplePitchLinearTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simplePrintf/CMakeLists.txt b/Samples/0_Introduction/simplePrintf/CMakeLists.txt
index 6eecedba..e012c093 100644
--- a/Samples/0_Introduction/simplePrintf/CMakeLists.txt
+++ b/Samples/0_Introduction/simplePrintf/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simplePrintf LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simplePrintf.cu
-)
-
 # Add target for simplePrintf
-add_executable(simplePrintf ${SRC_FILES})
+add_executable(simplePrintf simplePrintf.cu)
+
+target_compile_options(simplePrintf PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simplePrintf PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simplePrintf PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleStreams/CMakeLists.txt b/Samples/0_Introduction/simpleStreams/CMakeLists.txt
index 1dc33372..cc6250bd 100644
--- a/Samples/0_Introduction/simpleStreams/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleStreams/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleStreams LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleStreams.cu
-)
-
 # Add target for simpleStreams
-add_executable(simpleStreams ${SRC_FILES})
+add_executable(simpleStreams simpleStreams.cu)
+
+target_compile_options(simpleStreams PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleStreams PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleStreams PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleSurfaceWrite/CMakeLists.txt b/Samples/0_Introduction/simpleSurfaceWrite/CMakeLists.txt
index c8606424..4550c29b 100644
--- a/Samples/0_Introduction/simpleSurfaceWrite/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleSurfaceWrite/CMakeLists.txt
@@ -6,28 +6,22 @@ project(simpleSurfaceWrite LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleSurfaceWrite.cu
-)
-
 # Add target for simpleSurfaceWrite
-add_executable(simpleSurfaceWrite ${SRC_FILES})
+add_executable(simpleSurfaceWrite simpleSurfaceWrite.cu)
+
+target_compile_options(simpleSurfaceWrite PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleSurfaceWrite PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleSurfaceWrite PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
 # Copy data to the output directory
diff --git a/Samples/0_Introduction/simpleTemplates/CMakeLists.txt b/Samples/0_Introduction/simpleTemplates/CMakeLists.txt
index 0bde5c56..cbaff88a 100644
--- a/Samples/0_Introduction/simpleTemplates/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleTemplates/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleTemplates LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleTemplates.cu
-)
-
 # Add target for simpleTemplates
-add_executable(simpleTemplates ${SRC_FILES})
+add_executable(simpleTemplates simpleTemplates.cu)
+
+target_compile_options(simpleTemplates PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleTemplates PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleTemplates PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleTexture/CMakeLists.txt b/Samples/0_Introduction/simpleTexture/CMakeLists.txt
index 5e720585..f2ac9dc3 100644
--- a/Samples/0_Introduction/simpleTexture/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleTexture/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleTexture LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleTexture.cu
-)
-
 # Add target for simpleTexture
-add_executable(simpleTexture ${SRC_FILES})
+add_executable(simpleTexture simpleTexture.cu)
+
+target_compile_options(simpleTexture PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleTexture PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleTexture PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleTexture3D/CMakeLists.txt b/Samples/0_Introduction/simpleTexture3D/CMakeLists.txt
index ebb4af60..6ee55ec2 100644
--- a/Samples/0_Introduction/simpleTexture3D/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleTexture3D/CMakeLists.txt
@@ -6,18 +6,11 @@ project(simpleTexture3D LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
@@ -25,15 +18,15 @@ find_package(OpenGL)
 find_package(GLUT)
 
 # Source file
-set(SRC_FILES
-    simpleTexture3D_kernel.cu
-    simpleTexture3D.cpp
-)
-
 if(${OpenGL_FOUND})
     if (${GLUT_FOUND})
         # Add target for simpleTexture3D
-        add_executable(simpleTexture3D ${SRC_FILES})
+        add_executable(simpleTexture3D simpleTexture3D_kernel.cu simpleTexture3D.cpp)
+
+target_compile_options(simpleTexture3D PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleTexture3D PRIVATE cxx_std_17 cuda_std_17)
+
         set_target_properties(simpleTexture3D PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
         target_include_directories(simpleTexture3D PUBLIC
diff --git a/Samples/0_Introduction/simpleTextureDrv/CMakeLists.txt b/Samples/0_Introduction/simpleTextureDrv/CMakeLists.txt
index 88eced5a..135179e7 100644
--- a/Samples/0_Introduction/simpleTextureDrv/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleTextureDrv/CMakeLists.txt
@@ -6,28 +6,22 @@ project(simpleTextureDrv LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleTextureDrv.cpp
-)
-
 # Add target for simpleTextureDrv
-add_executable(simpleTextureDrv ${SRC_FILES})
+add_executable(simpleTextureDrv simpleTextureDrv.cpp)
+
+target_compile_options(simpleTextureDrv PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleTextureDrv PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleTextureDrv PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 target_include_directories(simpleTextureDrv PRIVATE
     ${CUDAToolkit_INCLUDE_DIRS}
diff --git a/Samples/0_Introduction/simpleVoteIntrinsics/CMakeLists.txt b/Samples/0_Introduction/simpleVoteIntrinsics/CMakeLists.txt
index f5942771..641087ff 100644
--- a/Samples/0_Introduction/simpleVoteIntrinsics/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleVoteIntrinsics/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleVoteIntrinsics LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleVoteIntrinsics.cu
-)
-
 # Add target for simpleVoteIntrinsics
-add_executable(simpleVoteIntrinsics ${SRC_FILES})
+add_executable(simpleVoteIntrinsics simpleVoteIntrinsics.cu)
+
+target_compile_options(simpleVoteIntrinsics PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleVoteIntrinsics PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleVoteIntrinsics PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/simpleZeroCopy/CMakeLists.txt b/Samples/0_Introduction/simpleZeroCopy/CMakeLists.txt
index d0f5f38a..18dba6eb 100644
--- a/Samples/0_Introduction/simpleZeroCopy/CMakeLists.txt
+++ b/Samples/0_Introduction/simpleZeroCopy/CMakeLists.txt
@@ -6,26 +6,20 @@ project(simpleZeroCopy LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    simpleZeroCopy.cu
-)
-
 # Add target for simpleZeroCopy
-add_executable(simpleZeroCopy ${SRC_FILES})
+add_executable(simpleZeroCopy simpleZeroCopy.cu)
+
+target_compile_options(simpleZeroCopy PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(simpleZeroCopy PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(simpleZeroCopy PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/systemWideAtomics/CMakeLists.txt b/Samples/0_Introduction/systemWideAtomics/CMakeLists.txt
index ee0a8f3e..5773f994 100644
--- a/Samples/0_Introduction/systemWideAtomics/CMakeLists.txt
+++ b/Samples/0_Introduction/systemWideAtomics/CMakeLists.txt
@@ -6,26 +6,20 @@ project(systemWideAtomics LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    systemWideAtomics.cu
-)
-
 # Add target for systemWideAtomics
-add_executable(systemWideAtomics ${SRC_FILES})
+add_executable(systemWideAtomics systemWideAtomics.cu)
+
+target_compile_options(systemWideAtomics PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(systemWideAtomics PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(systemWideAtomics PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/template/CMakeLists.txt b/Samples/0_Introduction/template/CMakeLists.txt
index a4950144..e38519dc 100644
--- a/Samples/0_Introduction/template/CMakeLists.txt
+++ b/Samples/0_Introduction/template/CMakeLists.txt
@@ -6,27 +6,21 @@ project(template LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    template.cu
-)
-
 # Add target for template
-add_executable(template ${SRC_FILES})
+add_executable(template template.cu)
+
+target_compile_options(template PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(template PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(template PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/vectorAdd/CMakeLists.txt b/Samples/0_Introduction/vectorAdd/CMakeLists.txt
index 4f3fb548..8a3d1e12 100644
--- a/Samples/0_Introduction/vectorAdd/CMakeLists.txt
+++ b/Samples/0_Introduction/vectorAdd/CMakeLists.txt
@@ -6,26 +6,20 @@ project(vectorAdd LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    vectorAdd.cu
-)
-
 # Add target for vectorAdd
-add_executable(vectorAdd ${SRC_FILES})
+add_executable(vectorAdd vectorAdd.cu)
+
+target_compile_options(vectorAdd PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(vectorAdd PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(vectorAdd PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
diff --git a/Samples/0_Introduction/vectorAddDrv/CMakeLists.txt b/Samples/0_Introduction/vectorAddDrv/CMakeLists.txt
index 2626bc7e..7105513e 100644
--- a/Samples/0_Introduction/vectorAddDrv/CMakeLists.txt
+++ b/Samples/0_Introduction/vectorAddDrv/CMakeLists.txt
@@ -6,28 +6,22 @@ project(vectorAddDrv LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    vectorAddDrv.cpp
-)
-
 # Add target for vectorAddDrv
-add_executable(vectorAddDrv ${SRC_FILES})
+add_executable(vectorAddDrv vectorAddDrv.cpp)
+
+target_compile_options(vectorAddDrv PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(vectorAddDrv PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(vectorAddDrv PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 target_include_directories(vectorAddDrv PRIVATE
     ${CUDAToolkit_INCLUDE_DIRS}
diff --git a/Samples/0_Introduction/vectorAddMMAP/CMakeLists.txt b/Samples/0_Introduction/vectorAddMMAP/CMakeLists.txt
index d9d65000..403b36d6 100644
--- a/Samples/0_Introduction/vectorAddMMAP/CMakeLists.txt
+++ b/Samples/0_Introduction/vectorAddMMAP/CMakeLists.txt
@@ -6,29 +6,22 @@ project(vectorAddMMAP LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    vectorAddMMAP.cpp
-    multidevicealloc_memmap.cpp
-)
-
 # Add target for vectorAddMMAP
-add_executable(vectorAddMMAP ${SRC_FILES})
+add_executable(vectorAddMMAP vectorAddMMAP.cpp multidevicealloc_memmap.cpp)
+
+target_compile_options(vectorAddMMAP PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(vectorAddMMAP PRIVATE cxx_std_17 cuda_std_17)
+
 set_target_properties(vectorAddMMAP PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 target_include_directories(vectorAddMMAP PRIVATE
     ${CUDAToolkit_INCLUDE_DIRS}
diff --git a/Samples/0_Introduction/vectorAdd_nvrtc/CMakeLists.txt b/Samples/0_Introduction/vectorAdd_nvrtc/CMakeLists.txt
index be31140b..1babe2a7 100644
--- a/Samples/0_Introduction/vectorAdd_nvrtc/CMakeLists.txt
+++ b/Samples/0_Introduction/vectorAdd_nvrtc/CMakeLists.txt
@@ -6,28 +6,22 @@ project(vectorAdd_nvrtc LANGUAGES C CXX CUDA)
 
 find_package(CUDAToolkit REQUIRED)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(CMAKE_CUDA_STANDARD 17)
-set(CMAKE_CUDA_STANDARD_REQUIRED ON)
-
 set(CMAKE_CUDA_ARCHITECTURES "native")
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     # set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G")  # enable cuda-gdb (expensive)
 endif()
 
-set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda")
 # Include directories and libraries
 include_directories(../../../Common)
 
 # Source file
-set(SRC_FILES
-    vectorAdd.cpp
-)
-
 # Add sample target executable
-add_executable(vectorAdd_nvrtc ${SRC_FILES})
+add_executable(vectorAdd_nvrtc vectorAdd.cpp)
+
+target_compile_options(vectorAdd_nvrtc PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
+
+target_compile_features(vectorAdd_nvrtc PRIVATE cxx_std_17 cuda_std_17)
+
 target_link_libraries(vectorAdd_nvrtc PRIVATE
     CUDA::nvrtc
 )