Merge ~bullwinkle-team/ubuntu/+source/rocrand:bullwinkle/llvm-21/ubuntu/devel into ubuntu/+source/rocrand:ubuntu/devel

[Talha Can Havadar]

See the build in this ppa: https://launchpad.net/~tchavadar/+archive/ubuntu/mp499170/+packages
  - all archs and -proposed enabled

Because of this particular bug in llvm-toolchain https://bugs.launchpad.net/ubuntu/+source/llvm-toolchain-21/+bug/2138890 (due to python 3.14 migration in the archive) I needed to add following dependencies to see if the rocrand is even building:
1. https://launchpad.net/~igorluppi/+archive/ubuntu/lp2138890-default for llvm-toolchain-21
2. https://launchpad.net/~tchavadar/+archive/ubuntu/lp2138906 => for rocm-llvm
3. https://launchpad.net/~tchavadar/+archive/ubuntu/lp2138659 => for rocr-runtime

Autopkgtest results will be here: https://autopkgtest.ubuntu.com/user/tchavadar/ppa/mp499170

[Talha Can Havadar (tchavadar)]

Rebased to fix merge conflict: see the diff before force push (so no functional change):

```
 git diff origin/bullwinkle/llvm-21/ubuntu/devel
diff --git a/debian/changelog b/debian/changelog
index 691bc9d..6f5a793 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -21,14 +21,17 @@ rocrand (7.1.0-0ubuntu1) resolute; urgency=medium

  -- Tim Flink <email address hidden> Wed, 21 Jan 2026 12:11:41 -0600

-rocrand (6.4.3-1~exp1ubuntu1) questing; urgency=medium
+rocrand (6.4.3-1) unstable; urgency=medium

- * d/control: update build-depends
- * d/control: update maintainer field
- * d/rules: fix FTBFS by adding -Wl,--gc-sections to flags
+ * Upload to unstable
+ * Update my email address and copyright
+ * Drop inactive maintainers from uploaders
+ * Update symbol tracking with optional symbols
+
+ [ Igor Luppi ]
   * d/rules: use GPU_TARGETS instead of deprecated AMDGPU_TARGETS

- -- Igor Luppi <email address hidden> Tue, 14 Oct 2025 15:45:14 -0300
+ -- Cordell Bloor <email address hidden> Tue, 28 Oct 2025 21:31:30 -0600

 rocrand (6.4.3-1~exp1) experimental; urgency=medium

diff --git a/debian/copyright b/debian/copyright
index de0b4f8..db61ae1 100644
--- a/debian/copyright
+++ b/debian/copyright
@@ -79,7 +79,7 @@ Comment:
 Files: debian/*
 Copyright: 2022 Maxime Chambonnet <email address hidden>
            2022 Étienne Mollier <email address hidden>
- 2022-2024, Cordell Bloor <email address hidden>
+ 2022-2025, Cordell Bloor <email address hidden>
            2023-2025, Christian Kastner <email address hidden>
 License: Expat

```

[Igor Luppi (igorluppi)]

New ppa with the current proposed queue: https://launchpad.net/~igorluppi/+archive/ubuntu/rocrand-lp2140325/+packages

[Andreas Hasenack (ahasenack)]

Please evaluate the reverse dependencies on ppc64el that will also have to be dropped:
--- a/debian/control
+++ b/debian/control
@@ -30,7 +36,7 @@ Rules-Requires-Root: no

 Package: librocrand1
 Section: libs
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 XB-X-ROCm-GPU-Architecture: ${rocm:GPU-Architecture}
 Depends: ${misc:Depends}, ${shlibs:Depends},
 Description: generate pseudo- and quasi-random numbers - library
@@ -45,7 +51,7 @@ Description: generate pseudo- and quasi-random numbers - library

 Package: librocrand-dev
 Section: libdevel
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Depends: librocrand1 (= ${binary:Version}),
          libamdhip64-dev,
          ${misc:Depends},
@@ -63,7 +69,7 @@ Description: generate pseudo- and quasi-random numbers - headers

 Package: librocrand1-tests
 Section: libdevel
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Build-Profiles: <!nocheck>
 Depends: librocrand1 (= ${binary:Version}),${misc:Depends}, ${shlibs:Depends},
 Description: generate pseudo- and quasi-random numbers - test binaries

review: Needs Information

[Igor Luppi (igorluppi)]

Safe to delete:

for i in librocrand1 librocrand-dev librocrand1-tests; do reverse-depends --arch ppc64el $i -x; done
Reverse-Depends
===============
* librocrand-dev
* librocrand1-tests

No reverse dependencies found
No reverse dependencies found

Its within rocm stack.

[Andreas Hasenack (ahasenack)]

 Build-Depends: debhelper-compat (= 13),
                cmake,
- hipcc (>= 7.0~),
- libamd-comgr-dev (>= 6.4~),
- libamdhip64-dev (>= 6.4~),
- libhsa-runtime-dev (>= 6.4~),
+ hipcc (>= 6.0.0),
+ libamd-comgr-dev (>= 6.0~),
+ libhsa-runtime-dev (>= 6.0.0~),

Are these new versions correct? They are lower now, in the higher 7.1.0 rocrand?

review: Needs Information

[Andreas Hasenack (ahasenack)]

In d/rules:
@@ -15,6 +21,9 @@ CMAKE_FLAGS = \
    -DROCM_SYMLINK_LIBS=OFF \
    -DGPU_TARGETS="$(shell rocm-target-arch --sep ';')" \
    -DBUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF \
+ --debug-trycompile \
+ -DCMAKE_VERBOSE_MAKEFILE=ON \
+ -DCMAKE_PREFIX_PATH=/usr/lib/llvm-21/lib \
    -DENABLE_INLINE_ASM=1
 ifeq (,$(filter nocheck,$(DEB_BUILD_PROFILES)))
 CMAKE_FLAGS += -DBUILD_TEST=ON

This "--debug-trycompile", it's not mentioned explicitly in d/changelog. Is this a leftover from debugging, or an intended change?

review: Needs Information

[Andreas Hasenack (ahasenack)]

d/rules:

+ rocm-docs-build -r $(shell dpkg-parsechangelog -S Version | sed 's/-.*//')

I checked other rocm packages, and this is the only one (from my small sample) which uses the -r switch. Without this switch, I understand that rocm-docs-build will fetch the version from the internet, so I'm not even sure if it's able to do that in these other packages (maybe they get a null version, or if not, then the wrong version: upstream is at 7.2 now).

So, I do think passing -r seems correct for two reasons:
- set the correct version
- bypass the internet fetch

I was then checking if there was another way to get the version, as fetching it from d/changelog is usually frowned upon. But I didn't see a clear way to do it. The closest I got was this line in CMakeLists.txt:

./CMakeLists.txt:math(EXPR rocrand_VERSION_NUMBER "${rocRAND_VERSION_MAJOR} * 100000 + ${rocRAND_VERSION_MINOR} * 100 + ${rocRAND_VERSION_PATCH}")

So, this is ok. If you find a way to not use d/changelog in the future, that will be better. And perhaps also check which version is being used in the other packages that just call rocm-docs-build without -r.

[Talha Can Havadar (tchavadar)]

Thank you very much for the review Andreas,

About docs versioning, I will check if there is any other easy way to fetch upstream version of the current package but I also think this is a good option we have here that is working.

- I do feel `--debug-trycompile` is a debugging artifact gonna try a build without to verify.

- the version mismatch might be happened during rebase, to fix the conflict gonna update them

[Talha Can Havadar (tchavadar)]

checked the reflog for version mismatch seems like it is not because of rebase :) but updated the versions and removed debug-trycompile and make docs versioning to take possible `+dfsg` additions in the version as well (not necessary but makes it more generic)

gonna trigger a new build in ppa and once published trigger autopkg tests again

[Talha Can Havadar (tchavadar)]

amd64 builds are struggling in LP so I built this package in strix halo machine we have see the logs: https://pastebin.ubuntu.com/p/tHNJpnSzbm/

proposed enabled local build logs: https://pastebin.ubuntu.com/p/GBk2kS5zbS/

[Andreas Hasenack (ahasenack)]

+1

review: Approve

[Andreas Hasenack (ahasenack)]

Sponsored:

Uploading rocrand_7.1.0-0ubuntu1.dsc
Uploading rocrand_7.1.0.orig.tar.gz
Uploading rocrand_7.1.0-0ubuntu1.debian.tar.xz
Uploading rocrand_7.1.0-0ubuntu1_source.buildinfo
Uploading rocrand_7.1.0-0ubuntu1_source.changes

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 65006ad..29bce98 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,10 +1,10 @@
 # Global owners
-* @stanleytsang-amd @umfranzw @RobsonRLemos @lawruble13
+* @stanleytsang-amd @umfranzw @RobsonRLemos 
 
 # Documentation files
-docs/* @ROCm/rocm-documentation
+docs/ @ROCm/rocm-documentation
 *.md @ROCm/rocm-documentation
 *.rst @ROCm/rocm-documentation
 
 # Header directory
-library/include/* @ROCm/rocm-documentation @stanleytsang-amd @umfranzw @RobsonRLemos @lawruble13
+library/include/ @ROCm/rocm-documentation @stanleytsang-amd @umfranzw @RobsonRLemos  
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 93e3a4f..a829b55 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -157,12 +157,12 @@ copyright-date:
       -D BENCHMARK_TUNING_BLOCK_OPTIONS="128, 256"
       -D BUILD_FORTRAN_WRAPPER=ON
       -D DEPENDENCIES_FORCE_DOWNLOAD=ON
-      -D BUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF
       -D BUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}
       -D AMDGPU_TARGETS=${GPU_TARGETS}
       -D DISABLE_WERROR=OFF
       -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
       -D CMAKE_CXX_COMPILER_LAUNCHER=phc_sccache_cxx
+      -D CMAKE_CXX_STANDARD="$BUILD_VERSION"
     - cmake --build $CI_PROJECT_DIR/build
     - if [[ "${BUILD_SHARED_LIBS}" = "ON" ]]; then cmake --build $CI_PROJECT_DIR/build --target package; fi
 
@@ -183,12 +183,12 @@ copyright-date:
       -D BUILD_BENCHMARK=ON
       -D BUILD_FORTRAN_WRAPPER=ON
       -D DEPENDENCIES_FORCE_DOWNLOAD=ON
-      -D BUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF
       -D BUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}
       -D NVGPU_TARGETS=${GPU_TARGETS}
       -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
       -D CMAKE_CXX_COMPILER_LAUNCHER=phc_sccache_cxx
       -D CMAKE_CUDA_COMPILER_LAUNCHER=phc_sccache_cuda
+      -D CMAKE_CXX_STANDARD=17
     - cmake --build $CI_PROJECT_DIR/build
     - if [[ "${BUILD_SHARED_LIBS}" = "ON" ]]; then cmake --build $CI_PROJECT_DIR/build --target package; fi
 
@@ -196,15 +196,14 @@ copyright-date:
 .save-artifacts:
   artifacts:
     paths:
+      - $CI_PROJECT_DIR/build/lib/
       - $CI_PROJECT_DIR/build/library/
       - $CI_PROJECT_DIR/build/test/test_*
       - $CI_PROJECT_DIR/build/**/CTestTestfile.cmake
       - $CI_PROJECT_DIR/build/benchmark/benchmark_*
-      - $CI_PROJECT_DIR/build/deps/googlebenchmark/
       - $CI_PROJECT_DIR/build/CMakeCache.txt
       - $CI_PROJECT_DIR/build/*.deb
       - $CI_PROJECT_DIR/build/*.zip
-    expire_in: 2 weeks
 
 build:rocm-cmake-minimum:
   tags:
@@ -217,6 +216,7 @@ build:rocm-cmake-minimum:
   variables:
     BUILD_SHARED_LIBS: "ON"
     BUILD_BENCHMARK_TUNING: "ON"
+    BUILD_VERSION: 17
 
 build:rocm-hipcc-cmake-minimum:
   tags:
@@ -228,6 +228,7 @@ build:rocm-hipcc-cmake-minimum:
     - .save-artifacts
   variables:
     BUILD_SHARED_LIBS: "ON"
+    BUILD_VERSION: 17
 
 build:rocm-static-cmake-minimum:
   tags:
@@ -238,6 +239,7 @@ build:rocm-static-cmake-minimum:
     - .rocm:build
   variables:
     BUILD_SHARED_LIBS: "OFF"
+    BUILD_VERSION: 17
 
 build:rocm-cmake-latest:
   tags:
@@ -248,6 +250,10 @@ build:rocm-cmake-latest:
     - .rocm:build
   variables:
     BUILD_SHARED_LIBS: "ON"
+  parallel:
+    matrix:
+      - BUILD_VERSION: 17
+
 
 build:nvcc-cmake-minimum:
   tags:
@@ -315,7 +321,6 @@ benchmark:benchmark-tuning:
       -D BUILD_BENCHMARK_TUNING=ON
       -D BUILD_FORTRAN_WRAPPER=OFF
       -D DEPENDENCIES_FORCE_DOWNLOAD=ON
-      -D BUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF
       -D BUILD_SHARED_LIBS=ON
       -D AMDGPU_TARGETS=${GPU_TARGET}
       -D DISABLE_WERROR=OFF
@@ -324,13 +329,13 @@ benchmark:benchmark-tuning:
       -D BENCHMARK_TUNING_BLOCK_OPTIONS="${BENCHMARK_TUNING_BLOCK_OPTIONS}"
       -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
       -D CMAKE_CXX_COMPILER_LAUNCHER=phc_sccache_cxx
+      -D CMAKE_CXX_STANDARD=17
     - cmake --build $CI_PROJECT_DIR/build --target benchmark_rocrand_tuning
     - $CI_PROJECT_DIR/build/benchmark/tuning/benchmark_rocrand_tuning --benchmark_out_format=json --benchmark_out=$CI_PROJECT_DIR/build/rocrand_config_tuning_${GPU_TARGET}_${CI_JOB_ID}.json
   artifacts:
     paths:
       - $CI_PROJECT_DIR/build/library/
       - $CI_PROJECT_DIR/build/benchmark/
-      - $CI_PROJECT_DIR/build/deps/googlebenchmark/
       - $CI_PROJECT_DIR/build/CMakeCache.txt
       - $CI_PROJECT_DIR/build/*.json
     expire_in: 2 weeks
@@ -420,17 +425,17 @@ benchmark:nvcc:
     - .rules:test
   script:
     - $SUDO_CMD apt-get update -qq
-    - $SUDO_CMD apt-get install -y -qq python3 python3-pip python3-numpy
-    - $SUDO_CMD apt-get install -y -qq wget
-    - pip3 install setuptools
+    - $SUDO_CMD apt-get install -y -qq python3 python3-pip python3-venv
     - export ROCRAND_PATH=$CI_PROJECT_DIR/build/library/
     # rocRAND Wrapper with Python 3
-    - pip3 --version
     - cd $CI_PROJECT_DIR/python/rocrand
-    - python3 setup.py test
-    - pip3 install . --user
+    - python3 -m venv rocrand-venv
+    - source rocrand-venv/bin/activate
+    - python3 -m pip install setuptools numpy
+    - python3 -m pip install .
     - python3 tests/rocrand_test.py
-    - pip3 uninstall --yes rocrand
+    - python3 -m pip uninstall --yes rocrand
+    - deactivate
 
 test:rocm-python:
   tags:
@@ -512,9 +517,12 @@ test:cpp-wrapper:
       -B $CI_PROJECT_DIR/build_only_install
       -D BUILD_TEST=OFF
       -D BUILD_FORTRAN_WRAPPER=OFF
-      -D BUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF
       -D CMAKE_CXX_COMPILER=${COMPILER}
-    - $SUDO_CMD cmake --build $CI_PROJECT_DIR/build_only_install --target install
+      -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
+      -D CMAKE_CXX_COMPILER_LAUNCHER=phc_sccache_cxx
+      -D CMAKE_CUDA_COMPILER_LAUNCHER=phc_sccache_cuda
+    # Preserve $PATH when sudoing
+    - $SUDO_CMD env PATH="$PATH" cmake --build $CI_PROJECT_DIR/build_only_install --target install
     - cmake
       -S $CI_PROJECT_DIR/test/package/
       -B $CI_PROJECT_DIR/install_test
@@ -546,6 +554,10 @@ test:doc:
   extends:
     - .rules:test
     - .build:docs
+  artifacts:
+    paths:
+      - $DOCS_DIR/_build/html/
+    expire_in: 2 weeks
 
 .test:parity:
   stage: test
@@ -601,9 +613,11 @@ test:nvcc-parity:
       -D BUILD_TEST=ON
       -D CMAKE_BUILD_TYPE=Release
       -D CMAKE_CXX_COMPILER:FILEPATH="${env:HIP_PATH}/bin/clang++.exe"
+      -D CMAKE_CXX_FLAGS="-Wno-ignored-attributes"
       -D CMAKE_INSTALL_PREFIX:PATH="$CI_PROJECT_DIR/build/install"
       -D CMAKE_PREFIX_PATH:PATH="${env:HIP_PATH}/lib/cmake"
-      -D DISABLE_WERROR=OFF *>&1
+      -D DISABLE_WERROR=OFF
+      -D CMAKE_CXX_STANDARD=17 *>&1
     # Building
     - cmake --build "$CI_PROJECT_DIR/build" *>&1
 
@@ -632,10 +646,13 @@ test:windows:
       -D CMAKE_BUILD_TYPE=Release
       -D CMAKE_CXX_COMPILER:FILEPATH="${env:HIP_PATH}/bin/clang++.exe"
       -D CMAKE_PREFIX_PATH:FILEPATH="${env:HIP_PATH}/lib/cmake;$CI_PROJECT_DIR/build/install" *>&1
+      -D CMAKE_CXX_STANDARD=17
     # Build package test
     - cmake --build "$CI_PROJECT_DIR/build_install_test"
     # Copy rocRAND.dll to the package test build directory
     - cmake -E copy "$CI_PROJECT_DIR/build/install/bin/rocRAND.dll" "$CI_PROJECT_DIR/build_install_test" *>&1
+    - cmake -E copy "$CI_PROJECT_DIR/build/_deps/googlebenchmark-build/src/benchmark.dll" "$CI_PROJECT_DIR/build_install_test" *>&1
+    - cmake -E copy "$CI_PROJECT_DIR/build/_deps/googlebenchmark-build/src/benchmark_main.dll" "$CI_PROJECT_DIR/build_install_test" *>&1
     # Run package test
     - ctest --test-dir "$CI_PROJECT_DIR/build_install_test" -C $CMAKE_BUILD_TYPE --output-on-failure *>&1
 
@@ -663,6 +680,7 @@ test:windows:
       -D CMAKE_CXX_COMPILER=${COMPILER}
       -D CMAKE_C_COMPILER_LAUNCHER=phc_sccache_c
       -D CMAKE_CXX_COMPILER_LAUNCHER=phc_sccache_cxx
+      -D CMAKE_CXX_STANDARD=17
     - cmake --build ${ROCRAND_STAT_TESTS_DIR}/build
     - mkdir ${LOGS_DIR}
     - cd ${ROCRAND_STAT_TESTS_DIR}/build
@@ -670,7 +688,7 @@ test:windows:
   artifacts:
     paths:
       - ${LOGS_DIR}/*
-    expire_in: never
+    expire_in: 3 months
 
 # TestU01 SmallCrush, 10 tests, 15 statistics, takes about 5 seconds
 statistical-test:crush-small:
diff --git a/.jenkins/common.groovy b/.jenkins/common.groovy
deleted file mode 100644
index 65a9a90..0000000
--- a/.jenkins/common.groovy
+++ /dev/null
@@ -1,95 +0,0 @@
-// This file is for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-def runCompileCommand(platform, project, jobName, boolean debug=false, boolean staticLibrary=false, boolean codeCoverage=false)
-{
-    project.paths.construct_build_prefix()
-
-    project.paths.build_command = './install -c'
-    String buildTypeArg = debug ? '-DCMAKE_BUILD_TYPE=Debug' : '-DCMAKE_BUILD_TYPE=Release'
-    String buildTypeDir = debug ? 'debug' : 'release'
-    String buildStatic = staticLibrary ? '-DBUILD_SHARED_LIBS=OFF' : '-DBUILD_SHARED_LIBS=ON'
-    String codeCovFlag = codeCoverage ? '-DCODE_COVERAGE=ON' : ''
-    String cmake = platform.jenkinsLabel.contains('centos') ? 'cmake3' : 'cmake'
-    //Set CI node's gfx arch as target if PR, otherwise use default targets of the library
-    String amdgpuTargets = env.BRANCH_NAME.startsWith('PR-') ? '-DAMDGPU_TARGETS=\$gfx_arch' : ''
-
-    def command = """#!/usr/bin/env bash
-                set -x
-                cd ${project.paths.project_build_prefix}
-                mkdir -p build/${buildTypeDir} && cd build/${buildTypeDir}
-                # gfxTargetParser reads gfxarch and adds target features such as xnack
-                ${auxiliary.gfxTargetParser()}
-                ${cmake} --toolchain=toolchain-linux.cmake ${buildTypeArg} ${buildStatic} ${amdgpuTargets} ${codeCovFlag} -DBUILD_TEST=ON -DBUILD_BENCHMARK=ON ../..
-                make -j\$(nproc)
-                """
-
-    platform.runCommand(this, command)
-}
-
-def runTestCommand (platform, project)
-{
-    String sudo = auxiliary.sudo(platform.jenkinsLabel)
-    // String centos = platform.jenkinsLabel.contains('centos') ? '3' : ''
-    // Disable xorwow test for now as it is a known failure with gfx90a.
-    // def testCommand = "ctest${centos} --output-on-failure"
-    def testCommand = "ctest --output-on-failure"
-
-    def command = """#!/usr/bin/env bash
-                set -x
-                cd ${project.paths.project_build_prefix}/build/release
-                make -j4
-                ${sudo} LD_LIBRARY_PATH=/opt/rocm/lib/ ${testCommand}
-            """
-
-    platform.runCommand(this, command)
-}
-
-def runPackageCommand(platform, project)
-{
-    def packageHelper = platform.makePackage(platform.jenkinsLabel,"${project.paths.project_build_prefix}/build/release")
-
-    platform.runCommand(this, packageHelper[0])
-    platform.archiveArtifacts(this, packageHelper[1])
-}
-
-def runCodeCovTestCommand(platform, project, jobName)
-{
-    withCredentials([string(credentialsId: 'mathlibs-codecov-token-rocrand', variable: 'CODECOV_TOKEN')])
-    {
-        String prflag = env.CHANGE_ID ? "--pr \"${env.CHANGE_ID}\"" : ''
-
-        String objectFlags = "-object ./library/librocrand.so"
-
-        String profdataFile = "./rocRand.profdata"
-        String reportFile = "./code_cov_rocRand.report"
-        String coverageFile = "./code_cov_rocRand.txt"
-        String coverageFilter = "(.*googletest-src.*)|(.*/yaml-cpp-src/.*)|(.*hip/include.*)|(.*/include/llvm/.*)|(.*test/unit.*)|(.*/spdlog/.*)|(.*/msgpack-src/.*)"
-
-        def command = """#!/usr/bin/env bash
-                    set -ex
-                    cd ${project.paths.project_build_prefix}/build/release
-                    #Remove any preexisting prof files.
-                    rm -rf ./test/*.profraw
-
-                    #The `%m` creates a different prof file for each object file.
-                    LLVM_PROFILE_FILE=./rocRand_%m.profraw ctest --output-on-failure
-
-                    #this combines them back together.
-                    /opt/rocm/llvm/bin/llvm-profdata merge -sparse ./test/*.profraw -o ${profdataFile}
-
-                    #For some reason, with the -object flag, we can't just specify the source directory, so we have to filter out the files we don't want.
-                    /opt/rocm/llvm/bin/llvm-cov report ${objectFlags} -instr-profile=${profdataFile} -ignore-filename-regex="${coverageFilter}" > ${reportFile}
-                    cat ${reportFile}
-                    /opt/rocm/llvm/bin/llvm-cov show -Xdemangler=/opt/rocm/llvm/bin/llvm-cxxfilt ${objectFlags} -instr-profile=${profdataFile} -ignore-filename-regex="${coverageFilter}" > ${coverageFile}
-
-                    #Upload report to codecov
-                    curl -Os https://uploader.codecov.io/latest/linux/codecov
-                    chmod +x codecov
-                    ./codecov -t ${CODECOV_TOKEN} ${prflag} --flags "${platform.gpu}" --sha \$(git rev-parse HEAD) --name "CI: ${jobName}" --file ${coverageFile} -v
-                """
-        platform.runCommand(this, command)
-    }
-}
-
-return this
diff --git a/.jenkins/precheckin.groovy b/.jenkins/precheckin.groovy
deleted file mode 100644
index d067fd8..0000000
--- a/.jenkins/precheckin.groovy
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/env groovy
-@Library('rocJenkins@pong') _
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path;
-
-def runCI =
-{
-    nodeDetails, jobName->
-    
-    def prj = new rocProject('rocRAND', 'PreCheckin')
-
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    def commonGroovy
-
-    boolean formatCheck = false
-     
-    def compileCommand =
-    {
-        platform, project->
-
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-        commonGroovy.runCompileCommand(platform, project, jobName)
-    }
-
-    
-    def testCommand =
-    {
-        platform, project->
-
-        commonGroovy.runTestCommand(platform, project)
-    }
-
-    def packageCommand =
-    {
-        platform, project->
-
-        commonGroovy.runPackageCommand(platform, project)
-    }
-
-    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, packageCommand)
-}
-
-ci: { 
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 0')])]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":([ubuntu18:['gfx900'],centos7:['gfx906'],centos8:['gfx906'],sles15sp1:['gfx908']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each 
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-
-    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
-    if(!jobNameList.keySet().contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu16:['gfx906']], urlJobName)
-        }
-    }
-}
\ No newline at end of file
diff --git a/.jenkins/static.groovy b/.jenkins/static.groovy
deleted file mode 100644
index cee8d3d..0000000
--- a/.jenkins/static.groovy
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/env groovy
-@Library('rocJenkins@pong') _
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path;
-
-def runCI =
-{
-    nodeDetails, jobName->
-    
-    def prj = new rocProject('rocRAND', 'static')
-
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    def commonGroovy
-
-    boolean formatCheck = false
-     
-    def compileCommand =
-    {
-        platform, project->
-
-        commonGroovy = load "${project.paths.project_src_prefix}/.jenkins/common.groovy"
-        commonGroovy.runCompileCommand(platform, project, jobName, debug=false, staticLibrary=true)
-    }
-    
-    def testCommand =
-    {
-        platform, project->
-
-        commonGroovy.runTestCommand(platform, project)
-    }
-
-    def packageCommand =
-    {
-        platform, project->
-
-        commonGroovy.runPackageCommand(platform, project)
-    }
-
-    buildProject(prj, formatCheck, nodes.dockerArray, compileCommand, testCommand, packageCommand)
-}
-
-ci: { 
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    def propertyList = ["compute-rocm-dkms-no-npi-hipclang":[pipelineTriggers([cron('0 1 * * 0')])]]
-    propertyList = auxiliary.appendPropertyList(propertyList)
-
-    def jobNameList = ["compute-rocm-dkms-no-npi-hipclang":([ubuntu18:['gfx900'],centos7:['gfx906'],centos8:['gfx906'],sles15sp1:['gfx908']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList)
-
-    propertyList.each 
-    {
-        jobName, property->
-        if (urlJobName == jobName)
-            properties(auxiliary.addCommonProperties(property))
-    }
-
-    jobNameList.each
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-
-    // For url job names that are not listed by the jobNameList i.e. compute-rocm-dkms-no-npi-1901
-    if(!jobNameList.keySet().contains(urlJobName))
-    {
-        properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * *')])]))
-        stage(urlJobName) {
-            runCI([ubuntu16:['gfx906']], urlJobName)
-        }
-    }
-}
diff --git a/.jenkins/staticanalysis.groovy b/.jenkins/staticanalysis.groovy
deleted file mode 100644
index c41e309..0000000
--- a/.jenkins/staticanalysis.groovy
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/usr/bin/env groovy
-// This shared library is available at https://github.com/ROCmSoftwarePlatform/rocJENKINS/
-@Library('rocJenkins@pong') _
-
-// This is file for internal AMD use.
-// If you are interested in running your own Jenkins, please raise a github issue for assistance.
-
-import com.amd.project.*
-import com.amd.docker.*
-import java.nio.file.Path
-
-def runCompileCommand(platform, project, jobName, boolean debug=false)
-{
-    project.paths.construct_build_prefix()
-}
-
-def runCI =
-{
-    nodeDetails, jobName->
-
-    def prj  = new rocProject('rocRAND', 'StaticAnalysis')
-
-    // Define test architectures, optional rocm version argument is available
-    def nodes = new dockerNodes(nodeDetails, jobName, prj)
-
-    boolean formatCheck = false
-    boolean staticAnalysis = true
-
-    def compileCommand =
-    {
-        platform, project->
-
-        runCompileCommand(platform, project, jobName, false)
-    }
-
-    buildProject(prj , formatCheck, nodes.dockerArray, compileCommand, null, null, staticAnalysis)
-}
-
-ci: {
-    String urlJobName = auxiliary.getTopJobName(env.BUILD_URL)
-
-    properties(auxiliary.addCommonProperties([pipelineTriggers([cron('0 1 * * 6')])]))
-    
-    def jobNameList = ["main":([ubuntu22:['any']])]
-    jobNameList = auxiliary.appendJobNameList(jobNameList, 'rocBLAS')
-
-    jobNameList.each
-    {
-        jobName, nodeDetails->
-        if (urlJobName == jobName)
-            stage(jobName) {
-                runCI(nodeDetails, jobName)
-            }
-    }
-}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b08796..69ebb6c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,67 @@
 Documentation for rocRAND is available at
 [https://rocm.docs.amd.com/projects/rocRAND/en/latest/](https://rocm.docs.amd.com/projects/rocRAND/en/latest/)
 
+## rocRAND 4.1.0 for ROCm 7.1
+
+### Resolved issues
+
+* Updated error handling for several rocRAND unit tests to accomodate the new hipGetLastError behaviour that was introduced in ROCm 7.0.
+As of ROCm 7.0, the internal error state is cleared on each call to `hipGetLastError` rather than on every HIP API call.
+
+### Changed
+
+* Changed the `USE_DEVICE_DISPATCH` flag so it can turn device dispatch off by setting it to zero. Device dispatch should be turned off when building for SPIRV.
+
+## rocRAND 4.0.0 for ROCm 7.0
+
+### Added
+
+* gfx950 support
+* Additional unit tests for `test_log_normal_distribution.cpp`
+* Additional unit tests for `test_normal_distribution.cpp`
+* Additional unit tests for `test_rocrand_mtgp32_prng.cpp`
+* Additional unit tests for `test_rocrand_scrambled_sobol32_qrng.cpp`
+* Additional unit tests for `test_rocrand_scrambled_sobol64_qrng.cpp`
+* Additional unit tests for `test_rocrand_sobol32_qrng.cpp`
+* Additional unit tests for `test_rocrand_sobol64_qrng.cpp`
+* Additional unit tests for `test_rocrand_threefry2x32_20_prng.cpp`
+* Additional unit tests for `test_rocrand_threefry2x64_20_prng.cpp`
+* Additional unit tests for `test_rocrand_threefry4x32_20_prng.cpp`
+* Additional unit tests for `test_rocrand_threefry4x64_20_prng.cpp`
+* Additional unit tests for `test_uniform_distribution.cpp`
+* New unit tests for `include/rocrand/rocrand_discrete.h` in `test_rocrand_discrete.cpp`
+* New unit tests for `include/rocrand/rocrand_mrg31k3p.h` in `test_rocrand_mrg31k3p_prng.cpp`
+* New unit tests for `include/rocrand/rocrand_mrg32k3a.h` in `test_rocrand_mrg32k3a_prng.cpp`
+* New unit tests for `include/rocrand/rocrand_poisson.h` in `test_rocrand_poisson.cpp`
+
+### Changed
+
+* Changed the return type for `rocrand_generate_poisson` for the `SOBOL64` and `SCRAMBLED_SOBOL64` engines.
+* Changed the unnecessarily large 64-bit data type for constants used for skipping in `MRG32K3A` to the 32-bit data type.
+* Updated several `gfx942` auto tuning parameters.
+* Modified error handling and expanded the error information for the case of double-deallocation of the (scrambled) sobol32 and sobol64 constants and direction vectors.
+
+### Removed
+
+* Removed inline assembly and the `ENABLE_INLINE_ASM` CMake option. Inline assembly was used to optimizate of multiplications in the Mrg32k3a and Philox 4x32-10 generators. It is no longer needed because the current HIP compiler is able to produce code with the same or better performance.
+* Removed instances of the deprecated clang definition `__AMDGCN_WAVEFRONT_SIZE`.
+* Removed C++14 support. Beginning with this release, only C++17 is supported.
+* Directly accessing the (scrambled) sobol32 and sobol64 constants and direction vectors is no longer supported. For:
+  * `h_scrambled_sobol32_constants`, use `rocrand_get_scramble_constants32` instead.
+  * `h_scrambled_sobol64_constants`, use `rocrand_get_scramble_constants64` instead.
+  * `rocrand_h_sobol32_direction_vectors`, use `rocrand_get_direction_vectors32` instead.
+  * `rocrand_h_sobol64_direction_vectors`, use `rocrand_get_direction_vectors64` instead.
+  * `rocrand_h_scrambled_sobol32_direction_vectors`, use `rocrand_get_direction_vectors32` instead.
+  * `rocrand_h_scrambled_sobol64_direction_vectors`, use `rocrand_get_direction_vectors64` instead.
+
+### Resolved issues
+
+* Fixed an issue where `mt19937.hpp` would cause kernel errors during auto tuning.
+
+### Upcoming changes
+
+* Deprecated the rocRAND Fortran API in favor of hipfort.
+
 ## rocRAND 3.3.0 for ROCm 6.4
 
 ### Added
@@ -14,9 +75,15 @@ Documentation for rocRAND is available at
 
 ### Changed
 
+* Removed a section in `cmake/Dependencies.cmake` that was forcing `DCMAKE_CXX_COMPILER` to be set to either `cl` or `g++` if the compiler was not `GNU`.
 * `--test|-t` is no longer a required flag for `rtest.py`. Instead, the user can use either `--emulation|-e` or `--test|-t`, but not both.
 * Removed TBB dependency for multi-core processing of host-side generation.
 
+## Resolved issues
+
+* Fixed an issue where `CMAKE_PREFIX_PATH` was not defined properly in `CMAKELists.txt` and `toolchain-linux.cmake`.
+* Fixed an issue in `rmake.py` where `cmake_platform_opts` was sometimes a string instead of a list.
+
 ## rocRAND 3.2.0 for ROCm 6.3.0
 
 ### Added
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f746b3c..b32acc8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -21,6 +21,7 @@
 # SOFTWARE.
 
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
+cmake_policy(VERSION 3.16...3.25)
 
 # Build options
 include(CMakeDependentOption)
@@ -29,22 +30,48 @@ option(BUILD_FORTRAN_WRAPPER "Build Fortran wrapper" OFF)
 option(BUILD_TEST "Build tests (requires googletest)" OFF)
 option(BUILD_BENCHMARK "Build benchmarks" OFF)
 cmake_dependent_option(BUILD_BENCHMARK_TUNING
-  "Build extra benchmarks for kernel configuration tuning" OFF "BUILD_BENCHMARK" OFF)
+"Build extra benchmarks for kernel configuration tuning" OFF "BUILD_BENCHMARK" OFF)
 option(BUILD_ADDRESS_SANITIZER "Build with address sanitizer enabled" OFF)
 option(CODE_COVERAGE "Build with code coverage flags (clang only)" OFF)
 option(DEPENDENCIES_FORCE_DOWNLOAD "Don't search the system for dependencies, always download them" OFF)
 cmake_dependent_option(RUN_SLOW_TESTS "Run extra tests with CTest. These cover niche functionality and take long time" OFF "BUILD_TEST" OFF)
 
+
+if (NOT DEFINED ENV{ROCM_PATH})
+#Path to ROCm installation
+  set(ENV{ROCM_PATH} "/opt/rocm")
+endif()
+  
 # Install prefix
-set(CMAKE_INSTALL_PREFIX "/opt/rocm" CACHE PATH "Install path prefix, prepended onto install directories")
+set(CMAKE_INSTALL_PREFIX "$ENV{ROCM_PATH}" CACHE PATH "Install path prefix, prepended onto install directories")
+
+if(WIN32)
+    set(CPACK_SOURCE_GENERATOR "ZIP")
+    set(CPACK_GENERATOR "ZIP")
+    set(CMAKE_INSTALL_PREFIX "C:/hipSDK" CACHE PATH "Install path")
+    set(INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+    set(CPACK_SET_DESTDIR OFF)
+    set(CPACK_PACKAGE_INSTALL_DIRECTORY "${CMAKE_INSTALL_PREFIX}")
+    set(CPACK_PACKAGING_INSTALL_PREFIX "")
+    set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
+else()
+    set(CMAKE_INSTALL_PREFIX "$ENV{ROCM_PATH}" CACHE PATH "Install path prefix, prepended onto install directories")
+    #Adding CMAKE_PREFIX_PATH
+    if(NOT DEFINED CMAKE_PREFIX_PATH)
+      list( APPEND CMAKE_PREFIX_PATH $ENV{ROCM_PATH}/llvm $ENV{ROCM_PATH})
+    endif()
+    if(NOT CPACK_PACKAGING_INSTALL_PREFIX)
+        set(CPACK_PACKAGING_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+    endif()
+endif()
 
 # CMake modules
 list(APPEND CMAKE_MODULE_PATH
-    ${CMAKE_CURRENT_SOURCE_DIR}/cmake
-    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules
-    $ENV{ROCM_PATH}/lib/cmake/hip
-    ${HIP_PATH}/cmake $ENV{ROCM_PATH}/hip/cmake # FindHIP.cmake
-    $ENV{ROCM_PATH}/llvm
+${CMAKE_CURRENT_SOURCE_DIR}/cmake
+${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules
+$ENV{ROCM_PATH}/lib/cmake/hip
+${HIP_PATH}/cmake $ENV{ROCM_PATH}/hip/cmake # FindHIP.cmake
+$ENV{ROCM_PATH}/llvm
 )
 
 #
@@ -97,11 +124,11 @@ if(GPU_TARGETS STREQUAL "all")
   if(BUILD_ADDRESS_SANITIZER)
     # ASAN builds require xnack
     rocm_check_target_ids(DEFAULT_AMDGPU_TARGETS
-      TARGETS "gfx908:xnack+;gfx90a:xnack+;gfx942:xnack+"
+      TARGETS "gfx908:xnack+;gfx90a:xnack+;gfx942:xnack+;gfx950:xnack+"
     )
   else()
     rocm_check_target_ids(DEFAULT_AMDGPU_TARGETS
-      TARGETS "gfx803;gfx900:xnack-;gfx906:xnack-;gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx942;gfx1030;gfx1100;gfx1101;gfx1102;gfx1200;gfx1201;gfx1151"
+      TARGETS "gfx803;gfx900:xnack-;gfx906:xnack-;gfx908:xnack-;gfx90a:xnack-;gfx90a:xnack+;gfx942;gfx950;gfx1030;gfx1100;gfx1101;gfx1102;gfx1200;gfx1201;gfx1151"
     )
   endif()
 
@@ -115,7 +142,9 @@ include(cmake/VerifyCompiler.cmake)
 option(DISABLE_WERROR "Disable building with Werror" ON)
 
 # Build CXX flags
-set(CMAKE_CXX_STANDARD 11)
+if (NOT DEFINED CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 17)
+endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 if(DISABLE_WERROR)
@@ -125,6 +154,13 @@ else()
 endif()
 if(CODE_COVERAGE)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-instr-generate -fcoverage-mapping")
+    add_definitions(-DCODE_COVERAGE_ENABLED)
+endif()
+
+if (CMAKE_CXX_STANDARD EQUAL 14)
+  message(WARNING "C++14 will be deprecated in the next major release")
+elseif(NOT CMAKE_CXX_STANDARD EQUAL 17)
+  message(FATAL_ERROR "Only C++14 and C++17 are supported")
 endif()
 
 # HIP on Windows: xhip is required with clang++ to get __half defined
@@ -142,21 +178,8 @@ if(BUILD_ADDRESS_SANITIZER AND BUILD_SHARED_LIBS)
   add_link_options(-fuse-ld=lld)
 endif()
 
-# FOR HANDLING ENABLE/DISABLE OPTIONAL BACKWARD COMPATIBILITY for FILE/FOLDER REORG
-option(BUILD_FILE_REORG_BACKWARD_COMPATIBILITY "Build with file/folder reorg with backward compatibility enabled" OFF)
-if(BUILD_FILE_REORG_BACKWARD_COMPATIBILITY AND NOT WIN32)
-  rocm_wrap_header_dir(
-    "${PROJECT_SOURCE_DIR}/library/include/rocrand"
-    HEADER_LOCATION include/rocrand
-    GUARDS SYMLINK WRAPPER
-    WRAPPER_LOCATIONS include rocrand/include
-    OUTPUT_LOCATIONS library/include library/rocrand/include
-    PATTERNS *.h *.hpp
-  )
-endif()
-
 # Set version variables
-rocm_setup_version( VERSION "3.3.0" )
+rocm_setup_version( VERSION "4.1.0" )
 set ( rocrand_VERSION ${rocRAND_VERSION} )
 # Old-style version number used within the library's API. rocrand_get_version should be modified.
 math(EXPR rocrand_VERSION_NUMBER "${rocRAND_VERSION_MAJOR} * 100000 + ${rocRAND_VERSION_MINOR} * 100 + ${rocRAND_VERSION_PATCH}")
@@ -190,25 +213,8 @@ if (BUILD_BENCHMARK)
 endif()
 
 # Package (make package)
-set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.txt")
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md")
 set(CPACK_RPM_PACKAGE_LICENSE "MIT")
-if(WIN32)
-    set(CPACK_SOURCE_GENERATOR "ZIP")
-    set(CPACK_GENERATOR "ZIP")
-    set(CMAKE_INSTALL_PREFIX "C:/hipSDK" CACHE PATH "Install path")
-    set(INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
-    set(CPACK_SET_DESTDIR OFF)
-    set(CPACK_PACKAGE_INSTALL_DIRECTORY "${CMAKE_INSTALL_PREFIX}")
-    set(CPACK_PACKAGING_INSTALL_PREFIX "")
-    set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
-else()
-    set(CMAKE_INSTALL_PREFIX "$ENV{ROCM_PATH}" CACHE PATH "Install path prefix, prepended onto install directories")
-    #Adding CMAKE_PREFIX_PATH
-    list( APPEND CMAKE_PREFIX_PATH $ENV{ROCM_PATH}/llvm $ENV{ROCM_PATH} )
-    if(NOT CPACK_PACKAGING_INSTALL_PREFIX)
-        set(CPACK_PACKAGING_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
-    endif()
-endif()
 
 if( HIP_RUNTIME_LOWER STREQUAL "rocclr" )
     if(BUILD_ADDRESS_SANITIZER)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ebac71d..04f2af5 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -6,7 +6,7 @@
 
 # Contributing to rocRAND #
 
-We welcome contributions to rocRAND.  Please follow these details to help ensure your contributions will be successfully accepted.
+We welcome contributions to rocRAND. Please follow these details to help ensure your contributions will be successfully accepted.
 
 ## Issue Discussion ##
 
@@ -110,4 +110,4 @@ During code reviews, another developer will take a look through your proposed ch
 needed), they may leave a comment. You can follow up and respond to the comment, and/or create comments of your own if you have questions or ideas.
 When a modification request has been completed, the conversation thread about it will be marked as resolved.
 
-To update the code in your PR (eg. in response to a code review discussion), you can simply push another commit to the branch used in your pull request.
\ No newline at end of file
+To update the code in your PR (eg. in response to a code review discussion), you can simply push another commit to the branch used in your pull request.
diff --git a/LICENSE.txt b/LICENSE.md
similarity index 94%
rename from LICENSE.txt
rename to LICENSE.md
index e650db9..4d43ac8 100644
--- a/LICENSE.txt
+++ b/LICENSE.md
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
+Copyright (C) Advanced Micro Devices, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README.md b/README.md
index 6bfdaaf..3503913 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,15 @@
 # rocRAND
 
+> [!NOTE]
+> The published rocRAND documentation is available [here](https://rocm.docs.amd.com/projects/rocRAND/en/latest/) in an organized, easy-to-read format, with search and a table of contents. The documentation source files reside in the `docs` folder of this repository. As with all ROCm projects, the documentation is open source. For more information on contributing to the documentation, see [Contribute to ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/contributing.html).
+
 The rocRAND project provides functions that generate pseudorandom and quasirandom numbers.
-The rocRAND library is implemented in the [HIP](https://github.com/ROCm/HIP)
+The rocRAND library is implemented in the [HIP](https://github.com/ROCm/rocm-systems/tree/develop/projects/hip)
 programming language and optimized for AMD's latest discrete GPUs. It is designed to run on top
-of AMD's [ROCm](https://rocm.docs.amd.com) runtime, but it also works on CUDA-enabled GPUs.
+of AMD's [ROCm](https://rocm.docs.amd.com) runtime.
 
 Prior to ROCm version 5.0, this project included the
-[hipRAND](https://github.com/ROCm/hipRAND.git) wrapper. As of version 5.0, it was
+[hipRAND](https://github.com/ROCm/rocm-libraries/tree/develop/projects/hiprand) wrapper. As of version 5.0, it was
 split into a separate library. As of version 6.0, hipRAND can no longer be built from rocRAND.
 
 ## Supported random number generators
@@ -24,28 +27,6 @@ split into a separate library. As of version 6.0, hipRAND can no longer be built
 * Scrambled Sobol64
 * ThreeFry
 
-## Documentation
-
-> [!NOTE]
-> The published rocRAND documentation is available at [rocRAND](https://rocm.docs.amd.com/projects/rocRAND/en/latest/) in an organized, easy-to-read format, with search and a table of contents. The documentation source files reside in the rocRAND/docs folder of this repository. As with all ROCm projects, the documentation is open source. For more information, see [Contribute to ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/contributing.html).
-
-To build documentation locally, use the following code:
-
-```sh
-# Go to the docs directory
-cd docs
-
-# Install Python dependencies
-python3 -m pip install -r sphinx/requirements.txt
-
-# Build the documentation
-python3 -m sphinx -T -E -b html -d _build/doctrees -D language=en . _build/html
-
-# E.g. serve the HTML docs locally
-cd _build/html
-python3 -m http.server
-```
-
 ## Requirements
 
 * CMake (3.16 or later)
@@ -56,11 +37,8 @@ python3 -m http.server
 * C++ compiler with C++11 support to consume the library.
 * For AMD platforms:
   * [ROCm](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/how-to/native-install/index.html) (1.7 or later)
-  * [HIP-clang](https://github.com/ROCm/HIP/blob/master/INSTALL.md#hip-clang) compiler, which must be
-    set as C++ compiler on ROCm platform.
-* For CUDA platforms:
-  * [HIP](https://github.com/ROCm/HIP)
-  * Latest CUDA SDK
+  * [HIP-clang](https://rocm.docs.amd.com/projects/HIP/en/latest/install/install.html) compiler, which must be
+    set as the C++ compiler for the ROCm platform.
 * Python 3.6 or higher (HIP on Windows only, only required for install script)
 * Visual Studio 2019 with clang support (HIP on Windows only)
 * Strawberry Perl (HIP on Windows only)
@@ -83,11 +61,18 @@ dependencies, rather than using the system-installed libraries.
 
 ## Build and install
 
+> [!NOTE]
+> The following clone command downloads all components in the [rocm-libraries](https://github.com/ROCm/rocm-libraries) GitHub repository.
+This is recommended for working with multiple library components, but can take a very long time to
+download. For a shorter download process that only clones the rocRAND library, see the
+[rocRAND installation documentation](https://rocm.docs.amd.com/projects/rocRAND/en/latest/install/installing.html)
+for ROCm 7.0 or later.
+
 ```shell
-git clone https://github.com/ROCm/rocRAND.git
+git clone https://github.com/ROCm/rocm-libraries.git
 
 # Go to rocRAND directory, create and go to build directory
-cd rocRAND; mkdir build; cd build
+cd rocm-libraries/projects/rocrand; mkdir build; cd build
 
 # Configure rocRAND, setup options for your system
 # Build options: BUILD_TEST (off by default), BUILD_BENCHMARK (off by default), BUILD_SHARED_LIBS (on by default)
@@ -101,14 +86,6 @@ cd rocRAND; mkdir build; cd build
 #
 [CXX=hipcc] cmake -DBUILD_BENCHMARK=ON ../. -DCMAKE_PREFIX_PATH=/opt/rocm # or cmake-gui ../.
 
-# To configure rocRAND for NVIDIA platforms, the CXX compiler must be set to a host compiler. The CUDA compiler can
-# be set explicitly using `-DCMAKE_CUDA_COMPILER=<path-to-nvcc>`.
-# Additionally, the path to FindHIP.cmake should be passed via CMAKE_MODULE_PATH. By default, this is module is
-# installed in /opt/rocm/hip/cmake.
-cmake -DBUILD_BENCHMARK=ON ../. -DCMAKE_PREFIX_PATH=/opt/rocm -DCMAKE_MODULE_PATH=/opt/rocm/hip/cmake # or cmake-gui ../.
-# or
-[CXX=g++] cmake -DBUILD_BENCHMARK=ON -DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc -DCMAKE_PREFIX_PATH=/opt/rocm -DCMAKE_MODULE_PATH=/opt/rocm/hip/cmake ../. # or cmake-gui ../.
-
 # Build
 make -j4
 
@@ -119,14 +96,19 @@ ctest --output-on-failure
 [sudo] make install
 ```
 
+### SPIR-V
+
+rocRAND supports the `amdgcnspirv` target, but it should be built with `USE_DEVICE_DISPATCH`
+turned off like `-DUSE_DEVICE_DISPATCH=0`.
+
 ### HIP on Windows
 
 We've added initial support for HIP on Windows, which you can install using the `rmake.py` python
 script:
 
 ```shell
-git clone https://github.com/ROCm/rocRAND.git
-cd rocRAND
+git clone https://github.com/ROCm/rocm-libraries.git
+cd rocm-libraries/projects/rocrand
 
 # the -i option will install rocPRIM to C:\hipSDK by default
 python rmake.py -i
@@ -140,15 +122,11 @@ compilers) may cause a build failure; if you encounter errors with the existing 
 other dependencies, you can pass the `DEPENDENCIES_FORCE_DOWNLOAD` flag to CMake, which can
 help to solve the problem.
 
-To disable inline assembly optimizations in rocRAND (for both the host library and
-the device functions provided in `rocrand_kernel.h`), set the CMake option `ENABLE_INLINE_ASM`
-to `OFF`.
-
 ## Running unit tests
 
 ```shell
 # Go to rocRAND build directory
-cd rocRAND; cd build
+cd rocm-libraries/projects/rocrand; cd build
 
 # To run all tests
 ctest
@@ -161,7 +139,7 @@ ctest
 
 ```shell
 # Go to rocRAND build directory
-cd rocRAND; cd build
+cd rocm-libraries/projects/rocrand; cd build
 
 # To run benchmark for the host generate functions:
 # The benchmarks are registered with Google Benchmark as `device_generate<engine,distribution>`, where
@@ -225,10 +203,62 @@ been migrated to the new framework.
 * [Fortran wrappers](./library/src/fortran/).
 * [Python wrappers](./python/): [rocRAND](./python/rocrand).
 
+## Building the documentation locally
+
+### Requirements
+
+#### Doxygen
+
+The build system uses Doxygen [version 1.9.4](https://github.com/doxygen/doxygen/releases/tag/Release_1_9_4). You can try using a newer version, but that might cause issues.
+
+After you have downloaded Doxygen version 1.9.4:
+
+```shell
+# Add doxygen to your PATH
+echo 'export PATH=<doxygen 1.9.4 path>/bin:$PATH' >> ~/.bashrc
+
+# Apply the updated .bashrc
+source ~/.bashrc
+
+# Confirm that you are using version 1.9.4
+doxygen --version
+```
+
+#### Python
+
+The build system uses Python version 3.10. You can try using a newer version, but that might cause issues.
+
+You can install Python 3.10 alongside your other Python versions using [pyenv](https://github.com/pyenv/pyenv?tab=readme-ov-file#installation):
+
+```shell
+# Install Python 3.10
+pyenv install 3.10
+
+# Create a Python 3.10 virtual environment
+pyenv virtualenv 3.10 venv_rocrand
+
+# Activate the virtual environment
+pyenv activate venv_rocrand
+```
+
+### Building
+
+After cloning this repository, and `cd`ing into it:
+
+```shell
+# Install Python dependencies
+python3 -m pip install -r docs/sphinx/requirements.txt
+
+# Build the documentation
+python3 -m sphinx -T -E -b html -d docs/_build/doctrees -D language=en docs docs/_build/html
+```
+
+You can then open `docs/_build/html/index.html` in your browser to view the documentation.
+
 ## Support
 
 Bugs and feature requests can be reported through the
-[issue tracker](https://github.com/ROCm/rocRAND/issues).
+[issue tracker](https://github.com/ROCm/rocm-libraries/issues).
 
 ## Contributions and license
 
diff --git a/benchmark/benchmark_curand_device_api.cpp b/benchmark/benchmark_curand_device_api.cpp
index ec3123e..03a214b 100644
--- a/benchmark/benchmark_curand_device_api.cpp
+++ b/benchmark/benchmark_curand_device_api.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2022-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -38,19 +38,6 @@
 #include <utility>
 #include <vector>
 
-#define CUDA_CALL(condition)                                                               \
-    do                                                                                     \
-    {                                                                                      \
-        cudaError_t error_ = condition;                                                    \
-        if(error_ != cudaSuccess)                                                          \
-        {                                                                                  \
-            std::cout << "CUDA error: " << error_ << " at " << __FILE__ << ":" << __LINE__ \
-                      << std::endl;                                                        \
-            exit(error_);                                                                  \
-        }                                                                                  \
-    }                                                                                      \
-    while(0)
-
 #define CURAND_DEFAULT_MAX_BLOCK_SIZE 256
 
 #ifndef DEFAULT_RAND_N
@@ -100,7 +87,7 @@ struct runner
 
         init_kernel<<<blocks, threads>>>(states, seed, offset);
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
     }
 
@@ -127,7 +114,7 @@ __global__ __launch_bounds__(CURAND_DEFAULT_MAX_BLOCK_SIZE) void generate_kernel
 {
     const unsigned int state_id  = blockIdx.x;
     const unsigned int thread_id = threadIdx.x;
-    unsigned int       index     = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int       index     = blockIdx.x * blockDim.x + thread_id;
     unsigned int       stride    = gridDim.x * blockDim.x;
 
     __shared__ curandStateMtgp32_t state;
@@ -137,7 +124,13 @@ __global__ __launch_bounds__(CURAND_DEFAULT_MAX_BLOCK_SIZE) void generate_kernel
     __syncthreads();
 
     const size_t r               = size % blockDim.x;
-    const size_t size_rounded_up = r == 0 ? size : size + (blockDim.x - r);
+    const size_t size_rounded_down = size - r;
+    const size_t size_rounded_up   = r == 0 ? size : size_rounded_down + blockDim.x;
+    while(index < size_rounded_down)
+    {
+        data[index] = generator(&state);
+        index += stride;
+    }
     while(index < size_rounded_up)
     {
         auto value = generator(&state);
@@ -258,12 +251,13 @@ struct runner<curandStateSobol32_t>
     {
         this->dimensions = dimensions;
 
-        const size_t states_size = blocks * threads * dimensions;
-        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateSobol32_t)));
-
         curandDirectionVectors32_t* h_directions;
         CURAND_CALL(
             curandGetDirectionVectors32(&h_directions, CURAND_DIRECTION_VECTORS_32_JOEKUO6));
+
+        const size_t states_size = blocks * threads * dimensions;
+        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateSobol32_t)));
+
         unsigned int* directions;
         const size_t  size = dimensions * sizeof(unsigned int) * 32;
         CUDA_CALL(cudaMalloc(&directions, size));
@@ -275,7 +269,7 @@ struct runner<curandStateSobol32_t>
             directions,
             static_cast<unsigned int>(offset));
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
 
         CUDA_CALL(cudaFree(directions));
@@ -316,26 +310,26 @@ struct runner<curandStateScrambledSobol32_t>
     {
         this->dimensions = dimensions;
 
-        const size_t states_size = blocks * threads * dimensions;
-        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateScrambledSobol32_t)));
-
         curandDirectionVectors32_t* h_directions;
+        unsigned int*               h_constants;
+
         CURAND_CALL(
             curandGetDirectionVectors32(&h_directions, CURAND_DIRECTION_VECTORS_32_JOEKUO6));
+        CURAND_CALL(curandGetScrambleConstants32(&h_constants));
+
+        const size_t states_size = blocks * threads * dimensions;
+        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateScrambledSobol32_t)));
+
         unsigned int* directions;
-        const size_t  size = dimensions * sizeof(unsigned int) * 32;
-        CUDA_CALL(cudaMalloc(&directions, size));
-        CUDA_CALL(cudaMemcpy(directions, h_directions, size, cudaMemcpyHostToDevice));
+        const size_t  directions_size = dimensions * sizeof(unsigned int) * 32;
+        CUDA_CALL(cudaMalloc(&directions, directions_size));
+        CUDA_CALL(cudaMemcpy(directions, h_directions, directions_size, cudaMemcpyHostToDevice));
 
-        unsigned int* h_scramble_constants;
-        CURAND_CALL(curandGetScrambleConstants32(&h_scramble_constants));
         unsigned int* scramble_constants;
         const size_t  constants_size = dimensions * sizeof(unsigned int);
         CUDA_CALL(cudaMalloc(&scramble_constants, constants_size));
-        CUDA_CALL(cudaMemcpy(scramble_constants,
-                             h_scramble_constants,
-                             constants_size,
-                             cudaMemcpyHostToDevice));
+        CUDA_CALL(
+            cudaMemcpy(scramble_constants, h_constants, constants_size, cudaMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
         init_scrambled_sobol_kernel<<<dim3(blocks_x, dimensions), threads>>>(
@@ -344,7 +338,7 @@ struct runner<curandStateScrambledSobol32_t>
             scramble_constants,
             static_cast<unsigned int>(offset));
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
 
         CUDA_CALL(cudaFree(directions));
@@ -386,12 +380,13 @@ struct runner<curandStateSobol64_t>
     {
         this->dimensions = dimensions;
 
-        const size_t states_size = blocks * threads * dimensions;
-        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateSobol64_t)));
-
         curandDirectionVectors64_t* h_directions;
         CURAND_CALL(
             curandGetDirectionVectors64(&h_directions, CURAND_DIRECTION_VECTORS_64_JOEKUO6));
+
+        const size_t states_size = blocks * threads * dimensions;
+        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateSobol64_t)));
+
         unsigned long long int* directions;
         const size_t            size = dimensions * sizeof(unsigned long long) * 64;
         CUDA_CALL(cudaMalloc(&directions, size));
@@ -400,7 +395,7 @@ struct runner<curandStateSobol64_t>
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
         init_sobol_kernel<<<dim3(blocks_x, dimensions), threads>>>(states, directions, offset);
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
 
         CUDA_CALL(cudaFree(directions));
@@ -441,26 +436,26 @@ struct runner<curandStateScrambledSobol64_t>
     {
         this->dimensions = dimensions;
 
-        const size_t states_size = blocks * threads * dimensions;
-        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateScrambledSobol64_t)));
-
         curandDirectionVectors64_t* h_directions;
+        unsigned long long*         h_constants;
+
         CURAND_CALL(
             curandGetDirectionVectors64(&h_directions, CURAND_DIRECTION_VECTORS_64_JOEKUO6));
+        CURAND_CALL(curandGetScrambleConstants64(&h_constants));
+
+        const size_t states_size = blocks * threads * dimensions;
+        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateScrambledSobol64_t)));
+
         unsigned long long* directions;
-        const size_t        size = dimensions * sizeof(unsigned long long) * 64;
-        CUDA_CALL(cudaMalloc(&directions, size));
-        CUDA_CALL(cudaMemcpy(directions, h_directions, size, cudaMemcpyHostToDevice));
+        const size_t        directions_size = dimensions * sizeof(unsigned long long) * 64;
+        CUDA_CALL(cudaMalloc(&directions, directions_size));
+        CUDA_CALL(cudaMemcpy(directions, h_directions, directions_size, cudaMemcpyHostToDevice));
 
-        unsigned long long* h_scramble_constants;
-        CURAND_CALL(curandGetScrambleConstants64(&h_scramble_constants));
         unsigned long long* scramble_constants;
         const size_t        constants_size = dimensions * sizeof(unsigned long long);
         CUDA_CALL(cudaMalloc(&scramble_constants, constants_size));
-        CUDA_CALL(cudaMemcpy(scramble_constants,
-                             h_scramble_constants,
-                             constants_size,
-                             cudaMemcpyHostToDevice));
+        CUDA_CALL(
+            cudaMemcpy(scramble_constants, h_constants, constants_size, cudaMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
         init_scrambled_sobol_kernel<<<dim3(blocks_x, dimensions), threads>>>(states,
@@ -468,7 +463,7 @@ struct runner<curandStateScrambledSobol64_t>
                                                                              scramble_constants,
                                                                              offset);
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
 
         CUDA_CALL(cudaFree(directions));
@@ -722,7 +717,7 @@ void run_benchmark(benchmark::State&        state,
     for(size_t i = 0; i < 5; i++)
     {
         r.generate(blocks, threads, stream, data, size, generator);
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
     }
 
@@ -819,6 +814,14 @@ void add_benchmarks(const benchmark_context&                      ctx,
 
 int main(int argc, char* argv[])
 {
+    // get paramaters before they are passed into
+    // benchmark::Initialize()
+    std::string outFormat     = "";
+    std::string filter        = "";
+    std::string consoleFormat = "";
+
+    getFormats(argc, argv, outFormat, filter, consoleFormat);
+
     benchmark::Initialize(&argc, argv);
 
     cli::Parser parser(argc, argv);
@@ -884,8 +887,20 @@ int main(int argc, char* argv[])
         b->Unit(benchmark::kMillisecond);
     }
 
+    benchmark::BenchmarkReporter* console_reporter  = getConsoleReporter(consoleFormat);
+    benchmark::BenchmarkReporter* out_file_reporter = getOutFileReporter(outFormat);
+
+    std::string spec = (filter == "" || filter == "all") ? "." : filter;
+
     // Run benchmarks
-    benchmark::RunSpecifiedBenchmarks();
+    if(outFormat == "") // default case
+    {
+        benchmark::RunSpecifiedBenchmarks(console_reporter, spec);
+    }
+    else
+    {
+        benchmark::RunSpecifiedBenchmarks(console_reporter, out_file_reporter, spec);
+    }
     CUDA_CALL(cudaStreamDestroy(stream));
 
     return 0;
diff --git a/benchmark/benchmark_curand_generate.cpp b/benchmark/benchmark_curand_generate.cpp
index c3c450f..f85338b 100644
--- a/benchmark/benchmark_curand_generate.cpp
+++ b/benchmark/benchmark_curand_generate.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -52,11 +52,17 @@ template<typename T>
 void run_benchmark(const cli::Parser&    parser,
                    const rng_type_t      rng_type,
                    cudaStream_t          stream,
-                   generate_func_type<T> generate_func)
+                   generate_func_type<T> generate_func,
+                   const std::string&    distribution,
+                   const std::string&    engine,
+                   const double          lambda = 0.f)
 {
-    const size_t size = parser.get<size_t>("size");
-    const size_t trials = parser.get<size_t>("trials");
-    const size_t offset = parser.get<size_t>("offset");
+    const size_t      size0      = parser.get<size_t>("size");
+    const size_t      trials     = parser.get<size_t>("trials");
+    const size_t      dimensions = parser.get<size_t>("dimensions");
+    const size_t      offset     = parser.get<size_t>("offset");
+    const size_t      size       = (size0 / dimensions) * dimensions;
+    const std::string format     = parser.get<std::string>("format");
 
     T * data;
     CUDA_CALL(cudaMalloc(&data, size * sizeof(T)));
@@ -64,7 +70,6 @@ void run_benchmark(const cli::Parser&    parser,
     curandGenerator_t generator;
     CURAND_CALL(curandCreateGenerator(&generator, rng_type));
 
-    const size_t dimensions = parser.get<size_t>("dimensions");
     curandStatus_t status = curandSetQuasiRandomGeneratorDimensions(generator, dimensions);
     if (status != CURAND_STATUS_TYPE_ERROR) // If the RNG is not quasi-random
     {
@@ -90,7 +95,6 @@ void run_benchmark(const cli::Parser&    parser,
     cudaEvent_t start, stop;
     CUDA_CALL(cudaEventCreate(&start));
     CUDA_CALL(cudaEventCreate(&stop));
-
     CUDA_CALL(cudaEventRecord(start, stream));
     for (size_t i = 0; i < trials; i++)
     {
@@ -98,21 +102,40 @@ void run_benchmark(const cli::Parser&    parser,
     }
     CUDA_CALL(cudaEventRecord(stop, stream));
     CUDA_CALL(cudaEventSynchronize(stop));
-
     float elapsed;
     CUDA_CALL(cudaEventElapsedTime(&elapsed, start, stop));
-
     CUDA_CALL(cudaEventDestroy(stop));
     CUDA_CALL(cudaEventDestroy(start));
 
-    std::cout << std::fixed << std::setprecision(3) << "      "
-              << "Throughput = " << std::setw(8)
-              << (trials * size * sizeof(T)) / (elapsed / 1e3 * (1 << 30))
-              << " GB/s, Samples = " << std::setw(8)
-              << (trials * size) / (elapsed / 1e3 * (1 << 30))
-              << " GSample/s, AvgTime (1 trial) = " << std::setw(8) << elapsed / trials
-              << " ms, Time (all) = " << std::setw(8) << elapsed << " ms, Size = " << size
-              << std::endl;
+    if(format.compare("csv") == 0)
+    {
+        std::cout << std::fixed << std::setprecision(3) << engine << "," << distribution << ","
+                  << (trials * size * sizeof(T)) / (elapsed / 1e3 * (1 << 30)) << ","
+                  << (trials * size) / (elapsed / 1e3 * (1 << 30)) << "," << elapsed / trials << ","
+                  << elapsed << "," << size << ",";
+        if(distribution.compare("poisson") == 0 || distribution.compare("discrete-poisson") == 0)
+        {
+            std::cout << lambda;
+        }
+        std::cout << std::endl;
+    }
+    else
+    {
+        if(format.compare("console") != 0)
+        {
+            std::cout << "Unknown format specified (must be either console or csv).  Defaulting to "
+                         "console output."
+                      << std::endl;
+        }
+        std::cout << std::fixed << std::setprecision(3) << "      "
+                  << "Throughput = " << std::setw(8)
+                  << (trials * size * sizeof(T)) / (elapsed / 1e3 * (1 << 30))
+                  << " GB/s, Samples = " << std::setw(8)
+                  << (trials * size) / (elapsed / 1e3 * (1 << 30))
+                  << " GSample/s, AvgTime (1 trial) = " << std::setw(8) << elapsed / trials
+                  << " ms, Time (all) = " << std::setw(8) << elapsed << " ms, Size = " << size
+                  << std::endl;
+    }
 
     CURAND_CALL(curandDestroyGenerator(generator));
     CUDA_CALL(cudaFree(data));
@@ -121,94 +144,123 @@ void run_benchmark(const cli::Parser&    parser,
 void run_benchmarks(const cli::Parser& parser,
                     const rng_type_t   rng_type,
                     const std::string& distribution,
+                    const std::string& engine,
                     cudaStream_t       stream)
 {
+    const std::string format = parser.get<std::string>("format");
     if (distribution == "uniform-uint")
     {
-        if (rng_type != CURAND_RNG_QUASI_SOBOL64 &&
-            rng_type != CURAND_RNG_QUASI_SCRAMBLED_SOBOL64)
+        if(rng_type != CURAND_RNG_QUASI_SOBOL64 && rng_type != CURAND_RNG_QUASI_SCRAMBLED_SOBOL64)
         {
-            run_benchmark<unsigned int>(parser,
-                                        rng_type,
-                                        stream,
-                                        [](curandGenerator_t gen, unsigned int* data, size_t size)
-                                        { return curandGenerate(gen, data, size); });
+            run_benchmark<unsigned int>(
+                parser,
+                rng_type,
+                stream,
+                [](curandGenerator_t gen, unsigned int* data, size_t size)
+                { return curandGenerate(gen, data, size); },
+                distribution,
+                engine);
         }
     }
     if (distribution == "uniform-long-long")
     {
-        if (rng_type == CURAND_RNG_QUASI_SOBOL64 ||
-            rng_type == CURAND_RNG_QUASI_SCRAMBLED_SOBOL64)
+        if(rng_type == CURAND_RNG_QUASI_SOBOL64 || rng_type == CURAND_RNG_QUASI_SCRAMBLED_SOBOL64)
         {
             run_benchmark<unsigned long long>(
                 parser,
                 rng_type,
                 stream,
                 [](curandGenerator_t gen, unsigned long long* data, size_t size)
-                { return curandGenerateLongLong(gen, data, size); });
+                { return curandGenerateLongLong(gen, data, size); },
+                distribution,
+                engine);
         }
     }
     if (distribution == "uniform-float")
     {
-        run_benchmark<float>(parser,
-                             rng_type,
-                             stream,
-                             [](curandGenerator_t gen, float* data, size_t size)
-                             { return curandGenerateUniform(gen, data, size); });
+        run_benchmark<float>(
+            parser,
+            rng_type,
+            stream,
+            [](curandGenerator_t gen, float* data, size_t size)
+            { return curandGenerateUniform(gen, data, size); },
+            distribution,
+            engine);
     }
     if (distribution == "uniform-double")
     {
-        run_benchmark<double>(parser,
-                              rng_type,
-                              stream,
-                              [](curandGenerator_t gen, double* data, size_t size)
-                              { return curandGenerateUniformDouble(gen, data, size); });
+        run_benchmark<double>(
+            parser,
+            rng_type,
+            stream,
+            [](curandGenerator_t gen, double* data, size_t size)
+            { return curandGenerateUniformDouble(gen, data, size); },
+            distribution,
+            engine);
     }
     if (distribution == "normal-float")
     {
-        run_benchmark<float>(parser,
-                             rng_type,
-                             stream,
-                             [](curandGenerator_t gen, float* data, size_t size)
-                             { return curandGenerateNormal(gen, data, size, 0.0f, 1.0f); });
+        run_benchmark<float>(
+            parser,
+            rng_type,
+            stream,
+            [](curandGenerator_t gen, float* data, size_t size)
+            { return curandGenerateNormal(gen, data, size, 0.0f, 1.0f); },
+            distribution,
+            engine);
     }
     if (distribution == "normal-double")
     {
-        run_benchmark<double>(parser,
-                              rng_type,
-                              stream,
-                              [](curandGenerator_t gen, double* data, size_t size)
-                              { return curandGenerateNormalDouble(gen, data, size, 0.0, 1.0); });
+        run_benchmark<double>(
+            parser,
+            rng_type,
+            stream,
+            [](curandGenerator_t gen, double* data, size_t size)
+            { return curandGenerateNormalDouble(gen, data, size, 0.0, 1.0); },
+            distribution,
+            engine);
     }
     if (distribution == "log-normal-float")
     {
-        run_benchmark<float>(parser,
-                             rng_type,
-                             stream,
-                             [](curandGenerator_t gen, float* data, size_t size)
-                             { return curandGenerateLogNormal(gen, data, size, 0.0f, 1.0f); });
+        run_benchmark<float>(
+            parser,
+            rng_type,
+            stream,
+            [](curandGenerator_t gen, float* data, size_t size)
+            { return curandGenerateLogNormal(gen, data, size, 0.0f, 1.0f); },
+            distribution,
+            engine);
     }
     if (distribution == "log-normal-double")
     {
-        run_benchmark<double>(parser,
-                              rng_type,
-                              stream,
-                              [](curandGenerator_t gen, double* data, size_t size)
-                              { return curandGenerateLogNormalDouble(gen, data, size, 0.0, 1.0); });
+        run_benchmark<double>(
+            parser,
+            rng_type,
+            stream,
+            [](curandGenerator_t gen, double* data, size_t size)
+            { return curandGenerateLogNormalDouble(gen, data, size, 0.0, 1.0); },
+            distribution,
+            engine);
     }
     if (distribution == "poisson")
     {
         const auto lambdas = parser.get<std::vector<double>>("lambda");
         for (double lambda : lambdas)
         {
-            std::cout << "    " << "lambda "
-                 << std::fixed << std::setprecision(1) << lambda << std::endl;
+            if(format.compare("console") == 0)
+            {
+                std::cout << "    "
+                          << "lambda " << std::fixed << std::setprecision(1) << lambda << std::endl;
+            }
             run_benchmark<unsigned int>(
                 parser,
                 rng_type,
                 stream,
                 [lambda](curandGenerator_t gen, unsigned int* data, size_t size)
-                { return curandGeneratePoisson(gen, data, size, lambda); });
+                { return curandGeneratePoisson(gen, data, size, lambda); },
+                distribution,
+                engine,
+                lambda);
         }
     }
 }
@@ -265,6 +317,10 @@ int main(int argc, char *argv[])
     parser.set_optional<std::vector<std::string>>("dis", "dis", {"uniform-uint"}, distribution_desc.c_str());
     parser.set_optional<std::vector<std::string>>("engine", "engine", {"philox"}, engine_desc.c_str());
     parser.set_optional<std::vector<double>>("lambda", "lambda", {10.0}, "space-separated list of lambdas of Poisson distribution");
+    parser.set_optional<std::string>("format",
+                                     "format",
+                                     {"console"},
+                                     "output format: console or csv");
     parser.run_and_exit_if_error();
 
     std::vector<std::string> engines;
@@ -310,6 +366,7 @@ int main(int argc, char *argv[])
     cudaDeviceProp props;
     CUDA_CALL(cudaGetDeviceProperties(&props, device_id));
 
+    std::cout << "benchmark_curand_generate" << std::endl;
     std::cout << "cuRAND: " << version << " ";
     std::cout << "Runtime: " << runtime_version << " ";
     std::cout << "Device: " << props.name;
@@ -318,6 +375,17 @@ int main(int argc, char *argv[])
     cudaStream_t stream;
     CUDA_CALL(cudaStreamCreate(&stream));
 
+    std::string format         = parser.get<std::string>("format");
+    bool        console_output = format.compare("console") == 0 ? true : false;
+
+    if(!console_output)
+    {
+        std::cout
+            << "Engine,Distribution,Throughput,Samples,AvgTime (1 Trial),Time(all),Size,Lambda"
+            << std::endl;
+        std::cout << ",,GB/s,GSample/s,ms),ms),values," << std::endl;
+    }
+
     for (auto engine : engines)
     {
         rng_type_t rng_type = CURAND_RNG_PSEUDO_XORWOW;
@@ -345,12 +413,14 @@ int main(int argc, char *argv[])
             exit(1);
         }
 
-        std::cout << engine << ":" << std::endl;
+        if(console_output)
+            std::cout << engine << ":" << std::endl;
 
         for (auto distribution : distributions)
         {
-            std::cout << "  " << distribution << ":" << std::endl;
-            run_benchmarks(parser, rng_type, distribution, stream);
+            if(console_output)
+                std::cout << "  " << distribution << ":" << std::endl;
+            run_benchmarks(parser, rng_type, distribution, engine, stream);
         }
         std::cout << std::endl;
     }
diff --git a/benchmark/benchmark_curand_host_api.cpp b/benchmark/benchmark_curand_host_api.cpp
index ddb121f..e1a099d 100644
--- a/benchmark/benchmark_curand_host_api.cpp
+++ b/benchmark/benchmark_curand_host_api.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -21,22 +21,11 @@
 #include "benchmark_curand_utils.hpp"
 #include "cmdparser.hpp"
 
+#include <benchmark/benchmark.h>
+
 #include <cuda_runtime.h>
 #include <curand.h>
 
-#define CUDA_CALL(condition)                                                               \
-    do                                                                                     \
-    {                                                                                      \
-        cudaError_t error_ = condition;                                                    \
-        if(error_ != cudaSuccess)                                                          \
-        {                                                                                  \
-            std::cout << "CUDA error: " << error_ << " at " << __FILE__ << ":" << __LINE__ \
-                      << std::endl;                                                        \
-            exit(error_);                                                                  \
-        }                                                                                  \
-    }                                                                                      \
-    while(0)
-
 #ifndef DEFAULT_RAND_N
 const size_t DEFAULT_RAND_N = 1024 * 1024 * 128;
 #endif
@@ -48,29 +37,36 @@ using generate_func_type = std::function<curandStatus_t(curandGenerator_t, T*, s
 
 template<typename T>
 void run_benchmark(benchmark::State&     state,
-                   const rng_type_t      rng_type,
                    generate_func_type<T> generate_func,
                    const size_t          size,
+                   const bool            byte_size,
                    const size_t          trials,
-                   const size_t          offset,
                    const size_t          dimensions,
+                   const size_t          offset,
+                   const rng_type_t      rng_type,
+                   const curandOrdering  ordering,
                    const bool            benchmark_host,
                    cudaStream_t          stream)
 {
+    const size_t binary_div   = byte_size ? sizeof(T) : 1;
+    const size_t rounded_size = (size / binary_div / dimensions) * dimensions;
+
     T*                data;
     curandGenerator_t generator;
 
     if(benchmark_host)
     {
-        data = new T[size];
+        data = new T[rounded_size];
         CURAND_CALL(curandCreateGeneratorHost(&generator, rng_type));
     }
     else
     {
-        CUDA_CALL(cudaMalloc(&data, size * sizeof(T)));
+        CUDA_CALL(cudaMalloc(&data, rounded_size * sizeof(T)));
         CURAND_CALL(curandCreateGenerator(&generator, rng_type));
     }
 
+    CURAND_CALL(curandSetGeneratorOrdering(generator, ordering));
+
     curandStatus_t status = curandSetQuasiRandomGeneratorDimensions(generator, dimensions);
     if(status != CURAND_STATUS_TYPE_ERROR) // If the RNG is not quasi-random
     {
@@ -88,7 +84,7 @@ void run_benchmark(benchmark::State&     state,
     // Warm-up
     for(size_t i = 0; i < 15; i++)
     {
-        CURAND_CALL(generate_func(generator, data, size));
+        CURAND_CALL(generate_func(generator, data, rounded_size));
     }
     CUDA_CALL(cudaDeviceSynchronize());
 
@@ -96,28 +92,27 @@ void run_benchmark(benchmark::State&     state,
     cudaEvent_t start, stop;
     CUDA_CALL(cudaEventCreate(&start));
     CUDA_CALL(cudaEventCreate(&stop));
-
     for(auto _ : state)
     {
         CUDA_CALL(cudaEventRecord(start, stream));
         for(size_t i = 0; i < trials; i++)
         {
-            CURAND_CALL(generate_func(generator, data, size));
+            CURAND_CALL(generate_func(generator, data, rounded_size));
         }
         CUDA_CALL(cudaEventRecord(stop, stream));
         CUDA_CALL(cudaEventSynchronize(stop));
 
         float elapsed = 0.0f;
         CUDA_CALL(cudaEventElapsedTime(&elapsed, start, stop));
+
         state.SetIterationTime(elapsed / 1000.f);
     }
 
-    state.SetBytesProcessed(trials * state.iterations() * size * sizeof(T));
-    state.SetItemsProcessed(trials * state.iterations() * size);
+    state.SetBytesProcessed(trials * state.iterations() * rounded_size * sizeof(T));
+    state.SetItemsProcessed(trials * state.iterations() * rounded_size);
 
     CUDA_CALL(cudaEventDestroy(stop));
     CUDA_CALL(cudaEventDestroy(start));
-
     CURAND_CALL(curandDestroyGenerator(generator));
 
     if(benchmark_host)
@@ -133,6 +128,10 @@ void run_benchmark(benchmark::State&     state,
 void configure_parser(cli::Parser& parser)
 {
     parser.set_optional<size_t>("size", "size", DEFAULT_RAND_N, "number of values");
+    parser.set_optional<bool>("byte-size",
+                              "byte-size",
+                              false,
+                              "--size is interpreted as the number of generated bytes");
     parser.set_optional<size_t>("trials", "trials", 20, "number of trials");
     parser.set_optional<size_t>("offset", "offset", 0, "offset of generated pseudo-random values");
     parser.set_optional<size_t>("dimensions",
@@ -152,6 +151,14 @@ void configure_parser(cli::Parser& parser)
 
 int main(int argc, char* argv[])
 {
+    // get paramaters before they are passed into
+    std::string outFormat     = "";
+    std::string filter        = "";
+    std::string consoleFormat = "";
+
+    getFormats(argc, argv, outFormat, filter, consoleFormat);
+
+    // Parse argv
     benchmark::Initialize(&argc, argv);
 
     // Parse arguments from command line
@@ -165,6 +172,7 @@ int main(int argc, char* argv[])
     add_common_benchmark_curand_info();
 
     const size_t              size            = parser.get<size_t>("size");
+    const bool                byte_size       = parser.get<bool>("byte-size");
     const size_t              trials          = parser.get<size_t>("trials");
     const size_t              offset          = parser.get<size_t>("offset");
     const size_t              dimensions      = parser.get<size_t>("dimensions");
@@ -172,12 +180,13 @@ int main(int argc, char* argv[])
     const bool                benchmark_host  = parser.get<bool>("host");
 
     benchmark::AddCustomContext("size", std::to_string(size));
+    benchmark::AddCustomContext("byte-size", std::to_string(byte_size));
     benchmark::AddCustomContext("trials", std::to_string(trials));
     benchmark::AddCustomContext("offset", std::to_string(offset));
     benchmark::AddCustomContext("dimensions", std::to_string(dimensions));
     benchmark::AddCustomContext("benchmark_host", std::to_string(benchmark_host));
 
-    const std::vector<rng_type_t> engine_types{
+    const std::vector<rng_type_t> benchmarked_engine_types{
         CURAND_RNG_PSEUDO_MT19937,
         CURAND_RNG_PSEUDO_MTGP32,
         CURAND_RNG_PSEUDO_MRG32K3A,
@@ -189,147 +198,214 @@ int main(int argc, char* argv[])
         CURAND_RNG_PSEUDO_XORWOW,
     };
 
-    const std::string                            benchmark_name_prefix = "device_generate";
-    std::vector<benchmark::internal::Benchmark*> benchmarks            = {};
+    const std::map<curandOrdering, std::string> ordering_name_map{
+        {CURAND_ORDERING_PSEUDO_DEFAULT, "default"},
+        { CURAND_ORDERING_PSEUDO_LEGACY,  "legacy"},
+        {   CURAND_ORDERING_PSEUDO_BEST,    "best"},
+        {CURAND_ORDERING_PSEUDO_DYNAMIC, "dynamic"},
+        { CURAND_ORDERING_PSEUDO_SEEDED,  "seeded"},
+        { CURAND_ORDERING_QUASI_DEFAULT, "default"},
+    };
 
+    const std::map<rng_type_t, std::vector<curandOrdering>> benchmarked_orderings{
+  // clang-format off
+        {          CURAND_RNG_PSEUDO_MTGP32,
+            {CURAND_ORDERING_PSEUDO_DEFAULT, CURAND_ORDERING_PSEUDO_DYNAMIC}},
+        {         CURAND_RNG_PSEUDO_MT19937, {CURAND_ORDERING_PSEUDO_DEFAULT}},
+        {          CURAND_RNG_PSEUDO_XORWOW,
+            {CURAND_ORDERING_PSEUDO_DEFAULT, CURAND_ORDERING_PSEUDO_DYNAMIC} },
+        {        CURAND_RNG_PSEUDO_MRG32K3A,
+            {CURAND_ORDERING_PSEUDO_DEFAULT, CURAND_ORDERING_PSEUDO_DYNAMIC}},
+        {   CURAND_RNG_PSEUDO_PHILOX4_32_10,
+            {CURAND_ORDERING_PSEUDO_DEFAULT, CURAND_ORDERING_PSEUDO_DYNAMIC}},
+        {          CURAND_RNG_QUASI_SOBOL32,  {CURAND_ORDERING_QUASI_DEFAULT}},
+        {CURAND_RNG_QUASI_SCRAMBLED_SOBOL32,  {CURAND_ORDERING_QUASI_DEFAULT}},
+        {          CURAND_RNG_QUASI_SOBOL64,  {CURAND_ORDERING_QUASI_DEFAULT}},
+        {CURAND_RNG_QUASI_SCRAMBLED_SOBOL64,  {CURAND_ORDERING_QUASI_DEFAULT}},
+  // clang-format on
+    };
+
+    const std::string benchmark_name_prefix = "device_generate";
     // Add benchmarks
-    for(const rng_type_t engine_type : engine_types)
+    std::vector<benchmark::internal::Benchmark*> benchmarks = {};
+    for(const rng_type_t engine_type : benchmarked_engine_types)
     {
-        const std::string benchmark_name_engine
-            = benchmark_name_prefix + "<" + engine_name(engine_type) + ",";
+        const std::string name = engine_name(engine_type);
+        for(const curandOrdering ordering : benchmarked_orderings.at(engine_type))
+        {
+            const std::string name_engine_prefix
+                = benchmark_name_prefix + "<" + name + "," + ordering_name_map.at(ordering) + ",";
+
+            if(engine_type != CURAND_RNG_QUASI_SOBOL64
+               && engine_type != CURAND_RNG_QUASI_SCRAMBLED_SOBOL64)
+
+            {
+                benchmarks.emplace_back(benchmark::RegisterBenchmark(
+                    (name_engine_prefix + "uniform-uint>").c_str(),
+                    &run_benchmark<unsigned int>,
+                    [](curandGenerator_t gen, unsigned int* data, size_t size_gen)
+                    { return curandGenerate(gen, data, size_gen); },
+                    size,
+                    byte_size,
+                    trials,
+                    dimensions,
+                    offset,
+                    engine_type,
+                    ordering,
+                    benchmark_host,
+                    stream));
+            }
+            else
+            {
+                benchmarks.emplace_back(benchmark::RegisterBenchmark(
+                    (name_engine_prefix + "uniform-long-long>").c_str(),
+                    &run_benchmark<unsigned long long>,
+                    [](curandGenerator_t gen, unsigned long long* data, size_t size)
+                    { return curandGenerateLongLong(gen, data, size); },
+                    size,
+                    byte_size,
+                    trials,
+                    dimensions,
+                    offset,
+                    engine_type,
+                    ordering,
+                    benchmark_host,
+                    stream));
+            }
+
+            benchmarks.emplace_back(
+                benchmark::RegisterBenchmark((name_engine_prefix + "uniform-float>").c_str(),
+                                             &run_benchmark<float>,
+                                             [](curandGenerator_t gen, float* data, size_t size_gen)
+                                             { return curandGenerateUniform(gen, data, size_gen); },
+                                             size,
+                                             byte_size,
+                                             trials,
+                                             dimensions,
+                                             offset,
+                                             engine_type,
+                                             ordering,
+                                             benchmark_host,
+                                             stream));
 
-        if(engine_type != CURAND_RNG_QUASI_SOBOL64
-           && engine_type != CURAND_RNG_QUASI_SCRAMBLED_SOBOL64)
             benchmarks.emplace_back(benchmark::RegisterBenchmark(
-                (benchmark_name_engine + "uniform-uint>").c_str(),
-                &run_benchmark<unsigned int>,
-                engine_type,
-                [](curandGenerator_t gen, unsigned int* data, size_t size)
-                { return curandGenerate(gen, data, size); },
+                (name_engine_prefix + "uniform-double>").c_str(),
+                &run_benchmark<double>,
+                [](curandGenerator_t gen, double* data, size_t size_gen)
+                { return curandGenerateUniformDouble(gen, data, size_gen); },
                 size,
+                byte_size,
                 trials,
-                offset,
                 dimensions,
+                offset,
+                engine_type,
+                ordering,
                 benchmark_host,
                 stream));
-        else
+
             benchmarks.emplace_back(benchmark::RegisterBenchmark(
-                (benchmark_name_engine + "uniform-long-long>").c_str(),
-                &run_benchmark<unsigned long long>,
-                engine_type,
-                [](curandGenerator_t gen, unsigned long long* data, size_t size)
-                { return curandGenerateLongLong(gen, data, size); },
+                (name_engine_prefix + "normal-float>").c_str(),
+                &run_benchmark<float>,
+                [](curandGenerator_t gen, float* data, size_t size_gen)
+                { return curandGenerateNormal(gen, data, size_gen, 0.0f, 1.0f); },
                 size,
+                byte_size,
                 trials,
-                offset,
                 dimensions,
+                offset,
+                engine_type,
+                ordering,
                 benchmark_host,
                 stream));
 
-        benchmarks.emplace_back(
-            benchmark::RegisterBenchmark((benchmark_name_engine + "uniform-float>").c_str(),
-                                         &run_benchmark<float>,
-                                         engine_type,
-                                         [](curandGenerator_t gen, float* data, size_t size)
-                                         { return curandGenerateUniform(gen, data, size); },
-                                         size,
-                                         trials,
-                                         offset,
-                                         dimensions,
-                                         benchmark_host,
-                                         stream));
-
-        benchmarks.emplace_back(
-            benchmark::RegisterBenchmark((benchmark_name_engine + "uniform-double>").c_str(),
-                                         &run_benchmark<double>,
-                                         engine_type,
-                                         [](curandGenerator_t gen, double* data, size_t size)
-                                         { return curandGenerateUniformDouble(gen, data, size); },
-                                         size,
-                                         trials,
-                                         offset,
-                                         dimensions,
-                                         benchmark_host,
-                                         stream));
-
-        benchmarks.emplace_back(benchmark::RegisterBenchmark(
-            (benchmark_name_engine + "normal-float>").c_str(),
-            &run_benchmark<float>,
-            engine_type,
-            [](curandGenerator_t gen, float* data, size_t size)
-            { return curandGenerateNormal(gen, data, size, 0.0f, 1.0f); },
-            size,
-            trials,
-            offset,
-            dimensions,
-            benchmark_host,
-            stream));
-
-        benchmarks.emplace_back(benchmark::RegisterBenchmark(
-            (benchmark_name_engine + "normal-double>").c_str(),
-            &run_benchmark<double>,
-            engine_type,
-            [](curandGenerator_t gen, double* data, size_t size)
-            { return curandGenerateNormalDouble(gen, data, size, 0.0, 1.0); },
-            size,
-            trials,
-            offset,
-            dimensions,
-            benchmark_host,
-            stream));
-
-        benchmarks.emplace_back(benchmark::RegisterBenchmark(
-            (benchmark_name_engine + "log-normal-float>").c_str(),
-            &run_benchmark<float>,
-            engine_type,
-            [](curandGenerator_t gen, float* data, size_t size)
-            { return curandGenerateLogNormal(gen, data, size, 0.0f, 1.0f); },
-            size,
-            trials,
-            offset,
-            dimensions,
-            benchmark_host,
-            stream));
-
-        benchmarks.emplace_back(benchmark::RegisterBenchmark(
-            (benchmark_name_engine + "log-normal-double>").c_str(),
-            &run_benchmark<double>,
-            engine_type,
-            [](curandGenerator_t gen, double* data, size_t size)
-            { return curandGenerateLogNormalDouble(gen, data, size, 0.0, 1.0); },
-            size,
-            trials,
-            offset,
-            dimensions,
-            benchmark_host,
-            stream));
-
-        for(auto lambda : poisson_lambdas)
-        {
-            const std::string poisson_dis_name
-                = std::string("poisson(lambda=") + std::to_string(lambda) + ")>";
-
             benchmarks.emplace_back(benchmark::RegisterBenchmark(
-                (benchmark_name_engine + poisson_dis_name).c_str(),
-                &run_benchmark<unsigned int>,
+                (name_engine_prefix + "normal-double>").c_str(),
+                &run_benchmark<double>,
+                [](curandGenerator_t gen, double* data, size_t size_gen)
+                { return curandGenerateNormalDouble(gen, data, size_gen, 0.0, 1.0); },
+                size,
+                byte_size,
+                trials,
+                dimensions,
+                offset,
                 engine_type,
-                [lambda](curandGenerator_t gen, unsigned int* data, size_t size)
-                { return curandGeneratePoisson(gen, data, size, lambda); },
+                ordering,
+                benchmark_host,
+                stream));
+
+            benchmarks.emplace_back(benchmark::RegisterBenchmark(
+                (name_engine_prefix + "log-normal-float>").c_str(),
+                &run_benchmark<float>,
+                [](curandGenerator_t gen, float* data, size_t size_gen)
+                { return curandGenerateLogNormal(gen, data, size_gen, 0.0f, 1.0f); },
                 size,
+                byte_size,
                 trials,
+                dimensions,
                 offset,
+                engine_type,
+                ordering,
+                benchmark_host,
+                stream));
+
+            benchmarks.emplace_back(benchmark::RegisterBenchmark(
+                (name_engine_prefix + "log-normal-double>").c_str(),
+                &run_benchmark<double>,
+                [](curandGenerator_t gen, double* data, size_t size_gen)
+                { return curandGenerateLogNormalDouble(gen, data, size_gen, 0.0, 1.0); },
+                size,
+                byte_size,
+                trials,
                 dimensions,
+                offset,
+                engine_type,
+                ordering,
                 benchmark_host,
                 stream));
+
+            for(auto lambda : poisson_lambdas)
+            {
+                const std::string poisson_dis_name
+                    = std::string("poisson(lambda=") + std::to_string(lambda) + ")>";
+                benchmarks.emplace_back(benchmark::RegisterBenchmark(
+                    (name_engine_prefix + poisson_dis_name).c_str(),
+                    &run_benchmark<unsigned int>,
+                    [lambda](curandGenerator_t gen, unsigned int* data, size_t size_gen)
+                    { return curandGeneratePoisson(gen, data, size_gen, lambda); },
+                    size,
+                    byte_size,
+                    trials,
+                    dimensions,
+                    offset,
+                    engine_type,
+                    ordering,
+                    benchmark_host,
+                    stream));
+            }
         }
     }
-    // Use manual timing
+
     for(auto& b : benchmarks)
     {
         b->UseManualTime();
         b->Unit(benchmark::kMillisecond);
     }
-    benchmark::RunSpecifiedBenchmarks();
+
+    benchmark::BenchmarkReporter* console_reporter  = getConsoleReporter(consoleFormat);
+    benchmark::BenchmarkReporter* out_file_reporter = getOutFileReporter(outFormat);
+
+    std::string spec = (filter == "" || filter == "all") ? "." : filter;
+
+    // Run benchmarks
+    if(outFormat == "") // default case
+    {
+        benchmark::RunSpecifiedBenchmarks(console_reporter, spec);
+    }
+    else
+    {
+        benchmark::RunSpecifiedBenchmarks(console_reporter, out_file_reporter, spec);
+    }
+
     CUDA_CALL(cudaStreamDestroy(stream));
 
     return 0;
diff --git a/benchmark/benchmark_curand_kernel.cpp b/benchmark/benchmark_curand_kernel.cpp
index 6c205ff..df3e792 100644
--- a/benchmark/benchmark_curand_kernel.cpp
+++ b/benchmark/benchmark_curand_kernel.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -36,7 +36,7 @@
 #include <curand_mtgp32_host.h>
 #include <curand_mtgp32dc_p_11213.h>
 
-#define CUPRAND_DEFAULT_MAX_BLOCK_SIZE 256
+#define CURAND_DEFAULT_MAX_BLOCK_SIZE 256
 
 #define CUDA_CALL(x) do { \
     cudaError_t error = (x);\
@@ -63,8 +63,8 @@ size_t next_power2(size_t x)
 
 template<typename GeneratorState>
 __global__
-__launch_bounds__(CUPRAND_DEFAULT_MAX_BLOCK_SIZE)
-void init_kernel(GeneratorState * states,
+__launch_bounds__(CURAND_DEFAULT_MAX_BLOCK_SIZE)
+void init_kernel(GeneratorState*          states,
                  const unsigned long long seed,
                  const unsigned long long offset)
 {
@@ -76,12 +76,12 @@ void init_kernel(GeneratorState * states,
 
 template<typename GeneratorState, typename T, typename GenerateFunc, typename Extra>
 __global__
-__launch_bounds__(CUPRAND_DEFAULT_MAX_BLOCK_SIZE)
-void generate_kernel(GeneratorState * states,
-                     T * data,
-                     const size_t size,
-                     GenerateFunc generate_func,
-                     const Extra extra)
+__launch_bounds__(CURAND_DEFAULT_MAX_BLOCK_SIZE)
+void generate_kernel(GeneratorState* states,
+                     T*              data,
+                     const size_t    size,
+                     GenerateFunc    generate_func,
+                     const Extra     extra)
 {
     const unsigned int state_id = blockIdx.x * blockDim.x + threadIdx.x;
     const unsigned int stride = gridDim.x * blockDim.x;
@@ -112,7 +112,7 @@ struct runner
 
         init_kernel<<<blocks, threads>>>(states, seed, offset);
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
     }
 
@@ -127,12 +127,13 @@ struct runner
     }
 
     template<typename T, typename GenerateFunc, typename Extra>
-    void generate(const size_t blocks,
-                  const size_t threads,
-                  T * data,
-                  const size_t size,
+    void generate(const size_t        blocks,
+                  const size_t        threads,
+                  cudaStream_t        stream,
+                  T*                  data,
+                  const size_t        size,
                   const GenerateFunc& generate_func,
-                  const Extra extra)
+                  const Extra         extra)
     {
         generate_kernel<<<blocks, threads>>>(states, data, size, generate_func, extra);
     }
@@ -140,12 +141,12 @@ struct runner
 
 template<typename T, typename GenerateFunc, typename Extra>
 __global__
-__launch_bounds__(CUPRAND_DEFAULT_MAX_BLOCK_SIZE)
-void generate_kernel(curandStateMtgp32_t * states,
-                     T * data,
-                     const size_t size,
-                     GenerateFunc generate_func,
-                     const Extra extra)
+__launch_bounds__(CURAND_DEFAULT_MAX_BLOCK_SIZE)
+void generate_kernel(curandStateMtgp32_t* states,
+                     T*                   data,
+                     const size_t         size,
+                     GenerateFunc         generate_func,
+                     const Extra          extra)
 {
     const unsigned int state_id = blockIdx.x;
     const unsigned int thread_id = threadIdx.x;
@@ -159,7 +160,13 @@ void generate_kernel(curandStateMtgp32_t * states,
     __syncthreads();
 
     const size_t r = size%blockDim.x;
-    const size_t size_rounded_up = r == 0 ? size : size + (blockDim.x - r);
+    const size_t size_rounded_down = size - r;
+    const size_t size_rounded_up   = r == 0 ? size : size_rounded_down + blockDim.x;
+    while(index < size_rounded_down)
+    {
+        data[index] = generate_func(&state, extra);
+        index += stride;
+    }
     while(index < size_rounded_up)
     {
         auto value = generate_func(&state, extra);
@@ -207,18 +214,23 @@ struct runner<curandStateMtgp32_t>
     template<typename T, typename GenerateFunc, typename Extra>
     void generate(const size_t blocks,
                   const size_t /* threads */,
-                  T * data,
-                  const size_t size,
+                  cudaStream_t        stream,
+                  T*                  data,
+                  const size_t        size,
                   const GenerateFunc& generate_func,
-                  const Extra extra)
+                  const Extra         extra)
     {
-        generate_kernel<<<std::min((size_t)200, blocks), 256>>>(states, data, size, generate_func, extra);
+        generate_kernel<<<std::min((size_t)200, blocks), 256, 0, stream>>>(states,
+                                                                           data,
+                                                                           size,
+                                                                           generate_func,
+                                                                           extra);
     }
 };
 
 template<typename GeneratorState, typename SobolType>
-__global__ __launch_bounds__(CUPRAND_DEFAULT_MAX_BLOCK_SIZE) void init_sobol_kernel(
-    GeneratorState* states, SobolType* directions, SobolType offset)
+__global__ __launch_bounds__(CURAND_DEFAULT_MAX_BLOCK_SIZE)
+void init_sobol_kernel(GeneratorState* states, SobolType* directions, SobolType offset)
 {
     const unsigned int dimension = blockIdx.y;
     const unsigned int state_id = blockIdx.x * blockDim.x + threadIdx.x;
@@ -228,8 +240,11 @@ __global__ __launch_bounds__(CUPRAND_DEFAULT_MAX_BLOCK_SIZE) void init_sobol_ker
 }
 
 template<typename GeneratorState, typename SobolType>
-__global__ __launch_bounds__(CUPRAND_DEFAULT_MAX_BLOCK_SIZE) void init_scrambled_sobol_kernel(
-    GeneratorState* states, SobolType* directions, SobolType* scramble_constants, SobolType offset)
+__global__ __launch_bounds__(CURAND_DEFAULT_MAX_BLOCK_SIZE)
+void init_scrambled_sobol_kernel(GeneratorState* states,
+                                 SobolType*      directions,
+                                 SobolType*      scramble_constants,
+                                 SobolType       offset)
 {
     const unsigned int dimension = blockIdx.y;
     const unsigned int state_id  = blockIdx.x * blockDim.x + threadIdx.x;
@@ -243,12 +258,12 @@ __global__ __launch_bounds__(CUPRAND_DEFAULT_MAX_BLOCK_SIZE) void init_scrambled
 
 // generate_kernel for the sobol generators
 template<typename GeneratorState, typename T, typename GenerateFunc, typename Extra>
-__global__ __launch_bounds__(CUPRAND_DEFAULT_MAX_BLOCK_SIZE) void generate_sobol_kernel(
-    GeneratorState* states,
-    T*              data,
-    const size_t    size,
-    GenerateFunc    generate_func,
-    const Extra     extra)
+__global__ __launch_bounds__(CURAND_DEFAULT_MAX_BLOCK_SIZE)
+void generate_sobol_kernel(GeneratorState* states,
+                           T*              data,
+                           const size_t    size,
+                           GenerateFunc    generate_func,
+                           const Extra     extra)
 {
     const unsigned int dimension = blockIdx.y;
     const unsigned int state_id = blockIdx.x * blockDim.x + threadIdx.x;
@@ -282,11 +297,13 @@ struct runner<curandStateSobol32_t>
     {
         this->dimensions = dimensions;
 
+        curandDirectionVectors32_t* h_directions;
+        CURAND_CALL(
+            curandGetDirectionVectors32(&h_directions, CURAND_DIRECTION_VECTORS_32_JOEKUO6));
+
         const size_t states_size = blocks * threads * dimensions;
         CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateSobol32_t)));
 
-        curandDirectionVectors32_t * h_directions;
-        CURAND_CALL(curandGetDirectionVectors32(&h_directions, CURAND_DIRECTION_VECTORS_32_JOEKUO6));
         unsigned int* directions;
         const size_t  size = dimensions * sizeof(unsigned int) * 32;
         CUDA_CALL(cudaMalloc(&directions, size));
@@ -298,7 +315,7 @@ struct runner<curandStateSobol32_t>
             directions,
             static_cast<unsigned int>(offset));
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
 
         CUDA_CALL(cudaFree(directions));
@@ -315,19 +332,20 @@ struct runner<curandStateSobol32_t>
     }
 
     template<typename T, typename GenerateFunc, typename Extra>
-    void generate(const size_t blocks,
-                  const size_t threads,
-                  T * data,
-                  const size_t size,
+    void generate(const size_t        blocks,
+                  const size_t        threads,
+                  cudaStream_t        stream,
+                  T*                  data,
+                  const size_t        size,
                   const GenerateFunc& generate_func,
-                  const Extra extra)
+                  const Extra         extra)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        generate_sobol_kernel<<<dim3(blocks_x, dimensions), threads>>>(states,
-                                                                       data,
-                                                                       size / dimensions,
-                                                                       generate_func,
-                                                                       extra);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), threads, 0, stream>>>(states,
+                                                                                  data,
+                                                                                  size / dimensions,
+                                                                                  generate_func,
+                                                                                  extra);
     }
 };
 
@@ -345,26 +363,26 @@ struct runner<curandStateScrambledSobol32_t>
     {
         this->dimensions = dimensions;
 
-        const size_t states_size = blocks * threads * dimensions;
-        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateScrambledSobol32_t)));
-
         curandDirectionVectors32_t* h_directions;
+        unsigned int*               h_constants;
+
         CURAND_CALL(
             curandGetDirectionVectors32(&h_directions, CURAND_DIRECTION_VECTORS_32_JOEKUO6));
+        CURAND_CALL(curandGetScrambleConstants32(&h_constants));
+
+        const size_t states_size = blocks * threads * dimensions;
+        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateScrambledSobol32_t)));
+
         unsigned int* directions;
-        const size_t  size = dimensions * sizeof(unsigned int) * 32;
-        CUDA_CALL(cudaMalloc(&directions, size));
-        CUDA_CALL(cudaMemcpy(directions, h_directions, size, cudaMemcpyHostToDevice));
+        const size_t  directions_size = dimensions * sizeof(unsigned int) * 32;
+        CUDA_CALL(cudaMalloc(&directions, directions_size));
+        CUDA_CALL(cudaMemcpy(directions, h_directions, directions_size, cudaMemcpyHostToDevice));
 
-        unsigned int* h_scramble_constants;
-        CURAND_CALL(curandGetScrambleConstants32(&h_scramble_constants));
         unsigned int* scramble_constants;
         const size_t  constants_size = dimensions * sizeof(unsigned int);
         CUDA_CALL(cudaMalloc(&scramble_constants, constants_size));
-        CUDA_CALL(cudaMemcpy(scramble_constants,
-                             h_scramble_constants,
-                             constants_size,
-                             cudaMemcpyHostToDevice));
+        CUDA_CALL(
+            cudaMemcpy(scramble_constants, h_constants, constants_size, cudaMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
         init_scrambled_sobol_kernel<<<dim3(blocks_x, dimensions), threads>>>(
@@ -373,7 +391,7 @@ struct runner<curandStateScrambledSobol32_t>
             scramble_constants,
             static_cast<unsigned int>(offset));
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
 
         CUDA_CALL(cudaFree(directions));
@@ -393,17 +411,18 @@ struct runner<curandStateScrambledSobol32_t>
     template<typename T, typename GenerateFunc, typename Extra>
     void generate(const size_t        blocks,
                   const size_t        threads,
+                  cudaStream_t        stream,
                   T*                  data,
                   const size_t        size,
                   const GenerateFunc& generate_func,
                   const Extra         extra)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        generate_sobol_kernel<<<dim3(blocks_x, dimensions), threads>>>(states,
-                                                                       data,
-                                                                       size / dimensions,
-                                                                       generate_func,
-                                                                       extra);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), threads, 0, stream>>>(states,
+                                                                                  data,
+                                                                                  size / dimensions,
+                                                                                  generate_func,
+                                                                                  extra);
     }
 };
 
@@ -421,11 +440,13 @@ struct runner<curandStateSobol64_t>
     {
         this->dimensions = dimensions;
 
+        curandDirectionVectors64_t* h_directions;
+        CURAND_CALL(
+            curandGetDirectionVectors64(&h_directions, CURAND_DIRECTION_VECTORS_64_JOEKUO6));
+
         const size_t states_size = blocks * threads * dimensions;
         CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateSobol64_t)));
 
-        curandDirectionVectors64_t * h_directions;
-        CURAND_CALL(curandGetDirectionVectors64(&h_directions, CURAND_DIRECTION_VECTORS_64_JOEKUO6));
         unsigned long long int* directions;
         const size_t            size = dimensions * sizeof(unsigned long long) * 64;
         CUDA_CALL(cudaMalloc(&directions, size));
@@ -434,7 +455,7 @@ struct runner<curandStateSobol64_t>
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
         init_sobol_kernel<<<dim3(blocks_x, dimensions), threads>>>(states, directions, offset);
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
 
         CUDA_CALL(cudaFree(directions));
@@ -453,6 +474,7 @@ struct runner<curandStateSobol64_t>
     template<typename T, typename GenerateFunc, typename Extra>
     void generate(const size_t        blocks,
                   const size_t        threads,
+                  cudaStream_t        stream,
                   T*                  data,
                   const size_t        size,
                   const GenerateFunc& generate_func,
@@ -481,26 +503,26 @@ struct runner<curandStateScrambledSobol64_t>
     {
         this->dimensions = dimensions;
 
-        const size_t states_size = blocks * threads * dimensions;
-        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateScrambledSobol64_t)));
-
         curandDirectionVectors64_t* h_directions;
+        unsigned long long*         h_constants;
+
         CURAND_CALL(
             curandGetDirectionVectors64(&h_directions, CURAND_DIRECTION_VECTORS_64_JOEKUO6));
+        CURAND_CALL(curandGetScrambleConstants64(&h_constants));
+
+        const size_t states_size = blocks * threads * dimensions;
+        CUDA_CALL(cudaMalloc(&states, states_size * sizeof(curandStateScrambledSobol64_t)));
+
         unsigned long long* directions;
-        const size_t        size = dimensions * sizeof(unsigned long long) * 64;
-        CUDA_CALL(cudaMalloc(&directions, size));
-        CUDA_CALL(cudaMemcpy(directions, h_directions, size, cudaMemcpyHostToDevice));
+        const size_t        directions_size = dimensions * sizeof(unsigned long long) * 64;
+        CUDA_CALL(cudaMalloc(&directions, directions_size));
+        CUDA_CALL(cudaMemcpy(directions, h_directions, directions_size, cudaMemcpyHostToDevice));
 
-        unsigned long long* h_scramble_constants;
-        CURAND_CALL(curandGetScrambleConstants64(&h_scramble_constants));
         unsigned long long* scramble_constants;
         const size_t        constants_size = dimensions * sizeof(unsigned long long);
         CUDA_CALL(cudaMalloc(&scramble_constants, constants_size));
-        CUDA_CALL(cudaMemcpy(scramble_constants,
-                             h_scramble_constants,
-                             constants_size,
-                             cudaMemcpyHostToDevice));
+        CUDA_CALL(
+            cudaMemcpy(scramble_constants, h_constants, constants_size, cudaMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
         init_scrambled_sobol_kernel<<<dim3(blocks_x, dimensions), threads>>>(states,
@@ -508,7 +530,7 @@ struct runner<curandStateScrambledSobol64_t>
                                                                              scramble_constants,
                                                                              offset);
 
-        CUDA_CALL(cudaPeekAtLastError());
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
 
         CUDA_CALL(cudaFree(directions));
@@ -526,12 +548,13 @@ struct runner<curandStateScrambledSobol64_t>
     }
 
     template<typename T, typename GenerateFunc, typename Extra>
-    void generate(const size_t blocks,
-                  const size_t threads,
-                  T * data,
-                  const size_t size,
+    void generate(const size_t        blocks,
+                  const size_t        threads,
+                  cudaStream_t        stream,
+                  T*                  data,
+                  const size_t        size,
                   const GenerateFunc& generate_func,
-                  const Extra extra)
+                  const Extra         extra)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
         generate_sobol_kernel<<<dim3(blocks_x, dimensions), threads>>>(states,
@@ -543,9 +566,13 @@ struct runner<curandStateScrambledSobol64_t>
 };
 
 template<typename T, typename GeneratorState, typename GenerateFunc, typename Extra>
-void run_benchmark(const cli::Parser& parser,
+void run_benchmark(const cli::Parser&  parser,
+                   cudaStream_t        stream,
                    const GenerateFunc& generate_func,
-                   const Extra extra)
+                   const Extra         extra,
+                   const std::string&  distribution,
+                   const std::string&  engine,
+                   const double        lambda = 0.f)
 {
     const size_t size = parser.get<size_t>("size");
     const size_t dimensions = parser.get<size_t>("dimensions");
@@ -554,6 +581,8 @@ void run_benchmark(const cli::Parser& parser,
     const size_t blocks = parser.get<size_t>("blocks");
     const size_t threads = parser.get<size_t>("threads");
 
+    const std::string format = parser.get<std::string>("format");
+
     T * data;
     CUDA_CALL(cudaMalloc(&data, size * sizeof(T)));
 
@@ -562,129 +591,170 @@ void run_benchmark(const cli::Parser& parser,
     // Warm-up
     for (size_t i = 0; i < 5; i++)
     {
-        r.generate(blocks, threads, data, size, generate_func, extra);
-        CUDA_CALL(cudaPeekAtLastError());
+        r.generate(blocks, threads, stream, data, size, generate_func, extra);
+        CUDA_CALL(cudaGetLastError());
         CUDA_CALL(cudaDeviceSynchronize());
     }
     CUDA_CALL(cudaDeviceSynchronize());
 
     // Measurement
-    auto start = std::chrono::high_resolution_clock::now();
+    cudaEvent_t start, stop;
+    CUDA_CALL(cudaEventCreate(&start));
+    CUDA_CALL(cudaEventCreate(&stop));
+    CUDA_CALL(cudaEventRecord(start, stream));
     for (size_t i = 0; i < trials; i++)
     {
-        r.generate(blocks, threads, data, size, generate_func, extra);
+        r.generate(blocks, threads, stream, data, size, generate_func, extra);
+    }
+    CUDA_CALL(cudaEventRecord(stop, stream));
+    CUDA_CALL(cudaEventSynchronize(stop));
+    float elapsed;
+    CUDA_CALL(cudaEventElapsedTime(&elapsed, start, stop));
+    CUDA_CALL(cudaEventDestroy(start));
+    CUDA_CALL(cudaEventDestroy(stop));
+
+    if(format.compare("csv") == 0)
+    {
+        std::cout << std::fixed << std::setprecision(3) << engine << "," << distribution << ","
+                  << (trials * size * sizeof(T)) / (elapsed / 1e3 * (1 << 30)) << ","
+                  << (trials * size) / (elapsed / 1e3 * (1 << 30)) << "," << elapsed / trials << ","
+                  << elapsed << "," << size << ",";
+        if(distribution.compare("poisson") == 0 || distribution.compare("discrete-poisson") == 0)
+        {
+            std::cout << lambda;
+        }
+        std::cout << std::endl;
+    }
+    else
+    {
+        if(format.compare("console") != 0)
+        {
+            std::cout << "Unknown format specified (must be either console or csv).  Defaulting to "
+                         "console output."
+                      << std::endl;
+        }
+        std::cout << std::fixed << std::setprecision(3) << "      "
+                  << "Throughput = " << std::setw(8)
+                  << (trials * size * sizeof(T)) / (elapsed / 1e3 * (1 << 30))
+                  << " GB/s, Samples = " << std::setw(8)
+                  << (trials * size) / (elapsed / 1e3 * (1 << 30))
+                  << " GSample/s, AvgTime (1 trial) = " << std::setw(8) << elapsed / trials
+                  << " ms, Time (all) = " << std::setw(8) << elapsed << " ms, Size = " << size
+                  << std::endl;
     }
-    CUDA_CALL(cudaPeekAtLastError());
-    CUDA_CALL(cudaDeviceSynchronize());
-    auto end = std::chrono::high_resolution_clock::now();
-    std::chrono::duration<double, std::milli> elapsed = end - start;
-
-    std::cout << std::fixed << std::setprecision(3)
-              << "      "
-              << "Throughput = "
-              << std::setw(8) << (trials * size * sizeof(T)) /
-                    (elapsed.count() / 1e3 * (1 << 30))
-              << " GB/s, Samples = "
-              << std::setw(8) << (trials * size) /
-                    (elapsed.count() / 1e3 * (1 << 30))
-              << " GSample/s, AvgTime (1 trial) = "
-              << std::setw(8) << elapsed.count() / trials
-              << " ms, Time (all) = "
-              << std::setw(8) << elapsed.count()
-              << " ms, Size = " << size
-              << std::endl;
 
     CUDA_CALL(cudaFree(data));
 }
 
 template<typename GeneratorState>
 void run_benchmarks(const cli::Parser& parser,
-                    const std::string& distribution)
+                    const std::string& distribution,
+                    const std::string& engine,
+                    cudaStream_t       stream)
 {
+    const std::string format = parser.get<std::string>("format");
     if (distribution == "uniform-uint")
     {
-        if (!std::is_same<GeneratorState, curandStateSobol64_t>::value &&
-            !std::is_same<GeneratorState, curandStateScrambledSobol64_t>::value)
-        {
-            run_benchmark<unsigned int, GeneratorState>(parser,
-                [] __device__ (GeneratorState * state, int) {
-                    return curand(state);
-                }, 0
-            );
-        }
+        run_benchmark<unsigned int, GeneratorState>(
+            parser,
+            stream,
+            [] __device__ ( GeneratorState* state, int) { return curand(state); },
+            0,
+            distribution,
+            engine);
     }
     if (distribution == "uniform-long-long")
     {
         if (std::is_same<GeneratorState, curandStateSobol64_t>::value ||
             std::is_same<GeneratorState, curandStateScrambledSobol64_t>::value)
         {
-            run_benchmark<unsigned long long, GeneratorState>(parser,
-                [] __device__ (GeneratorState * state, int) {
-                    return curand(state);
-                }, 0
-            );
+            run_benchmark<unsigned long long, GeneratorState>(
+                parser,
+                stream,
+                [] __device__ ( GeneratorState* state, int) { return curand(state); },
+                0,
+                distribution,
+                engine);
         }
     }
     if (distribution == "uniform-float")
     {
-        run_benchmark<float, GeneratorState>(parser,
-            [] __device__ (GeneratorState * state, int) {
-                return curand_uniform(state);
-            }, 0
-        );
+        run_benchmark<float, GeneratorState>(
+            parser,
+            stream,
+            [] __device__ ( GeneratorState* state, int) { return curand_uniform(state); },
+            0,
+            distribution,
+            engine);
     }
     if (distribution == "uniform-double")
     {
-        run_benchmark<double, GeneratorState>(parser,
-            [] __device__ (GeneratorState * state, int) {
-                return curand_uniform_double(state);
-            }, 0
-        );
+        run_benchmark<double, GeneratorState>(
+            parser,
+            stream,
+            [] __device__ ( GeneratorState* state, int) { return curand_uniform_double(state); },
+            0,
+            distribution,
+            engine);
     }
     if (distribution == "normal-float")
     {
-        run_benchmark<float, GeneratorState>(parser,
-            [] __device__ (GeneratorState * state, int) {
-                return curand_normal(state);
-            }, 0
-        );
+        run_benchmark<float, GeneratorState>(
+            parser,
+            stream,
+            [] __device__ ( GeneratorState* state, int) { return curand_normal(state); },
+            0,
+            distribution,
+            engine);
     }
     if (distribution == "normal-double")
     {
-        run_benchmark<double, GeneratorState>(parser,
-            [] __device__ (GeneratorState * state, int) {
-                return curand_normal_double(state);
-            }, 0
-        );
+        run_benchmark<double, GeneratorState>(
+            parser,
+            stream,
+            [] __device__ ( GeneratorState* state, int) { return curand_normal_double(state); },
+            0,
+            distribution,
+            engine);
     }
     if (distribution == "log-normal-float")
     {
-        run_benchmark<float, GeneratorState>(parser,
-            [] __device__ (GeneratorState * state, int) {
-                return curand_log_normal(state, 0.0f, 1.0f);
-            }, 0
-        );
+        run_benchmark<float, GeneratorState>(
+            parser,
+            stream,
+            [] __device__ ( GeneratorState* state, int) { return curand_log_normal(state, 0.0f, 1.0f); },
+            0,
+            distribution,
+            engine);
     }
     if (distribution == "log-normal-double")
     {
-        run_benchmark<double, GeneratorState>(parser,
-            [] __device__ (GeneratorState * state, int) {
-                return curand_log_normal_double(state, 0.0, 1.0);
-            }, 0
-        );
+        run_benchmark<double, GeneratorState>(
+            parser,
+            stream,
+            [] __device__ ( GeneratorState* state, int) { return curand_log_normal_double(state, 0.0, 1.0); },
+            0,
+            distribution,
+            engine);
     }
     if (distribution == "poisson")
     {
         const auto lambdas = parser.get<std::vector<double>>("lambda");
         for (double lambda : lambdas)
         {
-            std::cout << "    " << "lambda "
-                 << std::fixed << std::setprecision(1) << lambda << std::endl;
-            run_benchmark<unsigned int, GeneratorState>(parser,
-                [] __device__ (GeneratorState * state, double lambda) {
-                    return curand_poisson(state, lambda);
-                }, lambda
-            );
+            if(format.compare("console") == 0)
+            {
+                std::cout << "    "
+                          << "lambda " << std::fixed << std::setprecision(1) << lambda << std::endl;
+            }
+            run_benchmark<unsigned int, GeneratorState>(
+                parser,
+                stream,
+                [] __device__ ( GeneratorState* state, double lambda) { return curand_poisson(state, lambda); },
+                lambda,
+                distribution,
+                engine,
+                lambda);
         }
     }
     if (distribution == "discrete-poisson")
@@ -692,15 +762,22 @@ void run_benchmarks(const cli::Parser& parser,
         const auto lambdas = parser.get<std::vector<double>>("lambda");
         for (double lambda : lambdas)
         {
-            std::cout << "    " << "lambda "
-                 << std::fixed << std::setprecision(1) << lambda << std::endl;
+            if(format.compare("console") == 0)
+            {
+                std::cout << "    "
+                          << "lambda " << std::fixed << std::setprecision(1) << lambda << std::endl;
+            }
             curandDiscreteDistribution_t discrete_distribution;
             CURAND_CALL(curandCreatePoissonDistribution(lambda, &discrete_distribution));
-            run_benchmark<unsigned int, GeneratorState>(parser,
-                [] __device__ (GeneratorState * state, curandDiscreteDistribution_t discrete_distribution) {
-                    return curand_discrete(state, discrete_distribution);
-                }, discrete_distribution
-            );
+            run_benchmark<unsigned int, GeneratorState>(
+                parser,
+                stream,
+                [] __device__ ( GeneratorState* state, curandDiscreteDistribution_t discrete_distribution)
+                { return curand_discrete(state, discrete_distribution); },
+                discrete_distribution,
+                distribution,
+                engine,
+                lambda);
             CURAND_CALL(curandDestroyDistribution(discrete_distribution));
         }
     }
@@ -758,6 +835,10 @@ int main(int argc, char *argv[])
     parser.set_optional<std::vector<std::string>>("dis", "dis", {"uniform-uint"}, distribution_desc.c_str());
     parser.set_optional<std::vector<std::string>>("engine", "engine", {"philox"}, engine_desc.c_str());
     parser.set_optional<std::vector<double>>("lambda", "lambda", {10.0}, "space-separated list of lambdas of Poisson distribution");
+    parser.set_optional<std::string>("format",
+                                     "format",
+                                     {"console"},
+                                     "output format: console or csv");
     parser.run_and_exit_if_error();
 
     std::vector<std::string> engines;
@@ -803,53 +884,75 @@ int main(int argc, char *argv[])
     cudaDeviceProp props;
     CUDA_CALL(cudaGetDeviceProperties(&props, device_id));
 
+    std::cout << "benchmark_curand_kernel" << std::endl;
     std::cout << "cuRAND: " << version << " ";
     std::cout << "Runtime: " << runtime_version << " ";
     std::cout << "Device: " << props.name;
     std::cout << std::endl << std::endl;
 
+    cudaStream_t stream;
+    CUDA_CALL(cudaStreamCreate(&stream));
+
+    std::string format         = parser.get<std::string>("format");
+    bool        console_output = format.compare("console") == 0 ? true : false;
+
+    if(!console_output)
+    {
+        std::cout
+            << "Engine,Distribution,Throughput,Samples,AvgTime (1 Trial),Time(all),Size,Lambda"
+            << std::endl;
+        std::cout << ",,GB/s,GSample/s,ms),ms),values," << std::endl;
+    }
     for (auto engine : engines)
     {
-        std::cout << engine << ":" << std::endl;
+        if(console_output)
+        {
+            std::cout << engine << ":" << std::endl;
+        }
         for (auto distribution : distributions)
         {
-            std::cout << "  " << distribution << ":" << std::endl;
+            if(console_output)
+            {
+                std::cout << engine << ":" << std::endl;
+            }
             const std::string plot_name = engine + "-" + distribution;
             if (engine == "xorwow")
             {
-                run_benchmarks<curandStateXORWOW_t>(parser, distribution);
+                run_benchmarks<curandStateXORWOW_t>(parser, distribution, engine, stream);
             }
             else if (engine == "mrg32k3a")
             {
-                run_benchmarks<curandStateMRG32k3a_t>(parser, distribution);
+                run_benchmarks<curandStateMRG32k3a_t>(parser, distribution, engine, stream);
             }
             else if (engine == "philox")
             {
-                run_benchmarks<curandStatePhilox4_32_10_t>(parser, distribution);
+                run_benchmarks<curandStatePhilox4_32_10_t>(parser, distribution, engine, stream);
             }
             else if (engine == "sobol32")
             {
-                run_benchmarks<curandStateSobol32_t>(parser, distribution);
+                run_benchmarks<curandStateSobol32_t>(parser, distribution, engine, stream);
             }
             else if(engine == "scrambled_sobol32")
             {
-                run_benchmarks<curandStateScrambledSobol32_t>(parser, distribution);
+                run_benchmarks<curandStateScrambledSobol32_t>(parser, distribution, engine, stream);
             }
             else if (engine == "sobol64")
             {
-                run_benchmarks<curandStateSobol64_t>(parser, distribution);
+                run_benchmarks<curandStateSobol64_t>(parser, distribution, engine, stream);
             }
             else if(engine == "scrambled_sobol64")
             {
-                run_benchmarks<curandStateScrambledSobol64_t>(parser, distribution);
+                run_benchmarks<curandStateScrambledSobol64_t>(parser, distribution, engine, stream);
             }
             else if (engine == "mtgp32")
             {
-                run_benchmarks<curandStateMtgp32_t>(parser, distribution);
+                run_benchmarks<curandStateMtgp32_t>(parser, distribution, engine, stream);
             }
         }
         std::cout << std::endl;
     }
 
+    CUDA_CALL(cudaStreamDestroy(stream));
+
     return 0;
 }
diff --git a/benchmark/benchmark_curand_utils.hpp b/benchmark/benchmark_curand_utils.hpp
index 3a0ff37..8eef353 100644
--- a/benchmark/benchmark_curand_utils.hpp
+++ b/benchmark/benchmark_curand_utils.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2022-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -42,6 +42,19 @@
     }                                                                                         \
     while(0)
 
+#define CUDA_CALL(condition)                                                               \
+    do                                                                                     \
+    {                                                                                      \
+        cudaError_t error_ = condition;                                                    \
+        if(error_ != cudaSuccess)                                                          \
+        {                                                                                  \
+            std::cout << "CUDA error: " << error_ << " at " << __FILE__ << ":" << __LINE__ \
+                      << std::endl;                                                        \
+            exit(error_);                                                                  \
+        }                                                                                  \
+    }                                                                                      \
+    while(0)
+
 inline void add_common_benchmark_curand_info()
 {
     int version;
diff --git a/benchmark/benchmark_rocrand_device_api.cpp b/benchmark/benchmark_rocrand_device_api.cpp
index b38430e..cdf1237 100644
--- a/benchmark/benchmark_rocrand_device_api.cpp
+++ b/benchmark/benchmark_rocrand_device_api.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2022-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2022-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -85,14 +85,7 @@ struct runner
         const size_t states_size = blocks * threads;
         HIP_CHECK(hipMalloc(&states, states_size * sizeof(EngineState)));
 
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_kernel),
-                           dim3(blocks),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           seed,
-                           offset);
+        init_kernel<<<dim3(blocks), dim3(threads)>>>(states, seed, offset);
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -111,15 +104,7 @@ struct runner
                   const size_t     size,
                   const Generator& generator)
     {
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_kernel),
-                           dim3(blocks),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size,
-                           generator);
+        generate_kernel<<<dim3(blocks), dim3(threads), 0, stream>>>(states, data, size, generator);
     }
 };
 
@@ -185,15 +170,10 @@ struct runner<rocrand_state_mtgp32>
                   const size_t     size,
                   const Generator& generator)
     {
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_kernel),
-                           dim3(std::min((size_t)200, blocks)),
-                           dim3(256),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size,
-                           generator);
+        generate_kernel<<<dim3(std::min((size_t)200, blocks)), dim3(256), 0, stream>>>(states,
+                                                                                       data,
+                                                                                       size,
+                                                                                       generator);
     }
 };
 
@@ -341,14 +321,10 @@ struct runner<rocrand_state_sobol32>
         HIP_CHECK(hipMemcpy(directions, h_directions, size, hipMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           directions,
-                           static_cast<unsigned int>(offset));
+        init_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads)>>>(
+            states,
+            directions,
+            static_cast<unsigned int>(offset));
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -370,15 +346,11 @@ struct runner<rocrand_state_sobol32>
                   const Generator& generator)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size / dimensions,
-                           generator);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads), 0, stream>>>(
+            states,
+            data,
+            size / dimensions,
+            generator);
     }
 };
 
@@ -419,15 +391,11 @@ struct runner<rocrand_state_scrambled_sobol32>
             hipMemcpy(scramble_constants, h_constants, constants_size, hipMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_scrambled_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           directions,
-                           scramble_constants,
-                           static_cast<unsigned int>(offset));
+        init_scrambled_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads)>>>(
+            states,
+            directions,
+            scramble_constants,
+            static_cast<unsigned int>(offset));
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -450,15 +418,11 @@ struct runner<rocrand_state_scrambled_sobol32>
                   const Generator& generator)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size / dimensions,
-                           generator);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads), 0, stream>>>(
+            states,
+            data,
+            size / dimensions,
+            generator);
     }
 };
 
@@ -477,7 +441,8 @@ struct runner<rocrand_state_sobol64>
         this->dimensions = dimensions;
 
         const unsigned long long* h_directions;
-        rocrand_get_direction_vectors64(&h_directions, ROCRAND_DIRECTION_VECTORS_64_JOEKUO6);
+        ROCRAND_CHECK(
+            rocrand_get_direction_vectors64(&h_directions, ROCRAND_DIRECTION_VECTORS_64_JOEKUO6));
 
         const size_t states_size = blocks * threads * dimensions;
         HIP_CHECK(hipMalloc(&states, states_size * sizeof(rocrand_state_sobol64)));
@@ -488,14 +453,9 @@ struct runner<rocrand_state_sobol64>
         HIP_CHECK(hipMemcpy(directions, h_directions, size, hipMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           directions,
-                           offset);
+        init_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads)>>>(states,
+                                                                         directions,
+                                                                         offset);
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -517,15 +477,11 @@ struct runner<rocrand_state_sobol64>
                   const Generator& generator)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size / dimensions,
-                           generator);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads), 0, stream>>>(
+            states,
+            data,
+            size / dimensions,
+            generator);
     }
 };
 
@@ -546,9 +502,10 @@ struct runner<rocrand_state_scrambled_sobol64>
         const unsigned long long* h_directions;
         const unsigned long long* h_constants;
 
-        rocrand_get_direction_vectors64(&h_directions,
-                                        ROCRAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6);
-        rocrand_get_scramble_constants64(&h_constants);
+        ROCRAND_CHECK(
+            rocrand_get_direction_vectors64(&h_directions,
+                                            ROCRAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6));
+        ROCRAND_CHECK(rocrand_get_scramble_constants64(&h_constants));
 
         const size_t states_size = blocks * threads * dimensions;
         HIP_CHECK(hipMalloc(&states, states_size * sizeof(rocrand_state_scrambled_sobol64)));
@@ -565,15 +522,11 @@ struct runner<rocrand_state_scrambled_sobol64>
             hipMemcpy(scramble_constants, h_constants, constants_size, hipMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_scrambled_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           directions,
-                           scramble_constants,
-                           offset);
+        init_scrambled_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads)>>>(
+            states,
+            directions,
+            scramble_constants,
+            offset);
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -596,15 +549,11 @@ struct runner<rocrand_state_scrambled_sobol64>
                   const Generator& generator)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size / dimensions,
-                           generator);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads), 0, stream>>>(
+            states,
+            data,
+            size / dimensions,
+            generator);
     }
 };
 
diff --git a/benchmark/benchmark_rocrand_kernel.cpp b/benchmark/benchmark_rocrand_kernel.cpp
index 1e4c389..8e50094 100644
--- a/benchmark/benchmark_rocrand_kernel.cpp
+++ b/benchmark/benchmark_rocrand_kernel.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2023 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -114,11 +114,7 @@ struct runner
         const size_t states_size = blocks * threads;
         HIP_CHECK(hipMalloc(&states, states_size * sizeof(GeneratorState)));
 
-        hipLaunchKernelGGL(
-            HIP_KERNEL_NAME(init_kernel),
-            dim3(blocks), dim3(threads), 0, 0,
-            states, seed, offset
-        );
+        init_kernel<<<dim3(blocks), dim3(threads)>>>(states, seed, offset);
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -143,11 +139,11 @@ struct runner
                   const GenerateFunc& generate_func,
                   const Extra extra)
     {
-        hipLaunchKernelGGL(
-            HIP_KERNEL_NAME(generate_kernel),
-            dim3(blocks), dim3(threads), 0, stream,
-            states, data, size, generate_func, extra
-        );
+        generate_kernel<<<dim3(blocks), dim3(threads), 0, stream>>>(states,
+                                                                    data,
+                                                                    size,
+                                                                    generate_func,
+                                                                    extra);
     }
 };
 
@@ -222,11 +218,12 @@ struct runner<rocrand_state_mtgp32>
                   const GenerateFunc& generate_func,
                   const Extra extra)
     {
-        hipLaunchKernelGGL(
-            HIP_KERNEL_NAME(generate_kernel),
-            dim3(std::min((size_t)200, blocks)), dim3(256), 0, stream,
-            states, data, size, generate_func, extra
-        );
+        generate_kernel<<<dim3(std::min((size_t)200, blocks)), dim3(256), 0, stream>>>(
+            states,
+            data,
+            size,
+            generate_func,
+            extra);
     }
 };
 
@@ -255,16 +252,11 @@ struct runner<rocrand_state_lfsr113>
         const size_t states_size = blocks * threads;
         HIP_CHECK(hipMalloc(&states, states_size * sizeof(rocrand_state_lfsr113)));
 
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_kernel),
-                           dim3(blocks),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           uint4{ROCRAND_LFSR113_DEFAULT_SEED_X,
-                                 ROCRAND_LFSR113_DEFAULT_SEED_Y,
-                                 ROCRAND_LFSR113_DEFAULT_SEED_Z,
-                                 ROCRAND_LFSR113_DEFAULT_SEED_W});
+        init_kernel<<<dim3(blocks), dim3(threads)>>>(states,
+                                                     uint4{ROCRAND_LFSR113_DEFAULT_SEED_X,
+                                                           ROCRAND_LFSR113_DEFAULT_SEED_Y,
+                                                           ROCRAND_LFSR113_DEFAULT_SEED_Z,
+                                                           ROCRAND_LFSR113_DEFAULT_SEED_W});
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -289,16 +281,11 @@ struct runner<rocrand_state_lfsr113>
                   const GenerateFunc& generate_func,
                   const Extra         extra)
     {
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_kernel),
-                           dim3(blocks),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size,
-                           generate_func,
-                           extra);
+        generate_kernel<<<dim3(blocks), dim3(threads), 0, stream>>>(states,
+                                                                    data,
+                                                                    size,
+                                                                    generate_func,
+                                                                    extra);
     }
 };
 
@@ -381,14 +368,10 @@ struct runner<rocrand_state_sobol32>
         HIP_CHECK(hipMemcpy(directions, h_directions, size, hipMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           directions,
-                           static_cast<unsigned int>(offset));
+        init_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads)>>>(
+            states,
+            directions,
+            static_cast<unsigned int>(offset));
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -416,16 +399,12 @@ struct runner<rocrand_state_sobol32>
                   const Extra extra)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size / dimensions,
-                           generate_func,
-                           extra);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads), 0, stream>>>(
+            states,
+            data,
+            size / dimensions,
+            generate_func,
+            extra);
     }
 };
 
@@ -466,15 +445,11 @@ struct runner<rocrand_state_scrambled_sobol32>
             hipMemcpy(scramble_constants, h_constants, constants_size, hipMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_scrambled_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           directions,
-                           scramble_constants,
-                           static_cast<unsigned int>(offset));
+        init_scrambled_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads)>>>(
+            states,
+            directions,
+            scramble_constants,
+            static_cast<unsigned int>(offset));
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -503,16 +478,12 @@ struct runner<rocrand_state_scrambled_sobol32>
                   const Extra         extra)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size / dimensions,
-                           generate_func,
-                           extra);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads), 0, stream>>>(
+            states,
+            data,
+            size / dimensions,
+            generate_func,
+            extra);
     }
 };
 
@@ -542,14 +513,9 @@ struct runner<rocrand_state_sobol64>
         HIP_CHECK(hipMemcpy(directions, h_directions, size, hipMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           directions,
-                           offset);
+        init_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads)>>>(states,
+                                                                         directions,
+                                                                         offset);
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -577,16 +543,12 @@ struct runner<rocrand_state_sobol64>
                   const Extra extra)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size / dimensions,
-                           generate_func,
-                           extra);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads), 0, stream>>>(
+            states,
+            data,
+            size / dimensions,
+            generate_func,
+            extra);
     }
 };
 
@@ -626,15 +588,11 @@ struct runner<rocrand_state_scrambled_sobol64>
             hipMemcpy(scramble_constants, h_constants, constants_size, hipMemcpyHostToDevice));
 
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(init_scrambled_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           0,
-                           states,
-                           directions,
-                           scramble_constants,
-                           offset);
+        init_scrambled_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads)>>>(
+            states,
+            directions,
+            scramble_constants,
+            offset);
 
         HIP_CHECK(hipGetLastError());
         HIP_CHECK(hipDeviceSynchronize());
@@ -663,16 +621,12 @@ struct runner<rocrand_state_scrambled_sobol64>
                   const Extra         extra)
     {
         const size_t blocks_x = next_power2((blocks + dimensions - 1) / dimensions);
-        hipLaunchKernelGGL(HIP_KERNEL_NAME(generate_sobol_kernel),
-                           dim3(blocks_x, dimensions),
-                           dim3(threads),
-                           0,
-                           stream,
-                           states,
-                           data,
-                           size / dimensions,
-                           generate_func,
-                           extra);
+        generate_sobol_kernel<<<dim3(blocks_x, dimensions), dim3(threads), 0, stream>>>(
+            states,
+            data,
+            size / dimensions,
+            generate_func,
+            extra);
     }
 };
 
diff --git a/benchmark/custom_csv_formater.hpp b/benchmark/custom_csv_formater.hpp
index 75d05fa..d31550e 100644
--- a/benchmark/custom_csv_formater.hpp
+++ b/benchmark/custom_csv_formater.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2024 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -155,17 +155,11 @@ inline void customCSVReporter::PrintRunData(const Run& run)
     std::ostream& Err = GetErrorStream();
 
     //get the name of the engine and distribution:
-
     std::string temp = run.benchmark_name();
-
     std::string deviceName = std::string(temp.begin(), temp.begin() + temp.find("<"));
-
     temp.erase(0, temp.find("<") + 1);
-
     std::string engineName = std::string(temp.begin(), temp.begin() + temp.find(","));
-
     temp.erase(0, engineName.size() + 1);
-
     std::string mode = "default";
 
     if(deviceName != "device_kernel")
@@ -174,7 +168,6 @@ inline void customCSVReporter::PrintRunData(const Run& run)
         temp.erase(0, temp.find(",") + 1);
     }
     std::string disName = std::string(temp.begin(), temp.begin() + temp.find(">"));
-
     std::string lambda = "";
 
     size_t ePos = disName.find("=");
@@ -186,11 +179,11 @@ inline void customCSVReporter::PrintRunData(const Run& run)
 
     Out << engineName << "," << disName << "," << mode << ",";
     Out << CsvEscape(run.benchmark_name()) << ",";
-    if(run.error_occurred)
+    if(run.skipped)
     {
         Err << std::string(elements.size() - 3, ',');
         Err << "true,";
-        Err << CsvEscape(run.error_message) << "\n";
+        Err << CsvEscape(run.skip_message) << "\n";
         return;
     }
 
diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake
index 09b7286..329e7b6 100644
--- a/cmake/Dependencies.cmake
+++ b/cmake/Dependencies.cmake
@@ -1,6 +1,6 @@
 # MIT License
 #
-# Copyright (c) 2018-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (c) 2018-2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -20,106 +20,50 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-cmake_minimum_required(VERSION 3.16)
+# Dependencies
 
-# find_package() uses upper-case <PACKAGENAME>_ROOT variables.
-# altough we use GTEST_ROOT for our purposes, it is actually even benefecial for
-# find_package() to look for it there (that's where we are going to put it anyway)
-if(POLICY CMP0144)
-  cmake_policy(SET CMP0144 NEW)
+# Save global state
+# NOTE1: the reason we don't scope global state meddling using add_subdirectory
+#        is because CMake < 3.24 lacks CMAKE_FIND_PACKAGE_TARGETS_GLOBAL which
+#        would promote IMPORTED targets of find_package(CONFIG) to be visible
+#        by other parts of the build. So we save and restore global state.
+#
+# NOTE2: We disable the ROCMChecks.cmake warning noting that we meddle with
+#        global state. This is consequence of abusing the CMake CXX language
+#        which HIP piggybacks on top of. This kind of HIP support has one chance
+#        at observing the global flags, at the find_package(HIP) invocation.
+#        The device compiler won't be able to pick up changes after that, hence
+#        the warning.
+set(USER_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+if(DEFINED BUILD_SHARED_LIBS)
+  set(USER_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
 endif()
-
-# Dependencies
+set(USER_ROCM_WARN_TOOLCHAIN_VAR ${ROCM_WARN_TOOLCHAIN_VAR})
+
+# Change variables before configuring dependencies
+set(ROCM_WARN_TOOLCHAIN_VAR OFF CACHE BOOL "")
+# Turn off warnings and errors for all warnings in dependencies
+separate_arguments(CXX_FLAGS_LIST NATIVE_COMMAND ${CMAKE_CXX_FLAGS})
+list(REMOVE_ITEM CXX_FLAGS_LIST /WX -Werror -Werror=pendantic -pedantic-errors)
+if(MSVC)
+  list(FILTER CXX_FLAGS_LIST EXCLUDE REGEX "/[Ww]([0-4]?)(all)?") # Remove MSVC warning flags
+  list(APPEND CXX_FLAGS_LIST /w)
+else()
+  list(FILTER CXX_FLAGS_LIST EXCLUDE REGEX "-W(all|extra|everything)") # Remove GCC/LLVM flags
+  list(APPEND CXX_FLAGS_LIST -w)
+endif()
+list(JOIN CXX_FLAGS_LIST " " CMAKE_CXX_FLAGS)
+# Don't build client dependencies as shared
+set(BUILD_SHARED_LIBS OFF CACHE BOOL "Global flag to cause add_library() to create shared libraries if on." FORCE)
 
 # HIP dependency is handled earlier in the project cmake file
 # when VerifyCompiler.cmake is included.
 
-# For downloading, building, and installing required dependencies
-include(cmake/DownloadProject.cmake)
-
 # Fortran Wrapper
 if(BUILD_FORTRAN_WRAPPER)
     enable_language(Fortran)
 endif()
 
-# Test dependencies
-if(BUILD_TEST)
-  # NOTE: Google Test has created a mess with legacy FindGTest.cmake and newer GTestConfig.cmake
-  #
-  # FindGTest.cmake defines:   GTest::GTest, GTest::Main, GTEST_FOUND
-  #
-  # GTestConfig.cmake defines: GTest::gtest, GTest::gtest_main, GTest::gmock, GTest::gmock_main
-  #
-  # NOTE2: Finding GTest in MODULE mode, one cannot invoke find_package in CONFIG mode, because targets
-  #        will be duplicately defined.
-  if(NOT DEPENDENCIES_FORCE_DOWNLOAD)
-    # Google Test (https://github.com/google/googletest)
-    find_package(GTest QUIET)
-  endif()
-
-  if(NOT TARGET GTest::GTest AND NOT TARGET GTest::gtest)
-    message(STATUS "GTest not found or force download GTest on. Downloading and building GTest.")
-    set(GTEST_ROOT ${CMAKE_CURRENT_BINARY_DIR}/deps/gtest CACHE PATH "")
-    if(DEFINED CMAKE_CXX_COMPILER)
-      set(CXX_COMPILER_OPTION "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}")
-    endif()
-    download_project(
-      PROJ                googletest
-      GIT_REPOSITORY      https://github.com/google/googletest.git
-      GIT_TAG             release-1.11.0
-      INSTALL_DIR         ${GTEST_ROOT}
-      CMAKE_ARGS          -DBUILD_GTEST=ON -DINSTALL_GTEST=ON -Dgtest_force_shared_crt=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> ${CXX_COMPILER_OPTION} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-      LOG_DOWNLOAD        TRUE
-      LOG_CONFIGURE       TRUE
-      LOG_BUILD           TRUE
-      LOG_INSTALL         TRUE
-      BUILD_PROJECT       TRUE
-      UPDATE_DISCONNECTED TRUE # Never update automatically from the remote repository
-    )
-    find_package(GTest CONFIG REQUIRED PATHS ${GTEST_ROOT} NO_DEFAULT_PATH)
-  endif()
-endif()
-
-
-# Benchmark dependencies
-if(BUILD_BENCHMARK)
-  if(NOT DEPENDENCIES_FORCE_DOWNLOAD)
-    # Google Benchmark (https://github.com/google/benchmark.git)
-    find_package(benchmark QUIET)
-  endif()
-
-  if(NOT benchmark_FOUND)
-    message(STATUS "Google Benchmark not found or force download Google Benchmark on. Downloading and building Google Benchmark.")
-    if(CMAKE_CONFIGURATION_TYPES)
-      message(FATAL_ERROR "DownloadProject.cmake doesn't support multi-configuration generators.")
-    endif()
-    set(GOOGLEBENCHMARK_ROOT ${CMAKE_CURRENT_BINARY_DIR}/deps/googlebenchmark CACHE PATH "")
-    if(NOT (CMAKE_CXX_COMPILER_ID STREQUAL "GNU"))
-    # hip-clang cannot compile googlebenchmark for some reason
-      if(WIN32)
-        set(COMPILER_OVERRIDE "-DCMAKE_CXX_COMPILER=cl")
-      else()
-        set(COMPILER_OVERRIDE "-DCMAKE_CXX_COMPILER=g++")
-      endif()
-    endif()
-
-    download_project(
-      PROJ           googlebenchmark
-      GIT_REPOSITORY https://github.com/google/benchmark.git
-      GIT_TAG        v1.6.1
-      INSTALL_DIR    ${GOOGLEBENCHMARK_ROOT}
-      CMAKE_ARGS     -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=OFF -DBENCHMARK_ENABLE_TESTING=OFF -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> -DCMAKE_CXX_STANDARD=14 ${COMPILER_OVERRIDE}
-      LOG_DOWNLOAD   TRUE
-      LOG_CONFIGURE  TRUE
-      LOG_BUILD      TRUE
-      LOG_INSTALL    TRUE
-      BUILD_PROJECT  TRUE
-      UPDATE_DISCONNECTED TRUE
-    )
-  endif()
-  find_package(benchmark REQUIRED CONFIG PATHS ${GOOGLEBENCHMARK_ROOT} NO_DEFAULT_PATH)
-endif()
-
 set(PROJECT_EXTERN_DIR ${CMAKE_CURRENT_BINARY_DIR}/extern)
 
 # Find or download/install rocm-cmake project
@@ -167,4 +111,65 @@ include(ROCMInstallSymlinks)
 include(ROCMCheckTargetIds)
 include(ROCMUtilities)
 include(ROCMClients)
-include(ROCMHeaderWrapper)
+
+# For downloading and building required dependencies
+include(FetchContent)
+# Test dependencies
+if(BUILD_TEST)
+  # Google Test (https://github.com/google/googletest)
+  # NOTE: Google Test has created a mess with legacy FindGTest.cmake and newer GTestConfig.cmake
+  #
+  # FindGTest.cmake defines:   GTest::GTest, GTest::Main, GTEST_FOUND
+  #
+  # GTestConfig.cmake defines: GTest::gtest, GTest::gtest_main, GTest::gmock, GTest::gmock_main
+  #
+  # NOTE2: Finding GTest in MODULE mode, one cannot invoke find_package in CONFIG mode, because targets
+  #        will be duplicately defined.
+  if(NOT DEPENDENCIES_FORCE_DOWNLOAD)
+    find_package(GTest QUIET)
+  endif()
+
+  if(NOT TARGET GTest::GTest AND NOT TARGET GTest::gtest)
+    message(STATUS "Google Test not found or force download on. Fetching...")
+    option(BUILD_GTEST "Builds the googletest subproject" ON)
+    option(BUILD_GMOCK "Builds the googlemock subproject" OFF)
+    option(INSTALL_GTEST "Enable installation of googletest" ON)
+    FetchContent_Declare(
+      googletest
+      GIT_REPOSITORY https://github.com/google/googletest.git
+      GIT_TAG        v1.15.2
+    )
+    FetchContent_MakeAvailable(googletest)
+  endif()
+endif()
+
+# Benchmark dependencies
+if(BUILD_BENCHMARK)
+  # Google Benchmark (https://github.com/google/benchmark)
+  if(NOT DEPENDENCIES_FORCE_DOWNLOAD)
+    find_package(benchmark 1.9.1 QUIET)
+  endif()
+
+  if(NOT TARGET benchmark::benchmark)
+    message(STATUS "Google Benchmark not found or force download on. Fetching...")
+    option(BENCHMARK_ENABLE_TESTING "Enable testing of the benchmark library" OFF)
+    option(BENCHMARK_ENABLE_INSTALL "Enable installation of benchmark" OFF)
+    FetchContent_Declare(
+      googlebenchmark
+      GIT_REPOSITORY https://github.com/google/benchmark.git
+      GIT_TAG        v1.9.1
+    )
+    set(HAVE_STD_REGEX ON)
+    set(RUN_HAVE_STD_REGEX 1)
+    FetchContent_MakeAvailable(googlebenchmark)
+  endif()
+endif()
+
+# Restore user global state
+set(CMAKE_CXX_FLAGS ${USER_CXX_FLAGS})
+if(DEFINED USER_BUILD_SHARED_LIBS)
+  set(BUILD_SHARED_LIBS ${USER_BUILD_SHARED_LIBS})
+else()
+  unset(BUILD_SHARED_LIBS CACHE )
+endif()
+set(ROCM_WARN_TOOLCHAIN_VAR ${USER_ROCM_WARN_TOOLCHAIN_VAR} CACHE BOOL "")
diff --git a/cmake/DownloadProject.CMakeLists.cmake.in b/cmake/DownloadProject.CMakeLists.cmake.in
deleted file mode 100644
index d6e544f..0000000
--- a/cmake/DownloadProject.CMakeLists.cmake.in
+++ /dev/null
@@ -1,14 +0,0 @@
-# Distributed under the OSI-approved MIT License.  See accompanying
-# file LICENSE or https://github.com/Crascit/DownloadProject for details.
-
-cmake_minimum_required(VERSION 2.8.2)
-
-project(${DL_ARGS_PROJ}-download NONE)
-
-include(ExternalProject)
-ExternalProject_Add(${DL_ARGS_PROJ}-download
-                    ${DL_ARGS_UNPARSED_ARGUMENTS}
-                    SOURCE_DIR          "${DL_ARGS_SOURCE_DIR}"
-                    BUILD_IN_SOURCE     TRUE
-                    TEST_COMMAND        ""
-)
\ No newline at end of file
diff --git a/cmake/DownloadProject.cmake b/cmake/DownloadProject.cmake
deleted file mode 100644
index 110bbd5..0000000
--- a/cmake/DownloadProject.cmake
+++ /dev/null
@@ -1,170 +0,0 @@
-# Distributed under the OSI-approved MIT License.  See accompanying
-# file LICENSE or https://github.com/Crascit/DownloadProject for details.
-#
-# MODULE:   DownloadProject
-#
-# PROVIDES:
-#   download_project( PROJ projectName
-#                    [PREFIX prefixDir]
-#                    [DOWNLOAD_DIR downloadDir]
-#                    [SOURCE_DIR srcDir]
-#                    [BINARY_DIR binDir]
-#                    [QUIET]
-#                    ...
-#   )
-#
-#       Provides the ability to download and unpack a tarball, zip file, git repository,
-#       etc. at configure time (i.e. when the cmake command is run). How the downloaded
-#       and unpacked contents are used is up to the caller, but the motivating case is
-#       to download source code which can then be included directly in the build with
-#       add_subdirectory() after the call to download_project(). Source and build
-#       directories are set up with this in mind.
-#
-#       The PROJ argument is required. The projectName value will be used to construct
-#       the following variables upon exit (obviously replace projectName with its actual
-#       value):
-#
-#           projectName_SOURCE_DIR
-#           projectName_BINARY_DIR
-#
-#       The SOURCE_DIR and BINARY_DIR arguments are optional and would not typically
-#       need to be provided. They can be specified if you want the downloaded source
-#       and build directories to be located in a specific place. The contents of
-#       projectName_SOURCE_DIR and projectName_BINARY_DIR will be populated with the
-#       locations used whether you provide SOURCE_DIR/BINARY_DIR or not.
-#
-#       The DOWNLOAD_DIR argument does not normally need to be set. It controls the
-#       location of the temporary CMake build used to perform the download.
-#
-#       The PREFIX argument can be provided to change the base location of the default
-#       values of DOWNLOAD_DIR, SOURCE_DIR and BINARY_DIR. If all of those three arguments
-#       are provided, then PREFIX will have no effect. The default value for PREFIX is
-#       CMAKE_BINARY_DIR.
-#
-#       The QUIET option can be given if you do not want to show the output associated
-#       with downloading the specified project.
-#
-#       In addition to the above, any other options are passed through unmodified to
-#       ExternalProject_Add() to perform the actual download, patch and update steps.
-#
-#       Only those ExternalProject_Add() arguments which relate to downloading, patching
-#       and updating of the project sources are intended to be used. Also note that at
-#       least one set of download-related arguments are required.
-#
-#       If using CMake 3.2 or later, the UPDATE_DISCONNECTED option can be used to
-#       prevent a check at the remote end for changes every time CMake is run
-#       after the first successful download. See the documentation of the ExternalProject
-#       module for more information. It is likely you will want to use this option if it
-#       is available to you. Note, however, that the ExternalProject implementation contains
-#       bugs which result in incorrect handling of the UPDATE_DISCONNECTED option when
-#       using the URL download method or when specifying a SOURCE_DIR with no download
-#       method. Fixes for these have been created, the last of which is scheduled for
-#       inclusion in CMake 3.8.0. Details can be found here:
-#
-#           https://gitlab.kitware.com/cmake/cmake/commit/bdca68388bd57f8302d3c1d83d691034b7ffa70c
-#           https://gitlab.kitware.com/cmake/cmake/issues/16428
-#
-#       If you experience build errors related to the update step, consider avoiding
-#       the use of UPDATE_DISCONNECTED.
-#
-# EXAMPLE USAGE:
-#
-#   include(DownloadProject)
-#   download_project(PROJ                googletest
-#                    GIT_REPOSITORY      https://github.com/google/googletest.git
-#                    GIT_TAG             master
-#                    UPDATE_DISCONNECTED 1
-#                    QUIET
-#   )
-#
-#   add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
-#
-#========================================================================================
-
-
-set(_DownloadProjectDir "${CMAKE_CURRENT_LIST_DIR}")
-
-include(CMakeParseArguments)
-
-function(download_project)
-
-    set(options QUIET)
-    set(oneValueArgs
-        PROJ
-        PREFIX
-        DOWNLOAD_DIR
-        SOURCE_DIR
-        BINARY_DIR
-    )
-    set(multiValueArgs "")
-
-    cmake_parse_arguments(DL_ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-    # Hide output if requested
-    if (DL_ARGS_QUIET)
-        set(OUTPUT_QUIET "OUTPUT_QUIET")
-    else()
-        unset(OUTPUT_QUIET)
-        message(STATUS "Downloading/updating ${DL_ARGS_PROJ}")
-    endif()
-
-    # Set up where we will put our temporary CMakeLists.txt file and also
-    # the base point below which the default source and binary dirs will be.
-    # The prefix must always be an absolute path.
-    if (NOT DL_ARGS_PREFIX)
-        set(DL_ARGS_PREFIX "${CMAKE_BINARY_DIR}")
-    else()
-        get_filename_component(DL_ARGS_PREFIX "${DL_ARGS_PREFIX}" ABSOLUTE
-                               BASE_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-    endif()
-    if (NOT DL_ARGS_DOWNLOAD_DIR)
-        set(DL_ARGS_DOWNLOAD_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-download")
-    endif()
-
-    # Ensure the caller can know where to find the source and build directories
-    if (NOT DL_ARGS_SOURCE_DIR)
-        set(DL_ARGS_SOURCE_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-src")
-    endif()
-    if (NOT DL_ARGS_BINARY_DIR)
-        set(DL_ARGS_BINARY_DIR "${DL_ARGS_PREFIX}/${DL_ARGS_PROJ}-build")
-    endif()
-    set(${DL_ARGS_PROJ}_SOURCE_DIR "${DL_ARGS_SOURCE_DIR}" PARENT_SCOPE)
-    set(${DL_ARGS_PROJ}_BINARY_DIR "${DL_ARGS_BINARY_DIR}" PARENT_SCOPE)
-
-    # The way that CLion manages multiple configurations, it causes a copy of
-    # the CMakeCache.txt to be copied across due to it not expecting there to
-    # be a project within a project.  This causes the hard-coded paths in the
-    # cache to be copied and builds to fail.  To mitigate this, we simply
-    # remove the cache if it exists before we configure the new project.  It
-    # is safe to do so because it will be re-generated.  Since this is only
-    # executed at the configure step, it should not cause additional builds or
-    # downloads.
-    file(REMOVE "${DL_ARGS_DOWNLOAD_DIR}/CMakeCache.txt")
-
-    # Create and build a separate CMake project to carry out the download.
-    # If we've already previously done these steps, they will not cause
-    # anything to be updated, so extra rebuilds of the project won't occur.
-    # Make sure to pass through CMAKE_MAKE_PROGRAM in case the main project
-    # has this set to something not findable on the PATH.
-    configure_file("${_DownloadProjectDir}/DownloadProject.CMakeLists.cmake.in"
-                   "${DL_ARGS_DOWNLOAD_DIR}/CMakeLists.txt")
-    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}"
-                        -D "CMAKE_MAKE_PROGRAM:FILE=${CMAKE_MAKE_PROGRAM}"
-                        .
-                    RESULT_VARIABLE result
-                    ${OUTPUT_QUIET}
-                    WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}"
-    )
-    if(result)
-        message(FATAL_ERROR "CMake step for ${DL_ARGS_PROJ} failed: ${result}")
-    endif()
-    execute_process(COMMAND ${CMAKE_COMMAND} --build .
-                    RESULT_VARIABLE result
-                    ${OUTPUT_QUIET}
-                    WORKING_DIRECTORY "${DL_ARGS_DOWNLOAD_DIR}"
-    )
-    if(result)
-        message(FATAL_ERROR "Build step for ${DL_ARGS_PROJ} failed: ${result}")
-    endif()
-
-endfunction()
\ No newline at end of file
diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake
index c243e87..fe0d238 100644
--- a/cmake/Summary.cmake
+++ b/cmake/Summary.cmake
@@ -1,4 +1,41 @@
-function (print_configuration_summary)
+function(print_configuration_summary)
+    find_package(Git)
+    if(GIT_FOUND)
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} show --format=%H --no-patch
+            WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+            OUTPUT_VARIABLE COMMIT_HASH
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} show --format=%s --no-patch
+            WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+            OUTPUT_VARIABLE COMMIT_SUBJECT
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+    endif()
+
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} --version
+        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+        OUTPUT_VARIABLE CMAKE_CXX_COMPILER_VERBOSE_DETAILS
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    find_program(UNAME_EXECUTABLE uname)
+    if(UNAME_EXECUTABLE)
+        execute_process(
+            COMMAND ${UNAME_EXECUTABLE} -a
+            WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+            OUTPUT_VARIABLE LINUX_KERNEL_DETAILS
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+    endif()  
+
+    string(REPLACE "\n" ";" CMAKE_CXX_COMPILER_VERBOSE_DETAILS "${CMAKE_CXX_COMPILER_VERBOSE_DETAILS}")
+    list(TRANSFORM CMAKE_CXX_COMPILER_VERBOSE_DETAILS PREPEND "--     ")
+    string(REPLACE ";" "\n" CMAKE_CXX_COMPILER_VERBOSE_DETAILS "${CMAKE_CXX_COMPILER_VERBOSE_DETAILS}")
+
     message(STATUS "")
     message(STATUS "******** Summary ********")
     message(STATUS "General:")
@@ -35,4 +72,15 @@ function (print_configuration_summary)
     endif()
     message(STATUS "  BUILD_ADDRESS_SANITIZER    : ${BUILD_ADDRESS_SANITIZER}")
     message(STATUS "  DEPENDENCIES_FORCE_DOWNLOAD: ${DEPENDENCIES_FORCE_DOWNLOAD}")
+    message(STATUS "")
+    message(STATUS "Detailed:")
+    message(STATUS "  C++ compiler details       : \n${CMAKE_CXX_COMPILER_VERBOSE_DETAILS}")
+if(GIT_FOUND)
+    message(STATUS "  Commit                     : ${COMMIT_HASH}")
+    message(STATUS "                               ${COMMIT_SUBJECT}")
+endif()
+if(UNAME_EXECUTABLE)
+    message(STATUS "  Unix name                  : ${LINUX_KERNEL_DETAILS}")
+endif()
+  
 endfunction()
diff --git a/debian/changelog b/debian/changelog
index d80e590..8bc43b8 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,30 @@
+rocrand (7.1.0-0ubuntu1) resolute; urgency=medium
+
+  [Talha Can Havadar]
+  * d/control: update rocm dependency version to >= 7.1.0
+
+  [Tim Flink]
+  * new upstream 7.1.0 release
+    - Better test coverage
+    - Bugfixes
+    - Deprecated the rocRAND Fortran API in favor of hipfort
+    - Removed C++14 support. Beginning with this release, only C++17
+      is supported
+  * rebased patches
+  * removed ppc64el builds
+  * build docs with the rocm-docs-build script from rocm-docs-core
+  * new patches:
+    - 0005-dont-set-rocm-path-in-cmake.patch
+    - 0006-fix-doxygen-settings.patch
+
+  [ Igor Luppi ]
+  * d/control: update build-depends
+  * d/control: update maintainer field
+  * d/rules: fix FTBFS by adding -Wl,--gc-sections to flags
+  * d/rules: use GPU_TARGETS instead of deprecated AMDGPU_TARGETS
+
+ -- Talha Can Havadar <[e-mail]>  Thu, 05 Feb 2026 11:00:51 +0300
+
 rocrand (6.4.3-1) unstable; urgency=medium
 
   * Upload to unstable
diff --git a/debian/control b/debian/control
index 23379c0..52499ee 100644
--- a/debian/control
+++ b/debian/control
@@ -5,19 +5,25 @@ Priority: optional
 Standards-Version: 4.7.2
 Vcs-Git: https://salsa.debian.org/rocm-team/rocrand.git
 Vcs-Browser: https://salsa.debian.org/rocm-team/rocrand
-Maintainer: Debian ROCm Team <[e-mail]>
-Uploaders: Étienne Mollier <[e-mail]>,
-           Cordell Bloor <[e-mail]>,
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Debian ROCm Team <[e-mail]>
+Uploaders: Maxime Chambonnet <[e-mail]>,
+           Étienne Mollier <[e-mail]>,
+           Cordell Bloor <[e-mail]>,
            Christian Kastner <[e-mail]>,
 Build-Depends: debhelper-compat (= 13),
                cmake,
-               hipcc (>= 7.0~),
-               libamd-comgr-dev (>= 6.4~),
-               libamdhip64-dev (>= 6.4~),
-               libhsa-runtime-dev (>= 6.4~),
-               rocm-cmake,
+               hipcc (>= 7.1.0~),
+               libamd-comgr-dev (>= 7.1.0~),
+               libhsa-runtime-dev (>= 7.1.0~),
+               rocm-cmake (>= 7.1.0~),
                libgtest-dev <!nocheck>,
-               pkg-rocm-tools (>= 0.9.0~exp3),
+               pkg-rocm-tools (>= 0.9.5),
+               libstdc++-dev,
+               lld-21,
+               clang-tools-21,
+               llvm-21,
+               rocm-device-libs-21,
 Build-Depends-Indep: dh-sequence-sphinxdoc <!nodoc>,
                python3-doxysphinx <!nodoc>,
                python3-rocm-docs (>= 1.20.0-1~) <!nodoc>,
@@ -30,7 +36,7 @@ Rules-Requires-Root: no
 
 Package: librocrand1
 Section: libs
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 XB-X-ROCm-GPU-Architecture: ${rocm:GPU-Architecture}
 Depends: ${misc:Depends}, ${shlibs:Depends},
 Description: generate pseudo- and quasi-random numbers - library
@@ -45,7 +51,7 @@ Description: generate pseudo- and quasi-random numbers - library
 
 Package: librocrand-dev
 Section: libdevel
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Depends: librocrand1 (= ${binary:Version}),
          libamdhip64-dev,
          ${misc:Depends},
@@ -63,7 +69,7 @@ Description: generate pseudo- and quasi-random numbers - headers
 
 Package: librocrand1-tests
 Section: libdevel
-Architecture: amd64 arm64 ppc64el
+Architecture: amd64 arm64
 Build-Profiles: <!nocheck>
 Depends: librocrand1 (= ${binary:Version}),${misc:Depends}, ${shlibs:Depends},
 Description: generate pseudo- and quasi-random numbers - test binaries
diff --git a/debian/librocrand-doc.doc-base b/debian/librocrand-doc.doc-base
index 600e35d..77970d0 100644
--- a/debian/librocrand-doc.doc-base
+++ b/debian/librocrand-doc.doc-base
@@ -5,7 +5,7 @@ Abstract: Documentation describing the design and use of the rocRAND library.
 Section: Programming
 
 Format: HTML
-Index: /usr/share/doc/librocrand-dev/rocrand-html/index.html
-Files: /usr/share/doc/librocrand-dev/rocrand-html/*.html
+Index: /usr/share/doc/librocrand-dev/html/index.html
+Files: /usr/share/doc/librocrand-dev/html/*.html
 
 
diff --git a/debian/librocrand-doc.docs b/debian/librocrand-doc.docs
index f280757..6d28621 100644
--- a/debian/librocrand-doc.docs
+++ b/debian/librocrand-doc.docs
@@ -1 +1 @@
-rocrand-html/
+build/html
diff --git a/debian/librocrand-doc.links b/debian/librocrand-doc.links
index 7c25cb4..a20ad3b 100644
--- a/debian/librocrand-doc.links
+++ b/debian/librocrand-doc.links
@@ -1 +1 @@
-usr/share/javascript/jquery/jquery.js usr/share/doc/librocrand-dev/rocrand-html/doxygen/html/jquery.js
+usr/share/javascript/jquery/jquery.js usr/share/doc/librocrand-dev/html/doxygen/html/jquery.js
diff --git a/debian/not-installed b/debian/not-installed
index 70399f3..930f73c 100644
--- a/debian/not-installed
+++ b/debian/not-installed
@@ -1,2 +1,2 @@
-usr/share/doc/rocrand/LICENSE.txt
+usr/share/doc/rocrand/LICENSE.md
 usr/bin/rocRAND/CTestTestfile.cmake
diff --git a/debian/patches/0005-dont-set-rocm-path-in-cmake.patch b/debian/patches/0005-dont-set-rocm-path-in-cmake.patch
new file mode 100644
index 0000000..76ae6ba
--- /dev/null
+++ b/debian/patches/0005-dont-set-rocm-path-in-cmake.patch
@@ -0,0 +1,60 @@
+From: Tim Flink <[e-mail]>
+Date: Wed, 21 Jan 2026 08:27:17 -0600
+Subject: remove setting ROCM_PATH env var
+
+Setting the ROCM_PATH environment variable interferes with the system
+LLVM based compiler's ability to find device libs which are required
+for the compilation process.
+
+This patch removes all setting of the ROCM_PATH environment variable
+and any logic which uses that environment variable.
+
+As this isn't relevant to how the upstream project is normally built
+and as such, does not need to be forwarded upstream.
+
+Forwarded: not-needed
+---
+Index: bullwinkle-rocrand/CMakeLists.txt
+===================================================================
+--- bullwinkle-rocrand.orig/CMakeLists.txt
++++ bullwinkle-rocrand/CMakeLists.txt
+@@ -37,13 +37,14 @@ option(DEPENDENCIES_FORCE_DOWNLOAD "Don'
+ cmake_dependent_option(RUN_SLOW_TESTS "Run extra tests with CTest. These cover niche functionality and take long time" OFF "BUILD_TEST" OFF)
+ 
+ 
+-if (NOT DEFINED ENV{ROCM_PATH})
+-#Path to ROCm installation
+-  set(ENV{ROCM_PATH} "/opt/rocm")
+-endif()
+-  
+-# Install prefix
+-set(CMAKE_INSTALL_PREFIX "$ENV{ROCM_PATH}" CACHE PATH "Install path prefix, prepended onto install directories")
++# setting ROCM_PATH causes problems with hipcc finding device libs
++#if (NOT DEFINED ENV{ROCM_PATH})
++##Path to ROCm installation
++#  set(ENV{ROCM_PATH} "/opt/rocm")
++#endif()
++#  
++## Install prefix
++#set(CMAKE_INSTALL_PREFIX "$ENV{ROCM_PATH}" CACHE PATH "Install path prefix, prepended onto install directories")
+ 
+ if(WIN32)
+     set(CPACK_SOURCE_GENERATOR "ZIP")
+@@ -55,11 +56,12 @@ if(WIN32)
+     set(CPACK_PACKAGING_INSTALL_PREFIX "")
+     set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
+ else()
+-    set(CMAKE_INSTALL_PREFIX "$ENV{ROCM_PATH}" CACHE PATH "Install path prefix, prepended onto install directories")
+-    #Adding CMAKE_PREFIX_PATH
+-    if(NOT DEFINED CMAKE_PREFIX_PATH)
+-      list( APPEND CMAKE_PREFIX_PATH $ENV{ROCM_PATH}/llvm $ENV{ROCM_PATH})
+-    endif()
++    # setting ROCM_PATH causes problems with hipcc finding device libs
++    #    set(CMAKE_INSTALL_PREFIX "$ENV{ROCM_PATH}" CACHE PATH "Install path prefix, prepended onto install directories")
++    #    #Adding CMAKE_PREFIX_PATH
++    #    if(NOT DEFINED CMAKE_PREFIX_PATH)
++    #      list( APPEND CMAKE_PREFIX_PATH $ENV{ROCM_PATH}/llvm $ENV{ROCM_PATH})
++    #    endif()
+     if(NOT CPACK_PACKAGING_INSTALL_PREFIX)
+         set(CPACK_PACKAGING_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+     endif()
diff --git a/debian/patches/0006-fix-doxygen-settings.patch b/debian/patches/0006-fix-doxygen-settings.patch
new file mode 100644
index 0000000..9db17eb
--- /dev/null
+++ b/debian/patches/0006-fix-doxygen-settings.patch
@@ -0,0 +1,31 @@
+From: Tim Flink <[e-mail]>
+Date: Wed, 21 Jan 2026 11:08:37 -0600
+Subject: fix invalid doxygen settings
+
+Doxygen will fail with the upstream settings. This patch makes minimal
+changes to the Doxygen settings such that the docs will build.
+
+Forwarded: https://github.com/ROCm/rocm-libraries/pull/3994
+---
+Index: bullwinkle-rocrand/docs/doxygen/Doxyfile
+===================================================================
+--- bullwinkle-rocrand.orig/docs/doxygen/Doxyfile
++++ bullwinkle-rocrand/docs/doxygen/Doxyfile
+@@ -1674,7 +1674,7 @@ DISABLE_INDEX          = NO
+ # The default value is: NO.
+ # This tag requires that the tag GENERATE_HTML is set to YES.
+ 
+-GENERATE_TREEVIEW      = NONE
++GENERATE_TREEVIEW      = NO
+ 
+ # When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the
+ # FULL_SIDEBAR option determines if the side bar is limited to only the treeview
+@@ -1971,7 +1971,7 @@ COMPACT_LATEX          = NO
+ # The default value is: a4.
+ # This tag requires that the tag GENERATE_LATEX is set to YES.
+ 
+-PAPER_TYPE             = a4wide
++PAPER_TYPE             = a4
+ 
+ # The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+ # that should be included in the LaTeX output. The package can be specified just
diff --git a/debian/patches/Hide-internal-symbols.patch b/debian/patches/Hide-internal-symbols.patch
index 8149956..15fab61 100644
--- a/debian/patches/Hide-internal-symbols.patch
+++ b/debian/patches/Hide-internal-symbols.patch
@@ -7,22 +7,22 @@ Subject: Hide internal symbols
  library/src/rng/system.hpp | 1 +
  2 files changed, 2 insertions(+)
 
-diff --git a/library/src/rng/sobol.hpp b/library/src/rng/sobol.hpp
-index 65aff0b..5611188 100644
---- a/library/src/rng/sobol.hpp
-+++ b/library/src/rng/sobol.hpp
-@@ -110,6 +110,7 @@ template<unsigned int OutputPerThread,
+Index: rocrand/library/src/rng/sobol.hpp
+===================================================================
+--- rocrand.orig/library/src/rng/sobol.hpp
++++ rocrand/library/src/rng/sobol.hpp
+@@ -111,6 +111,7 @@ template<unsigned int OutputPerThread,
           class T,
           class Distribution,
           int block_size>
 +__attribute__((visibility("hidden")))
- __global__ __launch_bounds__(block_size) void generate_sobol_kernel(
+ __global__ __launch_bounds__(block_size)
+ void generate_sobol_kernel(
      T*, const size_t, const Constant*, const Constant*, const unsigned int, Distribution)
- {}
-diff --git a/library/src/rng/system.hpp b/library/src/rng/system.hpp
-index fee2704..6d6550c 100644
---- a/library/src/rng/system.hpp
-+++ b/library/src/rng/system.hpp
+Index: rocrand/library/src/rng/system.hpp
+===================================================================
+--- rocrand.orig/library/src/rng/system.hpp
++++ rocrand/library/src/rng/system.hpp
 @@ -257,6 +257,7 @@ namespace detail
  {
  
diff --git a/debian/patches/series b/debian/patches/series
index e104293..649b46f 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,3 +1,5 @@
 Extend-docs-conf.py-for-offline-build.patch
 Hide-internal-symbols.patch
 Use-local-mathjax.patch
+0005-dont-set-rocm-path-in-cmake.patch
+0006-fix-doxygen-settings.patch
diff --git a/debian/rules b/debian/rules
index 2c5bd98..0071864 100755
--- a/debian/rules
+++ b/debian/rules
@@ -2,6 +2,12 @@
 export CXX=hipcc
 export DEB_BUILD_MAINT_OPTIONS = hardening=+all optimize=-lto
 export DEB_CXXFLAGS_MAINT_PREPEND = -gz
+# -Wl,--gc-sections:
+# Fixes linker errors ("relocation refers to a discarded section") when using gtest.
+# The linker's section garbage collection incorrectly discards needed code due to
+# a toolchain mismatch (ROCm's clang vs. the system's GCC). This flag forces the
+# linker to correctly re-evaluate dependencies, keeping the required sections.
+export DEB_LDFLAGS_MAINT_PREPEND = -Wl,--gc-sections
 export VERBOSE=1
 #export AMD_LOG_LEVEL=4
 
@@ -15,6 +21,8 @@ CMAKE_FLAGS = \
 	-DROCM_SYMLINK_LIBS=OFF \
 	-DGPU_TARGETS="$(shell rocm-target-arch --sep ';')" \
 	-DBUILD_FILE_REORG_BACKWARD_COMPATIBILITY=OFF \
+	-DCMAKE_VERBOSE_MAKEFILE=ON \
+	-DCMAKE_PREFIX_PATH=/usr/lib/llvm-21/lib \
 	-DENABLE_INLINE_ASM=1
 ifeq (,$(filter nocheck,$(DEB_BUILD_PROFILES)))
 CMAKE_FLAGS += -DBUILD_TEST=ON
@@ -47,10 +55,9 @@ override_dh_auto_build-indep:
 ifeq (,$(filter nodoc,$(DEB_BUILD_OPTIONS)))
 	http_proxy='127.0.0.1:9' \
 	https_proxy='127.0.0.1:9' \
-	ROCM_DOCS_REMOTE_DETAILS=http://localhost,local \
-	latest_version= \
-	release_candidate= \
-	sphinx-build -v -b html docs rocrand-html
+	rocm-docs-build -r $(shell dpkg-parsechangelog -S Version | sed 's/[+-].*//')
+	rm -rf build/html/_static/fonts
+	rm -rf build/html/_static/vendor
 endif
 
 override_dh_auto_test-indep:
diff --git a/docs/api-reference/cpp-api.rst b/docs/api-reference/cpp-api.rst
index 6db52ae..2460d72 100644
--- a/docs/api-reference/cpp-api.rst
+++ b/docs/api-reference/cpp-api.rst
@@ -1,6 +1,6 @@
 .. meta::
-  :description: rocRAND documentation and API reference library
-  :keywords: rocRAND, ROCm, API, documentation
+  :description: rocRAND C/C++ API reference
+  :keywords: rocRAND, ROCm, API, documentation, C, C++
 
 .. _cpp-api:
 
@@ -11,14 +11,15 @@ C/C++ API reference
 This chapter describes the rocRAND C and C++ API.
 
 API index
-===========
+=========
 
-To search an API, refer to the API :ref:`genindex`.
+To search the API, refer to the API :ref:`genindex`.
 
 Device functions
 ================
 
-To use the device API, include the file ``rocrand_kernel.h`` in files that define kernels that use rocRAND device functions. The typical usage of device functions consists of the following operations in the device kernel definition:
+To use the device API, include the file ``rocrand_kernel.h`` in files that define kernels that use rocRAND device functions. 
+Follow these steps to use the device functions in the device kernel definition:
 
 1. Create a new generator state object of the desired generator type.
 
@@ -28,9 +29,10 @@ To use the device API, include the file ``rocrand_kernel.h`` in files that defin
 
 4. Use the results.
 
-Since the rocRAND device functions are invoked from inside the user kernel, the generated numbers can be used right away in the kernel without the need to copy them to the host memory.
+The rocRAND device functions are invoked from inside the user kernel.
+This means the generated numbers can be used immediately in the kernel without copying them to the host memory.
 
-In the below example, random number generation is using the XORWOW generator.
+In the following example, random number generation uses the XORWOW generator.
 
 ..  code-block:: cpp
 
@@ -62,7 +64,9 @@ In the below example, random number generation is using the XORWOW generator.
 C host API
 ==========
 
-The C host API allows encapsulation of the internal generator state. Random numbers may be produced either on the host or device, depending on the created generator object. The typical sequence of operations for device generation consists of the following steps:
+The C host API allows encapsulation of the internal generator state.
+Random numbers can be produced either on the host or device, depending on the created generator object.
+The typical sequence of operations for device generation consists of the following steps:
 
 1. Allocate memory on the device with ``hipMalloc``.
 
@@ -76,9 +80,12 @@ The C host API allows encapsulation of the internal generator state. Random numb
 
 6. Clean up with ``rocrand_destroy_generator`` and ``hipFree``.
 
-To generate random numbers on the host, the memory allocation in step one should be made using a host memory allocation call. In step two ``rocrand_create_generator_host`` should be called instead. In the last step, the appropriate memory release should be made using the ``rocrand_destroy_generator``. All other calls work identically whether you are generating random numbers on the device or on the host CPU. 
+To generate random numbers on the host, allocate the memory in the first step
+using a host memory allocation call. In step two, call ``rocrand_create_generator_host`` instead.
+In the last step, release the appropriate memory using ``rocrand_destroy_generator``.
+All other calls work identically whether you are generating random numbers on the device or on the host CPU. 
 
-In the example below, the C host API is used to generate 10 random floats using GPU capabilities.
+The example below uses the C host API to generate ten random floats using GPU capabilities.
 
 ..  code-block:: c
 
@@ -118,9 +125,10 @@ In the example below, the C host API is used to generate 10 random floats using 
 C++ host API wrapper
 ====================
 
-The C++ host API wrapper provides resource management and an object-oriented interface for random number generation facilities.
+The C++ host API wrapper provides resource management and an object-oriented interface for random number
+generation facilities.
 
-In the example below C++ host API wrapper is used to produce a random number using the default generation parameters.
+The example below uses the C++ host API wrapper to produce a random number using the default generation parameters.
 
 ..  code-block:: cpp
 
diff --git a/docs/api-reference/data-type-support.rst b/docs/api-reference/data-type-support.rst
index faba618..20ae4fe 100644
--- a/docs/api-reference/data-type-support.rst
+++ b/docs/api-reference/data-type-support.rst
@@ -1,18 +1,24 @@
 .. meta::
-   :description: rocRAND documentation and API reference library
-   :keywords: rocRAND, ROCm, API, documentation, cuRAND
+   :description: Data type support for rocRAND documentation
+   :keywords: rocRAND, ROCm, API, documentation, cuRAND, data types
 
 .. _data-type-support:
 
 rocRAND data type support
 ******************************************
 
+This topic discusses the various data types supported by rocRAND and provides a comparison
+with the data type support in NVIDIA CUDA cuRAND.
+
 Host API
 ========
 
+This section covers the data types supported for the host API.
+
 Generator types
 ---------------
- .. list-table:: Supported generators on the host
+
+.. list-table:: Supported generators on the host
     :header-rows: 1
     :name: host-supported-generators
 
@@ -81,22 +87,24 @@ Generator types
       - ✅
       - ✅
 
-Only Sobol64, Scrambled Sobol64, ThreeFry 2x64-20 and ThreeFry 4x64-20 support generation of 64 bit :code:`unsigned long long int` integers, the other generators generate 32 bit :code:`unsigned int` integers.
+Only Sobol64, Scrambled Sobol64, ThreeFry 2x64-20, and ThreeFry 4x64-20 support the generation of 64-bit :code:`unsigned long long int` integers.
+The other generators generate 32-bit :code:`unsigned int` integers.
 
 Seed types
 ----------
 
-All generators can be seeded with :code:`unsigned long long`, however LFSR113 can additionally be seeded using an :code:`uint4`.
+All generators can be seeded with :code:`unsigned long long`. However, LFSR113 can also be seeded using a :code:`uint4`.
 
 Output types
 ------------
 
-The generators produce pseudo-random numbers chosen from a given distribution. The following distributions and corresponding output types are supported for the host API:
+The generators produce pseudo-random numbers chosen from a given distribution.
+The following distributions and corresponding output types are supported for the host API:
 
 Uniform distribution
-""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^
 
- .. list-table:: Supported types for uniform distributions on the host
+.. list-table:: Supported types for uniform distributions on the host
     :header-rows: 1
     :name: host-types-uniform-distribution
 
@@ -122,7 +130,7 @@ Uniform distribution
       - ✅
     *
       - :code:`unsigned long long`
-      - 64 bit [#]_
+      - 64 bit (see note)
       - ✅
       - ✅
     *
@@ -141,14 +149,19 @@ Uniform distribution
       - ✅
       - ✅
 
-Uniform distributions of integral types return a number between 0 and 2^(size in bits) - 1, whereas floating-point types return a number between 0.0 and 1.0, excluding 1.0.
+Uniform distributions of integral types return a number between 0 and 2^(size in bits) - 1,
+whereas floating-point types return a number between 0.0 and 1.0, excluding 1.0.
+
+.. note::
+
+   The generation of 64-bit :code:`unsigned long long` integers is only supported by 64-bit generators
+   (Scrambled Sobol 64, Sobol64, Threefry 2x64-20, and Threefry 4x64-20).
 
 Poisson distribution
-"""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^
 
- .. list-table:: Supported types for the poisson distribution on the host
+.. list-table:: Supported types for the Poisson distribution on the host
     :header-rows: 1
-    :name: host-types-poisson-distribution
 
     *
       - Type
@@ -162,9 +175,9 @@ Poisson distribution
       - ✅
 
 Normal distribution
-"""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^
 
- .. list-table:: Supported types for normal distributions on the host
+.. list-table:: Supported types for normal distributions on the host
     :header-rows: 1
     :name: host-types-normal-distribution
 
@@ -190,9 +203,9 @@ Normal distribution
       - ✅
 
 Log-normal distributions
-""""""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^^^
 
- .. list-table:: Supported types for log-normal distributions on the host
+.. list-table:: Supported types for log-normal distributions on the host
     :header-rows: 1
     :name: host-types-log-normal-distribution
 
@@ -220,9 +233,13 @@ Log-normal distributions
 Device API
 ==========
 
+This section covers the supported data types for the device API.
+
+
 Generator types
 ---------------
- .. list-table:: Supported generators on the device
+
+.. list-table:: Supported generators on the device
     :header-rows: 1
     :name: device-supported-generators
 
@@ -294,40 +311,42 @@ Generator types
 Seed types
 ----------
 
-All generators can be seeded with :code:`unsigned long long`, however LFSR113 can additionally be seeded using an :code:`uint4`.
+All generators can be seeded with :code:`unsigned long long`, however LFSR113 can also be seeded using an :code:`uint4`.
 
 Output types
 ------------
 
-The generators produce pseudo-random numbers chosen from a given distribution. The following distributions and corresponding output types are supported for the device API, however not all generators support all types:
+The generators produce pseudo-random numbers chosen from a given distribution.
+The following distributions and corresponding output types are supported for the device API.
+However, not all generators support all types.
 
 
 Uniform distribution
-""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^
 
- .. list-table:: Supported types for uniform distributions on the device
+.. list-table:: Supported types for uniform distributions on the device
     :header-rows: 1
     :name: device-types-uniform-distribution
 
     *
       - Type
       - rocRAND support
-      - supported rocRAND generators
+      - Supported rocRAND generators
       - cuRAND support
     *
       - :code:`unsigned int`
       - ✅
-      - all native 32-bit generators
+      - All native 32-bit generators
       - ✅
     *
       - :code:`unsigned long long int`
       - ✅
-      - all native 64-bit generators
+      - All native 64-bit generators
       - ✅
     *
       - :code:`float`
       - ✅
-      - all generators
+      - All generators
       - ✅
     *
       - :code:`float2`
@@ -342,7 +361,7 @@ Uniform distribution
     *
       - :code:`double`
       - ✅
-      - all generators
+      - All generators
       - ✅
     *
       - :code:`double2`
@@ -357,21 +376,21 @@ Uniform distribution
 
 
 Normal distribution
-""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^
 
- .. list-table:: Supported types for normal distributions on the device
+.. list-table:: Supported types for normal distributions on the device
     :header-rows: 1
     :name: device-types-normal-distribution
 
     *
       - Type
       - rocRAND support
-      - supported rocRAND generators
+      - Supported rocRAND generators
       - cuRAND support
     *
       - :code:`float`
       - ✅
-      - all generators
+      - All generators
       - ✅
     *
       - :code:`float2`
@@ -386,7 +405,7 @@ Normal distribution
     *
       - :code:`double`
       - ✅
-      - all generators
+      - All generators
       - ✅
     *
       - :code:`double2`
@@ -400,21 +419,21 @@ Normal distribution
       - ❌
 
 Log-normal distributions
-""""""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^^^
 
- .. list-table:: Supported types for log-normal distributions on the device
+.. list-table:: Supported types for log-normal distributions on the device
     :header-rows: 1
     :name: device-types-log-normal-distribution
 
     *
       - Type
       - rocRAND support
-      - supported rocRAND generators
+      - Supported rocRAND generators
       - cuRAND support
     *
       - :code:`float`
       - ✅
-      - all generators
+      - All generators
       - ✅
     *
       - :code:`float2`
@@ -429,7 +448,7 @@ Log-normal distributions
     *
       - :code:`double`
       - ✅
-      - all generators
+      - All generators
       - ✅
     *
       - :code:`double2`
@@ -443,16 +462,16 @@ Log-normal distributions
       - ❌
 
 Poisson distributions
-"""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^
 
- .. list-table:: Supported types for poisson distributions on the device
+.. list-table:: Supported types for Poisson distributions on the device
     :header-rows: 1
     :name: device-types-poisson-distribution
 
     *
       - Type
       - rocRAND support
-      - supported rocRAND generators
+      - Supported rocRAND generators
       - cuRAND support
     *
       - :code:`unsigned int`
@@ -462,7 +481,7 @@ Poisson distributions
     *
       - :code:`unsigned long long int`
       - ✅
-      - Sobol64, Scrambled sobol64
+      - Sobol64, Scrambled Sobol64
       - ❌
     *
       - :code:`uint4`
@@ -471,27 +490,24 @@ Poisson distributions
       - ✅
 
 Discrete distributions
-""""""""""""""""""""""
+^^^^^^^^^^^^^^^^^^^^^^
 
- .. list-table:: Supported types for discrete distributions on the device
+.. list-table:: Supported types for discrete distributions on the device
     :header-rows: 1
     :name: device-types-discrete-distribution
 
     *
       - Type
       - rocRAND support
-      - supported rocRAND generators
+      - Supported rocRAND generators
       - cuRAND support
     *
       - :code:`unsigned int`
       - ✅
-      - all generators
+      - All generators
       - ✅
     *
       - :code:`uint4`
       - ✅
       - Philox 4x32-10
       - ✅ - only Philox - 4x32-10
-
-.. rubric:: Footnotes
-.. [#] Generation of 64 bit :code:`unsigned long long` integers is only supported by 64 bit generators (Scrambled Sobol 64, Sobol64, Threefry 2x64-20 and Threefry 4x64-20).
\ No newline at end of file
diff --git a/docs/api-reference/python-api.rst b/docs/api-reference/python-api.rst
index 189f9b0..ff7104c 100644
--- a/docs/api-reference/python-api.rst
+++ b/docs/api-reference/python-api.rst
@@ -1,6 +1,6 @@
 .. meta::
-  :description: rocRAND documentation and API reference library
-  :keywords: rocRAND, ROCm, API, documentation
+  :description: rocRAND Python API reference
+  :keywords: rocRAND, ROCm, API, documentation, Python
   
 .. _python-api:
 
@@ -13,7 +13,7 @@ This chapter describes the rocRAND Python module API.
 API index
 ------------
 
-To search an API, refer to the API :ref:`genindex`.
+To search the API, see the API :ref:`genindex`.
 
 .. default-domain:: py
 .. py:currentmodule:: rocrand
@@ -51,4 +51,4 @@ Utilities
 
 .. autofunction:: rocrand.get_version
 
-To search an API, refer to the :ref:`genindex` for all rocRAND APIs.
+To search the API, see the :ref:`genindex` for all rocRAND APIs.
diff --git a/docs/conceptual/curand-compatibility.rst b/docs/conceptual/curand-compatibility.rst
index d95e7a7..b75b48b 100644
--- a/docs/conceptual/curand-compatibility.rst
+++ b/docs/conceptual/curand-compatibility.rst
@@ -1,5 +1,5 @@
 .. meta::
-   :description: rocRAND documentation and API reference library
+   :description: rocRAND compatibility with cuRAND
    :keywords: rocRAND, ROCm, API, documentation, cuRAND
 
 .. _curand-compatibility:
@@ -10,7 +10,7 @@ cuRAND compatibility
 
 The following table shows which rocRAND generators produce the exact same sequence as the equivalent NVIDIA CUDA cuRAND generator when using legacy ordering, given the same seed, number of dimensions, and offset.
 
-.. table:: cuRAND Compatibility
+.. table:: cuRAND compatibility
     :widths: auto
 
     =================  =====================
diff --git a/docs/conceptual/dynamic_ordering_configuration.rst b/docs/conceptual/dynamic_ordering_configuration.rst
index bba95db..c1f62c0 100644
--- a/docs/conceptual/dynamic_ordering_configuration.rst
+++ b/docs/conceptual/dynamic_ordering_configuration.rst
@@ -1,6 +1,6 @@
 .. meta::
-   :description: rocRAND documentation and API reference library
-   :keywords: rocRAND, ROCm, API, documentation
+   :description: rocRAND documentation for dynamic ordering configuration
+   :keywords: rocRAND, ROCm, API, documentation, dynamic ordering
 
 .. _dynamic-ordering-configuration:
 
@@ -8,85 +8,135 @@
 Kernel configurations for dynamic ordering
 =============================================================
 
-Overview
-========
+When dynamic ordering (``ROCRAND_ORDERING_PSEUDO_DYNAMIC``) is set, rocRAND selects the number of blocks and threads
+to launch on the GPU to accommodate the specific GPU model best.
+Consequently, the number of allocated generators and the sequence of the generated numbers can also vary.
 
-When dynamic ordering (``ROCRAND_ORDERING_PSEUDO_DYNAMIC``) is set, the number of blocks and threads launched on the GPU is selected such that it best accommodates the specific GPU model. As a consequence, the number of allocated generators and thereby the sequence of the generated numbers can also vary.
-
-The tuning, i.e. the selection of the most performant configuration for each GPU architecture can be performed in an automated manner. The necessary tools and benchmarks for the tuning are provided in the rocRAND repository. In the following, the process of the tuning is described.
+The tuning, which is the selection of the most performant configuration for each GPU architecture,
+can be performed in an automated manner. The necessary tools and benchmarks for the tuning are provided
+in the rocRAND repository. The following sections provide additional details about the tuning process.
 
 .. _tuning-benchmark-build:
 
 Building the tuning benchmarks
 ==============================
 
-The principle of the tuning is very simple: the random number generation kernel is run for a list of kernel block size / kernel grid size combinations, and the fastest combination is selected as the dynamic ordering configuration for the particular device. rocRAND provides an executable target that runs the benchmarks with all these combinations: `benchmark_rocrand_tuning`. This target is disabled by default, and can be enabled and built by the following snippet.
+The principle behind the tuning is straightforward. The random number generation kernel is run
+for a list of kernel block size and kernel grid size combinations. The fastest combination
+is then selected as the dynamic ordering configuration for that particular device.
+rocRAND provides an executable target named ``benchmark_rocrand_tuning`` that runs the benchmarks with all these
+combinations.
+
+This target is disabled by default, but it can be enabled and built using the following snippet.
+Use the ``GPU_TARGETS`` variable to specify a comma-separated list of GPU architectures to build the benchmarks for.
+To determine the architecture of the installed GPU(s), run the ``rocminfo`` command
+and look for ``gfx`` in the "ISA Info" section.
 
-Use the `GPU_TARGETS` variable to specify the comma-separated list of GPU architectures to build the benchmarks for. To acquire the architecture of the GPU(s) installed, run `rocminfo`, and look for `gfx` in the "ISA Info" section. ::
+.. code-block:: shell
 
-    $ cd rocRAND
-    $ cmake -S . -B ./build
-        -D BUILD_BENCHMARK=ON
-        -D BUILD_BENCHMARK_TUNING=ON
-        -D CMAKE_CXX_COMPILER=/opt/rocm/bin/amdclang++
-        -D GPU_TARGETS=gfx908
-    $ cmake --build build --target benchmark_rocrand_tuning
+   cd rocm-libraries/projects/rocrand
+   cmake -S . -B ./build
+      -D BUILD_BENCHMARK=ON
+      -D BUILD_BENCHMARK_TUNING=ON
+      -D CMAKE_CXX_COMPILER=/opt/rocm/bin/amdclang++
+      -D GPU_TARGETS=gfx908
+   cmake --build build --target benchmark_rocrand_tuning
 
-Additionally, the following CMake cache variables control the generation of the benchmarked matrix:
+The following CMake cache variables control the generation of the benchmarked matrix:
 
 ========================================== ===============================================================
 Variable name                              Explanation
 ========================================== ===============================================================
 ``BENCHMARK_TUNING_THREAD_OPTIONS``        Comma-separated list of benchmarked block sizes
 ``BENCHMARK_TUNING_BLOCK_OPTIONS``         Comma-separated list of benchmarked grid sizes
-``BENCHMARK_TUNING_MIN_GRID_SIZE``         Configurations with fewer total number of threads are omitted
+``BENCHMARK_TUNING_MIN_GRID_SIZE``         Configurations with fewer total threads are omitted
 ========================================== ===============================================================
 
-Note, that currently the benchmark tuning is only supported for AMD GPUs. 
+.. note::
+
+   The benchmark tuning is only supported for AMD GPUs. 
 
 Using the number of multiprocessors as candidates
 -------------------------------------------------
 
-Multiples of the number of multiprocessors of the GPU at hand are good candidates for ``BENCHMARK_TUNING_BLOCK_OPTIONS``. Running `rocRAND/scripts/config-tuning/get_tuned_grid_sizes.py` executes `rocminfo` to acquire the number of multiprocessors, and prints a comma-separated list of grid size candidates to the standard output.
+Multiples of the number of multiprocessors on the GPU being benchmarked are
+good candidate values for ``BENCHMARK_TUNING_BLOCK_OPTIONS``. 
+The ``rocm-libraries/projects/rocrand/scripts/config-tuning/get_tuned_grid_sizes.py`` executable
+runs ``rocminfo`` to acquire the number of multiprocessors and prints a comma-separated list
+of grid size candidates to the standard output.
 
 .. _tuning-benchmark-run:
 
 Running the tuning benchmarks
 =============================
 
-When the `benchmark_rocrand_tuning` target is built, the benchmarks can be run and the results can be collected for further processing. Since the benchmarks run for a longer time period, it is crucial that the GPU in use is thermally stable, i.e. the cooling must be adequate enough to keep the GPU at the preset clock rates without throttling. Additionally, make sure that no other workload is dispatched on the GPU concurrently. Otherwise the resulting dynamic ordering configs might not be the optimal ones. The full benchmark suite can be run with the following command: ::
+After building the ``benchmark_rocrand_tuning`` target, you can run the benchmarks
+and collect the results for further processing.
+The benchmarks can run for a long time, so it is crucial that the GPU in use is thermally stable.
+For instance, there must be adequate cooling to keep the GPU at the preset clock rates without throttling.
+Additionally, ensure that no other workload is concurrently dispatched to the GPU.
+Otherwise, the resulting dynamic ordering configurations might not be the optimal ones.
+Run the full benchmark suite using the following command:
 
-    $ cd ./build/benchmark/tuning
-    $ ./benchmark_rocrand_tuning --benchmark_out_format=json --benchmark_out=rocrand_tuning_gfx908.json
+.. code-block:: shell
 
-This executes the benchmarks and saves the benchmark results into the JSON file at `rocrand_tuning_gfx908.json`. If only a subset of the benchmarks needs to be run, e.g. for a single generator, the `--benchmark_filter=<regex>` option can be used. For example: `--benchmark_filter=".*philox.*"`.
+   cd ./build/benchmark/tuning
+   ./benchmark_rocrand_tuning --benchmark_out_format=json --benchmark_out=rocrand_tuning_gfx908.json
+
+This executes the benchmarks and saves the benchmark results to the ``rocrand_tuning_gfx908.json`` JSON file.
+To only run a subset of the benchmarks, such as for a single generator, use the ``--benchmark_filter=<regex>`` option,
+for example, ``--benchmark_filter=".*philox.*"``.
 
 .. _tuning-benchmark-process:
 
 Processing the benchmark results
 ================================
 
-Once the benchmark results in JSON format from all architectures are present, the best configs are selected using the `rocRAND/scripts/config-tuning/select_best_config.py` script. Make sure that the prerequisite libraries are installed, by running ``pip install -r rocRAND/scripts/config-tuning/requirements.txt``.
+After the benchmark results from all architectures in JSON format are available, the best configurations
+are selected using the ``rocm-libraries/projects/rocrand/scripts/config-tuning/select_best_config.py`` script.
+Ensure the prerequisite libraries are installed by running the following command:
+
+.. code-block:: shell
 
-Each rocRAND generator is capable of generating a multitude of output types and distributions. However, a single configuration is selected for each GPU architecture, which applies uniformly to all types and distributions. It is possible that the configuration that performs the best for one distribution is not the fastest for another. `select_best_config.py` selects the configuration that performs best **on average**. If, under the selected configuration, any type/distribution performs worse than ``ROCRAND_ORDERING_PSEUDO_DEFAULT``, a warning is printed to the standard output. The eventual decision about applying the configuration or not have to be made by the library's maintainers.
+   pip install -r rocm-libraries/projects/rocrand/scripts/config-tuning/requirements.txt.
 
-The main output of running `select_best_config.py` is a number of C++ header files that contain the definitions of the dynamic ordering config for the benchmarked architectures. These files are intended to be copied to the `rocRAND/library/src/rng/config` directory of the source tree to be checked in to the version control. The directory, to which the header files are written, can be specified with the `--out-dir` option.
+Each rocRAND generator can generate a multitude of output types and distributions.
+However, a single configuration is selected for each GPU architecture, which applies uniformly to all types
+and distributions. It's possible that the best performing configuration for one distribution
+isn't the fastest for another. ``select_best_config.py`` selects the configuration that performs best **on average**.
+If any type or distribution performs worse than ``ROCRAND_ORDERING_PSEUDO_DEFAULT`` under the selected configuration,
+a warning is printed to the standard output.
+The eventual decision about whether to apply the configuration is made by the library's maintainers.
 
-To help humans comprehend the results, `select_best_config.py` can generate colorized diagrams to visually compare the performance of the configuration candidates. This can be invoked by passing the optional `--plot-out` argument, e.g. `--plot-out rocrand-tuning.svg`. This generates an SVG image for each GPU architecture the script has processed.
+The ``select_best_config.py``  script produces a set of C++ header files as output
+that contain the definitions of the dynamic ordering configuration for the benchmarked architectures.
+These files are intended to be copied to the ``rocm-libraries/projects/rocrand/library/src/rng/config`` directory of the source tree
+and checked in to the version control system. The directory where the header files are written to
+can be specified using the ``--out-dir`` option.
 
-To put it all together, a potential invocation of the `select_best_config.py` script: ::
+For more readable results, ``select_best_config.py`` can generate colorized diagrams to visually
+compare the performance of the configuration candidates. To select this option, use the
+optional ``--plot-out`` argument, for example, ``--plot-out rocrand-tuning.svg``.
+This generates an SVG image for each GPU architecture processed by the script.
 
-    $ ./rocRAND/scripts/config-tuning/select_best_config.py --plot-out ./rocrand-tuning.svg --out-dir ./rocRAND/library/src/rng/config/ ./rocRAND/build/benchmark/tuning/rocrand_tuning_gfx908.json ./rocRAND/build/benchmark/tuning/rocrand_tuning_gfx1030.json
+The following invokation of the ``select_best_config.py`` script demonstrates all these options:
+
+.. code-block:: shell
+
+   ./rocm-libraries/projects/rocrand/scripts/config-tuning/select_best_config.py --plot-out ./rocrand-tuning.svg --out-dir ./rocm-libraries/projects/rocrand/library/src/rng/config/ ./rocm-libraries/projects/rocrand/build/benchmark/tuning/rocrand_tuning_gfx908.json ./rocm-libraries/projects/rocrand/build/benchmark/tuning/rocrand_tuning_gfx1030.json
 
 Adding support for a new GPU architecture
 =========================================
 
-The intended audience of this section is the developer, who is adding support to rocRAND for a new GPU architecture.
+This section is intended for developers who want to add rocRAND support for a new GPU architecture.
+To add support, follow this checklist:
+
+#. Update the hard-coded list of recognized architectures in the ``library/src/rng/config_types.hpp`` file. The following symbols must be updated accordingly:
+
+   *  Enum class ``target_arch``: Lists the recognized architectures as an enumeration.
+   *  Function ``get_device_arch``: The device to compile to in the device code.
+   *  Function ``parse_gcn_arch``: Translates from the name of the architecture to the ``target_arch`` enum in the host code.
 
-1. The list of the recognized architectures are hard-coded in source file `library/src/rng/config_types.hpp`. The following symbols have to be updated accordingly:
-    * Enum class ``target_arch`` - lists the recognized architectures as an enumeration.
-    * Function ``get_device_arch`` - recognizes the device that we compile to in device code.
-    * Function ``parse_gcn_arch`` - dispatches from the name of the architecture to the ``target_arch`` enum in host code.
-2. The tuning benchmarks has to be compiled and run for the new architecture. See :ref:`tuning-benchmark-build` and :ref:`tuning-benchmark-run`.
-3. The benchmark results have to be processed by the provided `select_best_config.py` script. See :ref:`tuning-benchmark-process`.
-4. The resulting header files have to be merged with the ones that are checked in the version control in directory `rocRAND/library/src/rng/config`.
+#. The tuning benchmarks must be compiled and run for the new architecture. See :ref:`tuning-benchmark-build` and :ref:`tuning-benchmark-run`.
+#. The benchmark results must be processed by the ``select_best_config.py`` script. See :ref:`tuning-benchmark-process`.
+#. The resulting header files must be added to version control in the ``rocm-libraries/projects/rocrand/library/src/rng/config`` directory.
diff --git a/docs/conceptual/programmers-guide.rst b/docs/conceptual/programmers-guide.rst
index 4ebc971..0dcce5c 100644
--- a/docs/conceptual/programmers-guide.rst
+++ b/docs/conceptual/programmers-guide.rst
@@ -1,163 +1,181 @@
 .. meta::
-  :description: rocRAND documentation and API reference library
-  :keywords: rocRAND, ROCm, API, documentation
+  :description: Programming guide for rocRAND
+  :keywords: rocRAND, ROCm, API, documentation, programming, generator types
   
 .. _programmers-guide:
 
-==================
-Programmer's guide
-==================
+*******************************************************************
+rocRAND programming guide
+*******************************************************************
+
+This topic discusses some issues to consider when using rocRAND in your application.
 
 Generator types
-===============
+===============================