Merge staging-next into staging

pkgs/applications/editors/vim/plugins/generated.nix

···
 
   LazyVim = buildVimPlugin {
     pname = "LazyVim";
-    version = "2025-02-15";
+    version = "2025-02-22";
     src = fetchFromGitHub {
       owner = "LazyVim";
       repo = "LazyVim";
-      rev = "401ef48fcd617534b017ef471309bb1bd6465131";
-      sha256 = "1056af0psn9pxm1q9fcfh8rnv66fapq6fbv7h88ppz8c88d5lr0d";
+      rev = "cb223553ff73eb2f37ffb5dc0bb75b76a4677faf";
+      sha256 = "0yc8xcgfjfg0j4jm0rkfpd9d0bg6n29vsm2g9fdmacbmhx79261l";
     };
     meta.homepage = "https://github.com/LazyVim/LazyVim/";
     meta.hydraPlatforms = [ ];

pkgs/applications/networking/cluster/rke2/1_29/versions.nix

···
+{
+  rke2Version = "1.29.13+rke2r1";
+  rke2Commit = "00803ef95072be9d13b6e52a56fa9b6d9e7b0a51";
+  rke2TarballHash = "sha256-1OphaTrEU2MvV0kdEyxomRGgbl/YSVikcYtLuL3QnBI=";
+  rke2VendorHash = "sha256-6XczvyQMqYqHHu+cSsmXsi7zMG128ZwiAHr482qQqpI=";
+  k8sImageTag = "v1.29.13-rke2r1-build20250117";
+  etcdVersion = "v3.5.16-k3s1-build20241106";
+  pauseVersion = "3.6";
+  ccmVersion = "v1.29.10-0.20241016053521-9510ac25fefb-build20241016";
+  dockerizedVersion = "v1.29.13-rke2r1";
+}

pkgs/applications/networking/cluster/rke2/1_30/versions.nix

···
+{
+  rke2Version = "1.30.9+rke2r1";
+  rke2Commit = "bfd23524f32a4d9fa6f19ab58a2d47572e56f813";
+  rke2TarballHash = "sha256-/WVKmK9ZackY9ULST0zFi/RRwA4ZR3u1DXULWTc6G3o=";
+  rke2VendorHash = "sha256-kghiYswm3s7bILGp8t452jx84MY73EF9OTaWdncFr34=";
+  k8sImageTag = "v1.30.9-rke2r1-build20250116";
+  etcdVersion = "v3.5.16-k3s1-build20241106";
+  pauseVersion = "3.6";
+  ccmVersion = "v1.30.6-0.20241016053533-5ec454f50e7a-build20241016";
+  dockerizedVersion = "v1.30.9-rke2r1";
+}

pkgs/applications/networking/cluster/rke2/README.md

···
 # RKE2 Version
 
-RKE2, Kubernetes, and other clustered software has the property of not being able to update atomically.
-Most software in nixpkgs, like for example bash, can be updated as part of a `nixos-rebuild switch`
-without having to worry about the old and the new bash interacting in some way.
+RKE2, Kubernetes, and other clustered software has the property of not being able to update
+atomically. Most software in nixpkgs, like for example bash, can be updated as part of a
+`nixos-rebuild switch` without having to worry about the old and the new bash interacting in some
+way. RKE2/Kubernetes, on the other hand, is typically run across several machines, and each machine
+is updated independently. As such, different versions of the package and NixOS module must maintain
+compatibility with each other through temporary version skew during updates. The upstream Kubernetes
+project documents this in their
+[version-skew policy](https://kubernetes.io/releases/version-skew-policy/#supported-component-upgrade-order).
+
+Within nixpkgs, we strive to maintain a valid "upgrade path" that does not run afoul of the upstream
+version skew policy.
 
 > [!NOTE]
-> Upgrade the server nodes first, one at a time. Once all servers have been upgraded, you may then upgrade agent nodes.
+> Upgrade the server nodes first, one at a time. Once all servers have been upgraded, you may then
+> upgrade agent nodes.
 
 ## Release Channels
 
-RKE2 has three main release channels, which are: `stable`, `latest` and `testing`.
+RKE2 has two named release channels, i.e. `stable` and `latest`. Additionally, there exists a
+release channel tied to each Kubernetes minor version, e.g. `v1.32`.
 
-The `stable` channel is the default channel and is recommended for production use.
-The `latest` channel is the latest release.
-The `testing` channel is the latest release, including pre-releases.
+Nixpkgs follows active minor version release channels (typically 4 at a time) and sets aliases for
+`rke2_stable` and `rke2_latest` accordingly.
 
-| Channel   | Description                                                                                                                                                                                    |
-| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `stable`  | **(Default)** Stable is recommended for production environments. These releases have been through a period of community hardening, and are compatible with the most recent release of Rancher. |
-| `latest`  | Latest is recommended for trying out the latest features. These releases have not yet been through a period of community hardening, and may not be compatible with Rancher.                    |
-| `testing` | The most recent release, including pre-releases.                                                                                                                                               |
+Patch releases should be backported to to the latest stable release branch, however, new minor
+versions are not backported.
 
-Learn more about the [RKE2 release channels](https://docs.rke2.io/upgrade/manual_upgrade).
+For further information visit the
+[RKE2 release channels documentation](https://docs.rke2.io/upgrades/manual_upgrade?_highlight=manua#release-channels).
 
-For an exhaustive and up-to-date list of channels, you can visit the
-[rke2 channel service API](https://update.rke2.io/v1-release/channels).
-For more technical details on how channels work, you can see the [channelserver project](https://github.com/rancher/channelserver).
+## EOL Versions
 
-> [!TIP]
-> When attempting to upgrade to a new version of RKE2,
-> the [Kubernetes version skew policy](https://kubernetes.io/docs/setup/release/version-skew-policy) applies.
-> Ensure that your plan **does not skip intermediate minor versions** when upgrading. Nothing in the upgrade process will
-> protect you against unsupported changes to the Kubernetes version.
+Approximately every 4 months a minor RKE2 version reaches EOL. EOL versions should be removed from
+`nixpkgs-unstable`, preferably by throwing with an explanatory message in
+`pkgs/top-level/aliases.nix`. With stable releases, however, it isn't expected that packages will be
+removed. Instead we set `meta.knownVulnerabilities` for stable EOL packages, like it is also done
+for EOL JDKs, browser engines, Node.js versions, etc.
+
+For further information on the RKE2 lifecycle, see the
+[SUSE Product Support Lifecycle page](https://www.suse.com/lifecycle#rke2).

pkgs/applications/networking/cluster/rke2/builder.nix

···
   pauseVersion,
   ccmVersion,
   dockerizedVersion,
-  ...
 }:
 
 # Build dependencies
···
   # Testing dependencies
   nixosTests,
   testers,
-  rke2,
 }:
+let
+  rke2 = buildGoModule rec {
+    pname = "rke2";
+    version = rke2Version;
 
-buildGoModule rec {
-  pname = "rke2";
-  version = rke2Version;
+    src = fetchzip {
+      url = "https://github.com/rancher/rke2/archive/refs/tags/v${rke2Version}.tar.gz";
+      hash = "${rke2TarballHash}";
+    };
 
-  src = fetchzip {
-    url = "https://github.com/rancher/rke2/archive/refs/tags/v${rke2Version}.tar.gz";
-    hash = "${rke2TarballHash}";
-  };
+    vendorHash = rke2VendorHash;
 
-  vendorHash = rke2VendorHash;
+    nativeBuildInputs = [ makeWrapper ];
 
-  nativeBuildInputs = [ makeWrapper ];
+    # Important utilities used by the kubelet.
+    # See: https://github.com/kubernetes/kubernetes/issues/26093#issuecomment-237202494
+    # Notice the list in that issue is stale, but as a redundancy reservation.
+    buildInputs = [
+      procps # pidof pkill
+      coreutils # uname touch env nice du
+      util-linux # lsblk fsck mkfs nsenter mount umount
+      ethtool # ethtool
+      socat # socat
+      iptables # iptables iptables-restore iptables-save
+      bridge-utils # brctl
+      iproute2 # ip tc
+      kmod # modprobe
+      lvm2 # dmsetup
+    ];
 
-  # Important utilities used by the kubelet.
-  # See: https://github.com/kubernetes/kubernetes/issues/26093#issuecomment-237202494
-  # Notice the list in that issue is stale, but as a redundancy reservation.
-  buildInputs = [
-    procps # pidof pkill
-    coreutils # uname touch env nice du
-    util-linux # lsblk fsck mkfs nsenter mount umount
-    ethtool # ethtool
-    socat # socat
-    iptables # iptables iptables-restore iptables-save
-    bridge-utils # brctl
-    iproute2 # ip tc
-    kmod # modprobe
-    lvm2 # dmsetup
-  ];
-
-  # See: https://github.com/rancher/rke2/blob/e7f87c6dd56fdd76a7dab58900aeea8946b2c008/scripts/build-binary#L27-L38
-  ldflags = [
-    "-w"
-    "-X github.com/k3s-io/k3s/pkg/version.GitCommit=${lib.substring 0 6 rke2Commit}"
-    "-X github.com/k3s-io/k3s/pkg/version.Program=${pname}"
-    "-X github.com/k3s-io/k3s/pkg/version.Version=v${version}"
-    "-X github.com/k3s-io/k3s/pkg/version.UpstreamGolang=go${go.version}"
-    "-X github.com/rancher/rke2/pkg/images.DefaultRegistry=docker.io"
-    "-X github.com/rancher/rke2/pkg/images.DefaultEtcdImage=rancher/hardened-etcd:${etcdVersion}"
-    "-X github.com/rancher/rke2/pkg/images.DefaultKubernetesImage=rancher/hardened-kubernetes:${k8sImageTag}"
-    "-X github.com/rancher/rke2/pkg/images.DefaultPauseImage=rancher/mirrored-pause:${pauseVersion}"
-    "-X github.com/rancher/rke2/pkg/images.DefaultRuntimeImage=rancher/rke2-runtime:${dockerizedVersion}"
-    "-X github.com/rancher/rke2/pkg/images.DefaultCloudControllerManagerImage=rancher/rke2-cloud-provider:${ccmVersion}"
-  ];
+    # See: https://github.com/rancher/rke2/blob/e7f87c6dd56fdd76a7dab58900aeea8946b2c008/scripts/build-binary#L27-L38
+    ldflags = [
+      "-w"
+      "-X github.com/k3s-io/k3s/pkg/version.GitCommit=${lib.substring 0 6 rke2Commit}"
+      "-X github.com/k3s-io/k3s/pkg/version.Program=${pname}"
+      "-X github.com/k3s-io/k3s/pkg/version.Version=v${version}"
+      "-X github.com/k3s-io/k3s/pkg/version.UpstreamGolang=go${go.version}"
+      "-X github.com/rancher/rke2/pkg/images.DefaultRegistry=docker.io"
+      "-X github.com/rancher/rke2/pkg/images.DefaultEtcdImage=rancher/hardened-etcd:${etcdVersion}"
+      "-X github.com/rancher/rke2/pkg/images.DefaultKubernetesImage=rancher/hardened-kubernetes:${k8sImageTag}"
+      "-X github.com/rancher/rke2/pkg/images.DefaultPauseImage=rancher/mirrored-pause:${pauseVersion}"
+      "-X github.com/rancher/rke2/pkg/images.DefaultRuntimeImage=rancher/rke2-runtime:${dockerizedVersion}"
+      "-X github.com/rancher/rke2/pkg/images.DefaultCloudControllerManagerImage=rancher/rke2-cloud-provider:${ccmVersion}"
+    ];
 
-  tags = [
-    "no_cri_dockerd"
-    "no_embedded_executor"
-    "no_stage"
-    "sqlite_omit_load_extension"
-    "selinux"
-    "netgo"
-    "osusergo"
-  ];
+    tags = [
+      "no_cri_dockerd"
+      "no_embedded_executor"
+      "no_stage"
+      "sqlite_omit_load_extension"
+      "selinux"
+      "netgo"
+      "osusergo"
+    ];
 
-  subPackages = [ "." ];
+    subPackages = [ "." ];
 
-  installPhase = ''
-    install -D $GOPATH/bin/rke2 $out/bin/rke2
-    wrapProgram $out/bin/rke2 \
-      --prefix PATH : ${lib.makeBinPath buildInputs}
+    installPhase = ''
+      install -D $GOPATH/bin/rke2 $out/bin/rke2
+      wrapProgram $out/bin/rke2 \
+        --prefix PATH : ${lib.makeBinPath buildInputs}
 
-    install -D ./bundle/bin/rke2-killall.sh $out/bin/rke2-killall.sh
-    wrapProgram $out/bin/rke2-killall.sh \
-      --prefix PATH : ${
-        lib.makeBinPath [
-          systemd
-          gnugrep
-          gnused
-        ]
-      } \
-      --prefix PATH : ${lib.makeBinPath buildInputs}
-  '';
+      install -D ./bundle/bin/rke2-killall.sh $out/bin/rke2-killall.sh
+      wrapProgram $out/bin/rke2-killall.sh \
+        --prefix PATH : ${
+          lib.makeBinPath [
+            systemd
+            gnugrep
+            gnused
+          ]
+        } \
+        --prefix PATH : ${lib.makeBinPath buildInputs}
+    '';
 
-  doCheck = false;
+    doCheck = false;
 
-  passthru.updateScript = updateScript;
+    passthru.updateScript = updateScript;
 
-  passthru.tests =
-    {
-      version = testers.testVersion {
-        package = rke2;
-        version = "v${version}";
+    passthru.tests =
+      {
+        version = testers.testVersion {
+          package = rke2;
+          version = "v${version}";
+        };
+      }
+      // lib.optionalAttrs stdenv.hostPlatform.isLinux {
+        inherit (nixosTests) rke2;
       };
-    }
-    // lib.optionalAttrs stdenv.hostPlatform.isLinux {
-      inherit (nixosTests) rke2;
-    };
 
-  meta = with lib; {
-    homepage = "https://github.com/rancher/rke2";
-    description = "RKE2, also known as RKE Government, is Rancher's next-generation Kubernetes distribution";
-    changelog = "https://github.com/rancher/rke2/releases/tag/v${version}";
-    license = licenses.asl20;
-    maintainers = with maintainers; [
-      zimbatm
-      zygot
-    ];
-    mainProgram = "rke2";
-    platforms = platforms.linux;
+    meta = with lib; {
+      homepage = "https://github.com/rancher/rke2";
+      description = "RKE2, also known as RKE Government, is Rancher's next-generation Kubernetes distribution";
+      changelog = "https://github.com/rancher/rke2/releases/tag/v${version}";
+      license = licenses.asl20;
+      maintainers = with maintainers; [
+        zimbatm
+        zygot
+      ];
+      mainProgram = "rke2";
+      platforms = platforms.linux;
+    };
   };
-}
+in
+rke2

pkgs/applications/networking/cluster/rke2/default.nix

···
   common = opts: callPackage (import ./builder.nix lib opts);
   extraArgs = builtins.removeAttrs args [ "callPackage" ];
 in
-{
-  rke2_stable = common (
-    (import ./stable/versions.nix)
+rec {
+  rke2_1_29 = common (
+    (import ./1_29/versions.nix)
     // {
       updateScript = [
         ./update-script.sh
-        "stable"
+        "29"
       ];
     }
   ) extraArgs;
 
-  rke2_latest = common (
-    (import ./latest/versions.nix)
+  rke2_1_30 = common (
+    (import ./1_30/versions.nix)
     // {
       updateScript = [
         ./update-script.sh
-        "latest"
+        "30"
       ];
     }
   ) extraArgs;
 
-  rke2_testing = common (
-    (import ./testing/versions.nix)
+  rke2_1_31 = common (
+    (import ./1_31/versions.nix)
     // {
       updateScript = [
         ./update-script.sh
-        "testing"
+        "31"
+      ];
+    }
+  ) extraArgs;
+
+  rke2_1_32 = common (
+    (import ./1_32/versions.nix)
+    // {
+      updateScript = [
+        ./update-script.sh
+        "32"
       ];
     }
   ) extraArgs;
+
+  # Automatically set by update script
+  rke2_stable = rke2_1_31;
+  rke2_latest = rke2_1_32;
 }

pkgs/applications/networking/cluster/rke2/latest/versions.nix pkgs/applications/networking/cluster/rke2/1_32/versions.nix

···
   rke2Commit = "c0f7be4407cf2c437cacfe735e5c943e827f2ff8";
   rke2TarballHash = "sha256-clZpTnMnj2PRDDYz7+r11RlyX2ExwsE1Tmdt3/kUmtE=";
   rke2VendorHash = "sha256-aIB2fRkccx5fXMnFxZ+tirXp5gg8o/h/a6Lgc+EG4L4=";
-  k8sVersion = "v1.32.1";
   k8sImageTag = "v1.32.1-rke2r1-build20250115";
   etcdVersion = "v3.5.16-k3s1-build20241106";
   pauseVersion = "3.6";
   ccmVersion = "v1.32.0-rc3.0.20241220224140-68fbd1a6b543-build20250101";
   dockerizedVersion = "v1.32.1-rke2r1";
-  golangVersion = "go1.23.4";
-  eol = "2026-02-28";
 }

pkgs/applications/networking/cluster/rke2/stable/versions.nix pkgs/applications/networking/cluster/rke2/1_31/versions.nix

···
   rke2Commit = "08e198bbe3f0b8d4c9b0af4d92085c06bb94aa89";
   rke2TarballHash = "sha256-GG1GOs/kLWDCvc/+l0ymRpJzEthIyGpampCjvfnEPB8=";
   rke2VendorHash = "sha256-xWqMidOWiLgJXp6AEITkyOieLw4yi1JMmi80YS4RNy0=";
-  k8sVersion = "v1.31.5";
   k8sImageTag = "v1.31.5-rke2r1-build20250115";
   etcdVersion = "v3.5.16-k3s1-build20241106";
   pauseVersion = "3.6";
   ccmVersion = "v1.31.2-0.20241016053446-0955fa330f90-build20241016";
   dockerizedVersion = "v1.31.5-rke2r1";
-  golangVersion = "go1.22.10";
-  eol = "2025-10-28";
 }

pkgs/applications/networking/cluster/rke2/testing/versions.nix

···
-{
-  rke2Version = "1.31.4-rc3+rke2r1";
-  rke2Commit = "b2d8003d79075e7331ab8f2d1e1a3c494ed944b9";
-  rke2TarballHash = "sha256-eTA+/fF6HuXDT4EUnvPIaJtLfbNGk9BXG+z3zCRPh9s=";
-  rke2VendorHash = "sha256-akP6XLkeBtVVGgaLBcn+e1bwFtMPRs1/NGR9VN5UuCo=";
-  k8sVersion = "v1.31.4";
-  k8sImageTag = "v1.31.4-rke2r1-build20241212";
-  etcdVersion = "v3.5.16-k3s1-build20241106";
-  pauseVersion = "3.6";
-  ccmVersion = "v1.31.2-0.20241016053446-0955fa330f90-build20241016";
-  dockerizedVersion = "v1.31.4-rc3-rke2r1";
-  golangVersion = "go1.22.9";
-  eol = "2025-10-28";
-}

pkgs/applications/networking/cluster/rke2/update-script.sh

···
 SHELL_FLAGS=$(set +o)
 set -x -eu -o pipefail
 
-CHANNEL_NAME="${1:?Must provide a release channel, like 'stable', as the only argument}"
+MINOR_VERSION="${1:?Must provide a minor version number, like '26', as the only argument}"
 
 WORKDIR=$(cd $(dirname ${BASH_SOURCE[0]}) && pwd -P)
-mkdir --parents --verbose "${WORKDIR}/${CHANNEL_NAME}"
+mkdir --parents --verbose "${WORKDIR}/1_${MINOR_VERSION}"
 
-LATEST_TAG_NAME=$(curl -sS --fail https://update.rke2.io/v1-release/channels | \
-    yq ".data[] | select(.id == \"${CHANNEL_NAME}\") | .latest")
+NIXPKGS_ROOT="$(git rev-parse --show-toplevel)/"
+OLD_VERSION="$(nix-instantiate --eval -E "(import $NIXPKGS_ROOT. {}).rke2_1_${MINOR_VERSION}.version or \"0\"" | tr -d '"')"
+
+RELEASE_CHANNEL_DATA=$(curl -sS --fail https://update.rke2.io/v1-release/channels | yq ".data[]")
+LATEST_TAG_NAME=$(yq -p=json "select(.id == \"v1.$MINOR_VERSION\") | .latest" <<< "$RELEASE_CHANNEL_DATA")
+LATEST_RELEASE_VERSION=$(yq -p=json 'select(.id == "latest") | .latest' <<< "$RELEASE_CHANNEL_DATA")
+STABLE_RELEASE_VERSION=$(yq -p=json 'select(.id == "stable") | .latest' <<< "$RELEASE_CHANNEL_DATA")
 
-RKE2_VERSION=$(echo ${LATEST_TAG_NAME} | sed 's/^v//')
+RKE2_VERSION=${LATEST_TAG_NAME/v/}
 RKE2_COMMIT=$(curl -sS --fail "https://api.github.com/repos/rancher/rke2/git/refs/tags/${LATEST_TAG_NAME}" | yq '.object.sha')
 
 PREFETCH_META=$(nix-prefetch-url --unpack --print-path "https://github.com/rancher/rke2/archive/refs/tags/${LATEST_TAG_NAME}.tar.gz")
···
 STORE_PATH="${PREFETCH_META##*$'\n'}"
 
 cd ${STORE_PATH}
+# Used in scripts/version.sh
 GITHUB_ACTION_TAG=${LATEST_TAG_NAME}
 DRONE_COMMIT=${RKE2_COMMIT}
 
···
 ETCD_BUILD=$(grep "images.DefaultEtcdImage" scripts/build-binary | sed 's/.*-\(build[0-9]*\)$/\1/')
 ETCD_VERSION="${ETCD_VERSION}-${ETCD_BUILD}"
 cd ${WORKDIR}
-
-KUBERNETES_CYCLES=$(echo ${KUBERNETES_VERSION} | grep -Eo "[0-9]+\.[0-9]+")
-KUBERNETES_EOL=$(curl -sS --fail https://endoflife.date/api/kubernetes/${KUBERNETES_CYCLES}.json | yq ".eol")
 
 FAKE_HASH="sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
 
-cat << EOF > "${WORKDIR}/${CHANNEL_NAME}/versions.nix"
+cat << EOF > "${WORKDIR}/1_${MINOR_VERSION}/versions.nix"
 {
   rke2Version = "${RKE2_VERSION}";
   rke2Commit = "${RKE2_COMMIT}";
   rke2TarballHash = "${STORE_HASH}";
   rke2VendorHash = "${FAKE_HASH}";
-  k8sVersion = "${KUBERNETES_VERSION}";
   k8sImageTag = "${KUBERNETES_IMAGE_TAG}";
   etcdVersion = "${ETCD_VERSION}";
   pauseVersion = "${PAUSE_VERSION}";
   ccmVersion = "${CCM_VERSION}";
   dockerizedVersion = "${DOCKERIZED_VERSION}";
-  golangVersion = "${VERSION_GOLANG}";
-  eol = "${KUBERNETES_EOL}";
 }
 EOF
 
-set +e
-RKE2_VENDOR_HASH=$(nurl -e "(import $(git rev-parse --show-toplevel) {}).rke2_${CHANNEL_NAME}.goModules")
-set -e
-
+RKE2_VENDOR_HASH=$(nurl -e "(import $NIXPKGS_ROOT. {}).rke2_1_${MINOR_VERSION}.goModules")
 if [ -n "${RKE2_VENDOR_HASH:-}" ]; then
-    sed -i "s#${FAKE_HASH}#${RKE2_VENDOR_HASH}#g" ${WORKDIR}/${CHANNEL_NAME}/versions.nix
+    sed -i "s#${FAKE_HASH}#${RKE2_VENDOR_HASH}#g" ${WORKDIR}/1_${MINOR_VERSION}/versions.nix
 else
     echo "Update failed. 'RKE2_VENDOR_HASH' is empty."
     exit 1
 fi
 
+FILES_CHANGED=("${WORKDIR}/1_${MINOR_VERSION}/versions.nix")
+if [ "$LATEST_TAG_NAME" == "$LATEST_RELEASE_VERSION" ]; then
+    sed -ri "s#^(\s*)rke2_latest = .*;\$#\1rke2_latest = rke2_1_${MINOR_VERSION};#" "${WORKDIR}/default.nix"
+    FILES_CHANGED+=("${WORKDIR}/default.nix")
+elif [ "$LATEST_TAG_NAME" == "$STABLE_RELEASE_VERSION" ]; then
+    sed -ri "s#^(\s*)rke2_stable = .*;\$#\1rke2_stable = rke2_1_${MINOR_VERSION};#" "${WORKDIR}/default.nix"
+    FILES_CHANGED+=("${WORKDIR}/default.nix")
+fi
+
 # Implement commit
 # See: https://nixos.org/manual/nixpkgs/stable/#var-passthru-updateScript-commit
-set +u
-cat << EOF
-[
-  {
-    "attrPath": "rke2_${CHANNEL_NAME}",
-    "oldVersion": "${UPDATE_NIX_OLD_VERSION}",
-    "newVersion": "${RKE2_VERSION}",
-    "files": [
-      "${WORKDIR}/${CHANNEL_NAME}/versions.nix"
-    ]
-  }
-]
-EOF
+attr_path="rke2_1_${MINOR_VERSION}" \
+    old_version="${OLD_VERSION}" \
+    new_version="${RKE2_VERSION}" \
+    files=[$(printf '"%s",' "${FILES_CHANGED[@]}")] \
+    yq --null-input -o=json '[{"attrPath": strenv(attr_path), "oldVersion": strenv(old_version), "newVersion": strenv(new_version), "files": env(files)}]'
 
 set +x
 eval "$SHELL_FLAGS"

pkgs/by-name/bp/bpftune/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "bpftune";
-  version = "0-unstable-2025-01-17";
+  version = "0-unstable-2025-02-13";
 
   src = fetchFromGitHub {
     owner = "oracle";
     repo = "bpftune";
-    rev = "3c6ce4fc0c963610b7bada0ad6bac31c43eaab2e";
-    hash = "sha256-0f9cbJgZqGlatMSCKjNsT1NniyrteRANHR1Fj8o4J0c=";
+    rev = "2f73157b0e6f15034d898f3f92a376e89c3e3819";
+    hash = "sha256-0hgTJkGEU1xw2aCvTbhMVOz6EKtICrBqVPwIh5vxCOI=";
   };
 
   postPatch = ''

pkgs/by-name/co/cosmic-osd/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cosmic-osd";
-  version = "1.0.0-alpha.5.1";
+  version = "1.0.0-alpha.6";
 
   src = fetchFromGitHub {
     owner = "pop-os";
     repo = "cosmic-osd";
     tag = "epoch-${version}";
-    hash = "sha256-a5wzCHfp+dhtEkXsJOeEs2ZkmooSWIDGymeAdrXKE+U=";
+    hash = "sha256-ezOeRgqI/GOWFknUVZI7ZLEy1GYaBI+/An83HWKL6ho=";
   };
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-hJC0t8R+cdPWzdpxHA+j7en4IrhZXt5LM3S2V6/bps0=";
+  cargoHash = "sha256-vYehF2RjPrTZiuGcRUe4XX3ftRo7f+SIoKizD/kOtR8=";
 
   nativeBuildInputs = [ libcosmicAppHook ];
 

pkgs/by-name/fr/freetube/package.nix

···
 in
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "freetube";
-  version = "0.23.1";
+  version = "0.23.2";
 
   src = fetchFromGitHub {
     owner = "FreeTubeApp";
     repo = "FreeTube";
     tag = "v${finalAttrs.version}-beta";
-    hash = "sha256-I3C6gPPSTD/GzCoyyAxTfNEW83etJKJFb3uUKLUT79c=";
+    hash = "sha256-P0ENx8PDWbqfiBEsWv11R3Q/FE+rAFhhk49VyQgXIz4=";
   };
 
   # Darwin requires writable Electron dist
···
 
   yarnOfflineCache = fetchYarnDeps {
     yarnLock = "${finalAttrs.src}/yarn.lock";
-    hash = "sha256-oWDqar58vVoA6wdTpekwK/5xdro9YgNMxd1W0iT4hz8=";
+    hash = "sha256-U6H4TMKR+khs5fQtMtIBnHpAzJvHcvMeSD1XUqaov/M=";
   };
 
   nativeBuildInputs = [
···
       alyaeanyx
       ryand56
       sigmasquadron
+    ];
+    badPlatforms = [
+      # output app is called "Electron.app" while derivation expects "FreeTube.app"
+      #see: https://github.com/NixOS/nixpkgs/pull/384596#issuecomment-2677141349
+      lib.systems.inspect.patterns.isDarwin
     ];
     inherit (electron.meta) platforms;
     mainProgram = "freetube";

pkgs/by-name/ge/gemrb/package.nix

···
 {
   lib,
   stdenv,
+  runCommand,
   fetchFromGitHub,
   cmake,
+  pkg-config,
+  imagemagick,
+  gtest,
   SDL2,
   SDL2_mixer,
   freetype,
···
   openal,
   python3,
   zlib,
+  # the GLES backend on rpi is untested as I don't have the hardware
+  backend ? if stdenv.hostPlatform.isx86 then "OpenGL" else "GLES",
 }:
 
+# Previously we only used libvlc *on* darwin, which is incorrect. According to
+# https://github.com/gemrb/gemrb/blob/master/INSTALL it is needed for some mac versions of some
+# games but there is obviously nothing wrong using those on linux.
+# Additionally, when gemrb adds support for the EE games, libvlc will be needed anyway.
+
 let
-  # the GLES backend on rpi is untested as I don't have the hardware
-  backend = if stdenv.hostPlatform.isx86 then "OpenGL" else "GLES";
-
-  withVLC = stdenv.hostPlatform.isDarwin;
-
-  inherit (lib) optional optionalString;
-
-in
-stdenv.mkDerivation rec {
-  pname = "gemrb";
   version = "0.9.4";
 
   src = fetchFromGitHub {
···
     hash = "sha256-+aPnOJQGRblqcrblVU5ZwA8CZqeT19rxEtn3GLuofYU=";
   };
 
+  icons = runCommand "gemrb-icons" { nativeBuildInputs = [ imagemagick ]; } ''
+    for s in 48 64 96 128 256 512 1024; do
+      size=''${s}x''${s}
+      dir=$out/share/icons/hicolor/$size
+      mkdir -p $dir
+      magick -background none -size $size ${src}/artwork/logo04-rb_only.svg -format png $dir/gemrb.png
+    done
+  '';
+
+in
+stdenv.mkDerivation (finalAttrs: {
+  pname = "gemrb";
+  inherit version src;
+
   buildInputs = [
     SDL2
     SDL2_mixer
···
     libGL
     libiconv
     libpng
+    libvlc
     libvorbis
     openal
     python3
     zlib
-  ] ++ optional withVLC libvlc;
+  ];
 
-  nativeBuildInputs = [ cmake ];
-
-  # libvlc isn't being detected properly as of 0.9.0, so set it
-  LIBVLC_INCLUDE_PATH = optionalString withVLC "${lib.getDev libvlc}/include";
-  LIBVLC_LIBRARY_PATH = optionalString withVLC "${lib.getLib libvlc}/lib";
+  nativeBuildInputs = [
+    cmake
+    pkg-config
+  ] ++ lib.optionals (finalAttrs.doCheck or false) [ gtest ];
 
   cmakeFlags = [
-    "-DDATA_DIR=${placeholder "out"}/share/gemrb"
-    "-DEXAMPLE_CONF_DIR=${placeholder "out"}/share/doc/gemrb/examples"
-    "-DSYSCONF_DIR=/etc"
+    (lib.cmakeFeature "DATA_DIR" "${placeholder "out"}/share/gemrb")
+    (lib.cmakeFeature "EXAMPLE_CONF_DIR" "${placeholder "out"}/share/doc/gemrb/examples")
+    (lib.cmakeFeature "SYSCONF_DIR" "/etc")
     # use the Mesa drivers for video on ARM (harmless on x86)
-    "-DDISABLE_VIDEOCORE=ON"
-    "-DLAYOUT=opt"
-    "-DOPENGL_BACKEND=${backend}"
-    "-DOpenGL_GL_PREFERENCE=GLVND"
+    (lib.cmakeBool "DISABLE_VIDEOCORE" true)
+    (lib.cmakeFeature "LAYOUT" "opt")
+    (lib.cmakeFeature "OPENGL_BACKEND" backend)
+    (lib.cmakeFeature "OpenGL_GL_PREFERENCE" "GLVND")
+    (lib.cmakeBool "USE_TESTS" (finalAttrs.doCheck or false))
   ];
 
   postInstall = ''
-    for s in 36 48 72 96 144; do
-      install -Dm444 ../artwork/gemrb-logo-glow-''${s}px.png $out/share/icons/hicolor/''${s}x''${s}/gemrb.png
-    done
-    install -Dm444 ../artwork/gemrb-logo.png $out/share/icons/gemrb.png
+    cp -r ${icons}/share/icons $out/share/
   '';
+
+  # a bunch of tests fail in our sandbox
+  doCheck = false;
 
   meta = with lib; {
     description = "Reimplementation of the Infinity Engine, used by games such as Baldur's Gate";
···
     homepage = "https://gemrb.org/";
     license = licenses.gpl2Only;
     maintainers = with maintainers; [ peterhoeg ];
+    mainProgram = "gemrb";
   };
-}
+})

pkgs/by-name/go/gost/package.nix

···
 {
   lib,
+  stdenv,
   fetchFromGitHub,
   buildGoModule,
-  fetchpatch,
+  versionCheckHook,
 }:
 
 buildGoModule rec {
   pname = "gost";
-  version = "2.11.5-unstable-2024-02-02";
+  version = "2.12.0";
 
   src = fetchFromGitHub {
     owner = "ginuerzh";
     repo = "gost";
-    rev = "fd57e80709aba9581757b1cd63b7d8f75e2385d2";
-    sha256 = "sha256-GkXsiUcH5hppgkkt4ddVMLm5riUDORVhjWBGHZXti5A=";
+    tag = "v${version}";
+    hash = "sha256-kNhWJiPF6DlxxVZvW7HJkvzSuGsrozZBhiVaw+a7mYs=";
   };
 
-  patches = [
-    # Bump quic-go to v0.41.0 for go 1.22 compatibility.
-    (fetchpatch {
-      url = "https://github.com/ginuerzh/gost/pull/1016/commits/c2e3f7e493bbb6ff1bc348f36e1a148d9d0c16ad.patch";
-      hash = "sha256-9OtuPIzzCymMAVbrDuhhPcxcac69gjAUm4ykXbH/pbo=";
-    })
-  ];
-
-  vendorHash = "sha256-mq95eHyW8XkqyLApSqVB3bv5VFSu6FuPap/mTQj8a9M=";
+  vendorHash = "sha256-7Wmd82sSMVAo1cGUi1EIig8h5drgy85D9FmSNtIBRqY=";
 
   postPatch = ''
     substituteInPlace http2_test.go \
-      --replace "TestH2CForwardTunnel" "SkipH2CForwardTunnel" \
-      --replace "TestH2ForwardTunnel" "SkipH2ForwardTunnel"
+      --replace-fail "TestH2CForwardTunnel" "SkipH2CForwardTunnel" \
+      --replace-fail "TestH2ForwardTunnel" "SkipH2ForwardTunnel"
 
     substituteInPlace resolver_test.go \
-      --replace '{NameServer{Addr: "1.1.1.1"}, "github", true},' "" \
-      --replace '{NameServer{Addr: "1.1.1.1"}, "github.com", true},' "" \
-      --replace '{NameServer{Addr: "1.1.1.1:53"}, "github.com", true},' "" \
-      --replace '{NameServer{Addr: "1.1.1.1:53", Protocol: "tcp"}, "github.com", true},' "" \
-      --replace '{NameServer{Addr: "1.1.1.1:853", Protocol: "tls"}, "github.com", true},' "" \
-      --replace '{NameServer{Addr: "1.1.1.1:853", Protocol: "tls", Hostname: "cloudflare-dns.com"}, "github.com", true},' "" \
-      --replace '{NameServer{Addr: "https://cloudflare-dns.com/dns-query", Protocol: "https"}, "github.com", true},' "" \
-      --replace '{NameServer{Addr: "https://1.0.0.1/dns-query", Protocol: "https"}, "github.com", true},' ""
+      --replace-fail '{NameServer{Addr: "1.1.1.1"}, "github", true},' "" \
+      --replace-fail '{NameServer{Addr: "1.1.1.1"}, "github.com", true},' "" \
+      --replace-fail '{NameServer{Addr: "1.1.1.1:53"}, "github.com", true},' "" \
+      --replace-fail '{NameServer{Addr: "1.1.1.1:53", Protocol: "tcp"}, "github.com", true},' "" \
+      --replace-fail '{NameServer{Addr: "1.1.1.1:853", Protocol: "tls"}, "github.com", true},' "" \
+      --replace-fail '{NameServer{Addr: "1.1.1.1:853", Protocol: "tls", Hostname: "cloudflare-dns.com"}, "github.com", true},' "" \
+      --replace-fail '{NameServer{Addr: "https://cloudflare-dns.com/dns-query", Protocol: "https"}, "github.com", true},' "" \
+      --replace-fail '{NameServer{Addr: "https://1.0.0.1/dns-query", Protocol: "https"}, "github.com", true},' ""
 
     # Skip TestShadowTCP, TestShadowUDP: #70 #71 #72 #78 #83 #85 #86 #87 #93
     substituteInPlace ss_test.go \
-      --replace '{url.User("xchacha20"), url.UserPassword("xchacha20", "123456"), false},' "" \
-      --replace '{url.UserPassword("xchacha20", "123456"), url.User("xchacha20"), false},' "" \
-      --replace '{url.UserPassword("xchacha20", "123456"), url.UserPassword("xchacha20", "abc"), false},' "" \
-      --replace '{url.UserPassword("CHACHA20-IETF-POLY1305", "123456"), url.UserPassword("CHACHA20-IETF-POLY1305", "123456"), true},' "" \
-      --replace '{url.UserPassword("AES-128-GCM", "123456"), url.UserPassword("AES-128-GCM", "123456"), true},' "" \
-      --replace '{url.User("AES-192-GCM"), url.UserPassword("AES-192-GCM", "123456"), false},' "" \
-      --replace '{url.UserPassword("AES-192-GCM", "123456"), url.User("AES-192-GCM"), false},' "" \
-      --replace '{url.UserPassword("AES-192-GCM", "123456"), url.UserPassword("AES-192-GCM", "abc"), false},' "" \
-      --replace '{url.UserPassword("AES-256-GCM", "123456"), url.UserPassword("AES-256-GCM", "123456"), true},' ""
+      --replace-fail '{url.User("xchacha20"), url.UserPassword("xchacha20", "123456"), false},' "" \
+      --replace-fail '{url.UserPassword("xchacha20", "123456"), url.User("xchacha20"), false},' "" \
+      --replace-fail '{url.UserPassword("xchacha20", "123456"), url.UserPassword("xchacha20", "abc"), false},' "" \
+      --replace-fail '{url.UserPassword("CHACHA20-IETF-POLY1305", "123456"), url.UserPassword("CHACHA20-IETF-POLY1305", "123456"), true},' "" \
+      --replace-fail '{url.UserPassword("AES-128-GCM", "123456"), url.UserPassword("AES-128-GCM", "123456"), true},' "" \
+      --replace-fail '{url.User("AES-192-GCM"), url.UserPassword("AES-192-GCM", "123456"), false},' "" \
+      --replace-fail '{url.UserPassword("AES-192-GCM", "123456"), url.User("AES-192-GCM"), false},' "" \
+      --replace-fail '{url.UserPassword("AES-192-GCM", "123456"), url.UserPassword("AES-192-GCM", "abc"), false},' "" \
+      --replace-fail '{url.UserPassword("AES-256-GCM", "123456"), url.UserPassword("AES-256-GCM", "123456"), true},' ""
   '';
 
   __darwinAllowLocalNetworking = true;
 
-  meta = with lib; {
+  # i/o timeout
+  doCheck = !stdenv.hostPlatform.isDarwin;
+
+  doInstallCheck = true;
+
+  nativeInstallCheckInputs = [ versionCheckHook ];
+
+  versionCheckProgramArg = "-V";
+
+  meta = {
     description = "Simple tunnel written in golang";
     homepage = "https://github.com/ginuerzh/gost";
-    license = licenses.mit;
-    maintainers = with maintainers; [ pmy ];
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ pmy ];
     mainProgram = "gost";
   };
 }

pkgs/by-name/gq/gqlgenc/package.nix

···
 
 buildGoModule rec {
   pname = "gqlgenc";
-  version = "0.30.3";
+  version = "0.31.0";
 
   src = fetchFromGitHub {
     owner = "yamashou";
     repo = "gqlgenc";
     rev = "v${version}";
-    sha256 = "sha256-NYH05VppoIjxOzMP6aBBtZLxf8cj1kdzS+5NKtIDcik=";
+    sha256 = "sha256-RGHfDrFr2HO4i+YQeNzYrEcU+Xe286f3f5g/yUmpxpA=";
   };
 
   excludedPackages = [ "example" ];

pkgs/by-name/hd/hdrop/package.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "hdrop";
-  version = "0.7.5";
+  version = "0.7.6";
 
   src = fetchFromGitHub {
     owner = "Schweber";
     repo = "hdrop";
     rev = "v${version}";
-    hash = "sha256-TKSiwpoc1RSct8JzLHeM5SZaIT8fQUmAmY45OKbvQ9E=";
+    hash = "sha256-kJ+xjxd8MAuwzARCgN6qLeetwLxRzhmip1Z4U4IfqmY=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/ku/kubefirst/package.nix

···
 
 buildGoModule rec {
   pname = "kubefirst";
-  version = "2.8.1";
+  version = "2.8.4";
 
   src = fetchFromGitHub {
     owner = "konstructio";
     repo = "kubefirst";
     tag = "v${version}";
-    hash = "sha256-dNHHanoPR+U7WvjDSfEWOYbZAcWjt4fla8jMZAahJaE=";
+    hash = "sha256-5A5luRvUr5qBua6Jw5/SJqIHLZfEpkXFoqxTnpUjlas=";
   };
 
-  vendorHash = "sha256-tpg36+yiXAl2WD3JlfN9tPrTKk9B5aRpcx6dCAJNf70=";
+  vendorHash = "sha256-1u34cuPUY/5fYd073UhRUu/5/1nhPadTI06+3o+uE7w=";
 
   ldflags = [
     "-s"

pkgs/by-name/kv/kvazaar/package.nix

···
 {
   lib,
   stdenv,
-  fetchpatch,
   fetchFromGitHub,
   gitUpdater,
   testers,

pkgs/by-name/li/libmtp/package.nix

···
   autoconf,
   automake,
   fetchFromGitHub,
-  fetchpatch,
   gettext,
   lib,
   libiconv,
···
 
 stdenv.mkDerivation rec {
   pname = "libmtp";
-  version = "1.1.21";
+  version = "1.1.22";
 
   src = fetchFromGitHub {
     owner = "libmtp";
     repo = "libmtp";
     rev = "libmtp-${builtins.replaceStrings [ "." ] [ "-" ] version}";
-    sha256 = "sha256-m9QFVD8udQ3SdGwn276BnIKqGeATA5QuokOK29Ykc1k=";
+    sha256 = "sha256-hIH6W8qQ6DB4ST7SlFz6CCnLsEGOWgmUb9HoHMNA3wY=";
   };
-
-  patches = [
-    # Backport cross fix.
-    (fetchpatch {
-      url = "https://github.com/libmtp/libmtp/commit/467fa26e6b14c0884b15cf6d191de97e5513fe05.patch";
-      sha256 = "2DrRrdcguJ9su4LxtT6YOjer8gUTxIoHVpk+6M9P4cg=";
-    })
-  ];
 
   outputs = [
     "bin"

pkgs/by-name/li/libqalculate/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "libqalculate";
-  version = "5.5.0";
+  version = "5.5.1";
 
   src = fetchFromGitHub {
     owner = "qalculate";
     repo = "libqalculate";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-lyewx2dc8EywDvLnOkbrys5ObMR7BkEppN/cpWHPBbg=";
+    hash = "sha256-bx0a64EyF6/QzpQ6acgs4VO61Mvv1a/VXJyUQ7ksdxI=";
   };
 
   outputs = [

pkgs/by-name/np/npm-check-updates/package.nix

···
 
 buildNpmPackage rec {
   pname = "npm-check-updates";
-  version = "17.1.14";
+  version = "17.1.15";
 
   src = fetchFromGitHub {
     owner = "raineorshine";
     repo = "npm-check-updates";
     rev = "refs/tags/v${version}";
-    hash = "sha256-PIaT5Wg+jEd4NPlLVQKnJ429489ZSQPagCc/+h2EFrI=";
+    hash = "sha256-NewFg7eKhBMgMrjLQ1/n+CytcOZEaMMr/PNgA57Irw8=";
   };
 
-  npmDepsHash = "sha256-k/TBMdOyTjVBir5wIujMPHa+2FRvzORX7dXpLrMhTqY=";
+  npmDepsHash = "sha256-qF3p+P+CJvpDhx0ddPnz6A7N9yC9+6uXWQCWFo9k30c=";
 
   postPatch = ''
     sed -i '/"prepare"/d' package.json

pkgs/by-name/po/portfolio/package.nix

···
 in
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "PortfolioPerformance";
-  version = "0.74.0";
+  version = "0.74.1";
 
   src = fetchurl {
     url = "https://github.com/buchen/portfolio/releases/download/${finalAttrs.version}/PortfolioPerformance-${finalAttrs.version}-linux.gtk.x86_64.tar.gz";
-    hash = "sha256-RP+5mUoE7L+koS5AvI2J+H/7093+yAy9KXfgWedKAGQ=";
+    hash = "sha256-KV+I2e1I1ZvyvNpTKpKt/l+rQ/HIcZuQ8gwVbnoahmA=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/qa/qalculate-gtk/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "qalculate-gtk";
-  version = "5.5.0";
+  version = "5.5.1";
 
   src = fetchFromGitHub {
     owner = "qalculate";
     repo = "qalculate-gtk";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-9/fj+dwnEpbfcqBDQowhU4ltr/h43NQYTMUQnLL4Ut8=";
+    hash = "sha256-9KXzsMGSdi+nh5x7ehVHLi7Ni+iK+sFpsacj5ByU7M4=";
   };
 
   hardeningDisable = [ "format" ];

pkgs/by-name/qa/qalculate-qt/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "qalculate-qt";
-  version = "5.5.0";
+  version = "5.5.1";
 
   src = fetchFromGitHub {
     owner = "qalculate";
     repo = "qalculate-qt";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-IfdD3Nk+feLnILgEpccjEBlWfcW8ps7U+V7pTRG3LwM=";
+    hash = "sha256-mk1K+xekyusW17iH7Ecgd9VKCDCu5H2dTG0rtTctTeU=";
   };
 
   nativeBuildInputs = with qt6; [

pkgs/by-name/re/recaf-launcher/package.nix

···
+{
+  lib,
+  stdenv,
+  fetchurl,
+  buildFHSEnv,
+}:
+let
+  version = "0.8.1";
+  jar = fetchurl {
+    url = "https://github.com/Col-E/Recaf-Launcher/releases/download/${version}/recaf-gui-${version}.jar";
+    hash = "sha256-RHsI8z/orwR9b9s+LrrOHpxpr82J6YOpnfik3dnlsvI=";
+  };
+in
+buildFHSEnv {
+  pname = "recaf-launcher";
+  inherit version;
+
+  targetPkgs =
+    p: with p; [
+      jar
+
+      openjdk23
+      xorg.libX11
+      at-spi2-atk
+      cairo
+      gdk-pixbuf
+      glib
+      gtk3
+      pango
+      xorg.libXtst
+      xorg.libX11
+      xorg_sys_opengl
+    ];
+
+  runScript = "java -jar ${jar}";
+
+  meta = {
+    description = "Simple launcher for Recaf 4.X and above - a modern Java bytecode editor";
+    homepage = "https://recaf.coley.software";
+    changelog = "https://github.com/Col-E/Recaf-Launcher/releases/tag/${version}/CHANGELOG.md";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ tudbut ];
+    mainProgram = "recaf-launcher";
+    sourceProvenance = [ lib.sourceTypes.binaryBytecode ];
+  };
+}

pkgs/by-name/re/repomix/package.nix

···
 
 buildNpmPackage rec {
   pname = "repomix";
-  version = "0.2.25";
+  version = "0.2.29";
 
   src = fetchFromGitHub {
     owner = "yamadashy";
     repo = "repomix";
     tag = "v${version}";
-    hash = "sha256-Iuf2BJjJGYLw8J2UQzbAK50BZPaMa/3E3gXswWVRxn0=";
+    hash = "sha256-AOqGmI5hnDA18/+uFGQwVKdLniOvGMEBKHTZJa5gE2w=";
   };
 
-  npmDepsHash = "sha256-p/8/8o0BiHBsBaMtduEd1z6HYi3TerU6wuzOTq3oitg=";
+  npmDepsHash = "sha256-R/NTlU5ljwmoGHB/5wPADkGx8xjfF4d2bPWWkAr+VOk=";
 
   nativeInstallCheckInputs = [ versionCheckHook ];
   doInstallCheck = true;

pkgs/by-name/te/terragrunt/package.nix

···
 
 buildGoModule rec {
   pname = "terragrunt";
-  version = "0.73.5";
+  version = "0.73.12";
 
   src = fetchFromGitHub {
     owner = "gruntwork-io";
     repo = pname;
     tag = "v${version}";
-    hash = "sha256-0I2lMu2RyZ6F5GosWome6uzedllN3qn6smupZLbNuBg=";
+    hash = "sha256-nuqulBONUMY0BNh5uhhRGJruZdnkY05dd7zcX4t0MjE=";
   };
 
   nativeBuildInputs = [ go-mockery ];
···
     make generate-mocks
   '';
 
-  vendorHash = "sha256-q8HCRPD1PUchtktcs3+5GM2zMaEBy348d+6fMLJR1uk=";
+  vendorHash = "sha256-EO3zgqVqf994xB55twRmcGBQdffrNr2BejNq2jlkMSA=";
 
   doCheck = false;
 

pkgs/by-name/tr/trezor-suite/package.nix

···
   stdenv,
   fetchurl,
   appimageTools,
+  makeWrapper,
   tor,
   trezord,
 }:
 
 let
   pname = "trezor-suite";
-  version = "24.12.3";
+  version = "25.2.2";
 
   suffix =
     {
···
     hash =
       {
         # curl -Lfs https://github.com/trezor/trezor-suite/releases/download/v${version}/latest-linux{-arm64,}.yml | grep ^sha512 | sed 's/: /-/'
-        aarch64-linux = "sha512-erNWQTaj/WWoqy3TO7wb+ijQkwXjqfCjqvQN6/9gCVjbHswURWHX36P0rJg9vuQu6odi5EKtooDusIxjIUkQzA==";
-        x86_64-linux = "sha512-Zd+Ou3YUymlKr5lOTdWEZVdCbz3cIJx3Ho65AGDUXkNXfOrCc0v9faE8Np/9TkpJDWWqjjUoTJkkvsbapiMOOQ==";
+        aarch64-linux = "sha512-9EWbYju0e3DdS8bnuMiD4Cdodz/LxbLyCItNEWSIi/UADxtH7smAbpAu4Awcgbb3o39x94Mf8rbqcxmIktDDhQ==";
+        x86_64-linux = "sha512-j8TI46Jr/Tc99Ri3aFY0z73HFY5AWpeAv/yJy8xsV8rNGWEwKlCvJzkrEUpvpFUBMoHgGw3PTQ7CYUQ5bmB/CA==";
       }
       .${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");
   };
 
-  appimageContents = appimageTools.extractType2 {
+  appimageContents = appimageTools.extract {
     inherit pname version src;
   };
 
···
 appimageTools.wrapType2 rec {
   inherit pname version src;
 
+  nativeBuildInputs = [ makeWrapper ];
+
   extraInstallCommands = ''
     mkdir -p $out/bin $out/share/${pname} $out/share/${pname}/resources
 
···
     cp -a ${appimageContents}/resources/app*.* $out/share/${pname}/resources
     cp -a ${appimageContents}/resources/images/ $out/share/${pname}/resources
 
+    wrapProgram $out/bin/trezor-suite \
+        --add-flags "\''${NIXOS_OZONE_WL:+\''${WAYLAND_DISPLAY:+--ozone-platform-hint=auto --enable-features=WaylandWindowDecorations --enable-wayland-ime=true}}"
+
     install -m 444 -D ${appimageContents}/${pname}.desktop $out/share/applications/${pname}.desktop
     install -m 444 -D ${appimageContents}/resources/images/desktop/512x512.png $out/share/icons/hicolor/512x512/apps/${pname}.png
     substituteInPlace $out/share/applications/${pname}.desktop \
···
     ln -sf ${trezord}/bin/trezord-go $out/share/${pname}/resources/bin/bridge/trezord
     ln -sf ${tor}/bin/tor $out/share/${pname}/resources/bin/tor/tor
   '';
+
+  passthru.updateScript = ./update.sh;
 
   meta = with lib; {
     description = "Trezor Suite - Desktop App for managing crypto";

pkgs/by-name/tr/trezor-suite/update.sh

···
+#!/usr/bin/env nix-shell
+#!nix-shell -i bash -p curl yq
+set -eu -o pipefail
+
+target="$(dirname "$(readlink -f "$0")")/package.nix"
+host="https://data.trezor.io"
+metadata_aarch64=$(curl "$host/suite/releases/desktop/latest/latest-linux-arm64.yml")
+metadata_x64=$(curl "$host/suite/releases/desktop/latest/latest-linux.yml")
+hash_aarch64=$(echo "$metadata_aarch64" | yq .sha512 -r)
+hash_x64=$(echo "$metadata_x64" | yq .sha512 -r)
+version=$(echo "$metadata_x64" | yq .version -r)
+
+sed -i "s@version = .*;@version = \"$version\";@g" "$target"
+sed -i "s@aarch64-linux = \"sha512.*@aarch64-linux = \"sha512-$hash_aarch64\";@" "$target"
+sed -i "s@x86_64-linux = \"sha512.*@x86_64-linux = \"sha512-$hash_x64\";@" "$target"

pkgs/by-name/yo/youki/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "youki";
-  version = "0.5.0";
+  version = "0.5.1";
 
   src = fetchFromGitHub {
     owner = "containers";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-UKdl6+NHDriQYDgZzdWnH07xneLB/40tpCKhaRhzriA=";
+    hash = "sha256-cybh83mbTG5V1vb5WDWh0uozJa3fha2ciTGMvHOaEQk=";
   };
 
   nativeBuildInputs = [
···
   ];
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-JI37KtuWLhFiusQTqKy2DpSdgTY4jNuzsEkoyhLPieI=";
+  cargoHash = "sha256-7kiQNiOJrn1wQorzSXLcwTZLAImPw2SFOdteG9hibZ0=";
 
   meta = with lib; {
     description = "Container runtime written in Rust";

pkgs/by-name/yt/ytdl-sub/package.nix

···
 }:
 python3Packages.buildPythonApplication rec {
   pname = "ytdl-sub";
-  version = "2025.02.17";
+  version = "2025.02.21";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "jmbannon";
     repo = "ytdl-sub";
     tag = version;
-    hash = "sha256-YCzA6M3X+LF8AvTk/JcmomxOkpgTKy+/xXYJuTRXLRo=";
+    hash = "sha256-TRq4sJowCi8CsZP859eJt2NWTDs2LN+2sG3y2s7UDA0=";
   };
 
   postPatch = ''

pkgs/by-name/za/zap-chip/package.nix

···
 {
   lib,
   buildNpmPackage,
-  electron_31,
+  electron,
   fetchFromGitHub,
   writers,
   makeWrapper,
   withGui ? false,
 }:
 
-let
-  electron = electron_31;
-in
 buildNpmPackage rec {
   pname = "zap-chip";
   version = "2024.09.27";

pkgs/development/compilers/flutter/versions/3_27/data.json

···
   "engineSwiftShaderHash": "sha256-mRLCvhNkmHz7Rv6GzXkY7OB1opBSq+ATWZ466qZdgto=",
   "engineSwiftShaderRev": "2fa7e9b99ae4e70ea5ae2cc9c8d3afb43391384f",
   "channel": "stable",
-  "engineHashes": {},
+  "engineHashes": {
+    "aarch64-linux": {
+      "aarch64-linux": "sha256-Av8G5i4g9s6SrOpLUIw9WOSJ4hMQO+ANIaTIVpTsP+Y=",
+      "x86_64-linux": "sha256-Av8G5i4g9s6SrOpLUIw9WOSJ4hMQO+ANIaTIVpTsP+Y="
+    },
+    "x86_64-linux": {
+      "aarch64-linux": "sha256-PDSA0B/6mZTLC5gRlR8F6+p8V5dKmM7OALjehrPlQ1g=",
+      "x86_64-linux": "sha256-PDSA0B/6mZTLC5gRlR8F6+p8V5dKmM7OALjehrPlQ1g="
+    }
+  },
   "dartVersion": "3.6.2",
   "dartHash": {
     "x86_64-linux": "sha256-um3/S/XleAVGor8YVUIjhViDAXUiSKnJI7RchM9k1yc=",

pkgs/development/coq-modules/fourcolor/default.nix

···
   mkCoqDerivation,
   coq,
   mathcomp,
-  stdlib,
   version ? null,
 }:
 
···
     mathcomp.algebra
     mathcomp.ssreflect
     mathcomp.fingroup
-    stdlib
   ];
 
   meta = with lib; {

pkgs/development/coq-modules/hierarchy-builder/default.nix

···
    else
    { installFlags = [ "VFILES=structures.v" ] ++ o.installFlags; })
   //
-  lib.optionalAttrs (lib.versions.isLe "1.8.1" o.version)
+  lib.optionalAttrs (o.version != null && o.version == "1.8.1")
     { propagatedBuildInputs = o.propagatedBuildInputs ++ [ stdlib ]; }
 )

pkgs/development/coq-modules/jasmin/default.nix

···
   mkCoqDerivation,
   coq,
   mathcomp,
+  mathcomp-algebra-tactics,
   mathcomp-word,
   version ? null,
 }:
···
   release."2024.07.2".sha256 = "sha256-aF8SYY5jRxQ6iEr7t6mRN3BEmIDhJ53PGhuZiJGB+i8=";
 
   propagatedBuildInputs = [
+    mathcomp-algebra-tactics
     mathcomp-word
   ];
 

pkgs/development/coq-modules/mathcomp-analysis/default.nix

···
   mathcomp-finmap,
   mathcomp-bigenough,
   hierarchy-builder,
+  stdlib,
   single ? false,
   coqPackages,
   coq,
···
       ];
       intra-deps = lib.optionals (package != "single") (map mathcomp_ packages.${package});
       pkgpath = lib.switch package [
-        {
-          case = "single";
-          out = ".";
-        }
-        {
-          case = "analysis";
-          out = "theories";
-        }
-        {
-          case = "experimental-reals";
-          out = "experimental_reals";
-        }
-        {
-          case = "reals-stdlib";
-          out = "reals_stdlib";
-        }
-        {
-          case = "analysis-stdlib";
-          out = "analysis_stdlib";
-        }
+        { case = "single"; out = "."; }
+        { case = "analysis"; out = "theories"; }
+        { case = "experimental-reals"; out = "experimental_reals"; }
+        { case = "reals-stdlib"; out = "reals_stdlib"; }
+        { case = "analysis-stdlib"; out = "analysis_stdlib"; }
       ] package;
       pname = if package == "single" then "mathcomp-analysis-single" else "mathcomp-${package}";
       derivation = mkCoqDerivation ({
···
           ++ lib.optionals (lib.elem package [
             "analysis"
             "single"
-          ]) analysis-deps;
+          ]) analysis-deps
+          ++ lib.optional (lib.elem package [
+            "reals-stdlib"
+            "analysis-stdlib"
+            "single"
+          ]) stdlib;
 
         preBuild = ''
           cd ${pkgpath}

pkgs/development/coq-modules/mathcomp-finmap/default.nix

···
   coq,
   mkCoqDerivation,
   mathcomp,
-  stdlib,
   lib,
   version ? null,
 }:
···
     "1.0.0".sha256 = "0sah7k9qm8sw17cgd02f0x84hki8vj8kdz7h15i7rmz08rj0whpa";
   };
 
-  propagatedBuildInputs = [ mathcomp.ssreflect stdlib ];
+  propagatedBuildInputs = [ mathcomp.ssreflect ];
 
   meta = {
     description = "Finset and finmap library";

pkgs/development/coq-modules/mathcomp-real-closed/default.nix

···
   mkCoqDerivation,
   mathcomp,
   mathcomp-bigenough,
-  stdlib,
   lib,
   version ? null,
 }:
···
     mathcomp.fingroup
     mathcomp.solvable
     mathcomp-bigenough
-    stdlib
   ];
 
   meta = {

pkgs/development/coq-modules/mathcomp-tarjan/default.nix

···
   mkCoqDerivation,
   mathcomp-ssreflect,
   mathcomp-fingroup,
-  stdlib,
   lib,
   version ? null,
 }@args:
···
   propagatedBuildInputs = [
     mathcomp-ssreflect
     mathcomp-fingroup
-    stdlib
   ];
 
   meta = {

pkgs/development/coq-modules/mathcomp-word/default.nix

···
   coq,
   mkCoqDerivation,
   mathcomp,
+  stdlib,
   lib,
   version ? null,
 }:
···
     mathcomp.algebra
     mathcomp.ssreflect
     mathcomp.fingroup
+    stdlib
   ];
 
   meta = with lib; {

pkgs/development/coq-modules/mathcomp/default.nix

···
         mlPlugin = lib.versions.isLe "8.6" coq.coq-version;
         nativeBuildInputs = lib.optionals withDoc [ graphviz lua ];
         buildInputs = [ ncurses ];
-        propagatedBuildInputs = [ stdlib ] ++ mathcomp-deps;
+        propagatedBuildInputs = mathcomp-deps;
 
         buildFlags = lib.optional withDoc "doc";
 
···
       }
     );
     patched-derivation4 = patched-derivation3.overrideAttrs (o:
-      lib.optionalAttrs (o.version != null
-        && lib.versions.isLe "2.3.0" o.version)
+      lib.optionalAttrs (o.version != null && o.version == "2.3.0")
       {
         propagatedBuildInputs = o.propagatedBuildInputs ++ [ stdlib ];
       }

pkgs/development/coq-modules/odd-order/default.nix

···
   lib,
   mkCoqDerivation,
   mathcomp,
-  stdlib,
   version ? null,
 }:
 
···
     mathcomp.solvable
     mathcomp.field
     mathcomp.all
-    stdlib
   ];
 
   meta = with lib; {

pkgs/development/cuda-modules/cuda/extension.nix

···
     "12.0" = "12.0.1";
     "12.1" = "12.1.1";
     "12.2" = "12.2.2";
-    "12.3" = "12.3.0";
+    "12.3" = "12.3.2";
     "12.4" = "12.4.0";
-    "12.6" = "12.6.0";
+    "12.5" = "12.5.1";
+    "12.6" = "12.6.3";
     "12.8" = "12.8.0";
   };
 

pkgs/development/cuda-modules/cuda/manifests/feature_12.5.1.json

···
+{
+  "cuda_cccl": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_compat": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_cudart": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_cuobjdump": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_cupti": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": true,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": true,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": true,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": true,
+        "static": false
+      }
+    }
+  },
+  "cuda_cuxxfilt": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_demo_suite": {
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_documentation": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_gdb": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_nsight": {
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_nvcc": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_nvdisasm": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_nvml_dev": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_nvprof": {
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_nvprune": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_nvrtc": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_nvtx": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_nvvp": {
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_opencl": {
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_profiler_api": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "cuda_sanitizer_api": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "fabricmanager": {
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "imex": {
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libcublas": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libcudla": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libcufft": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libcufile": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    }
+  },
+  "libcurand": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libcusolver": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libcusparse": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libnpp": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libnvfatbin": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libnvidia_nscq": {
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libnvjitlink": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "libnvjpeg": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": true,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": true
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": true,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "nsight_compute": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "nsight_systems": {
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "nsight_vse": {
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "nvidia_driver": {
+    "linux-sbsa": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": true,
+        "dev": false,
+        "doc": false,
+        "lib": true,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "nvidia_fs": {
+    "linux-aarch64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-sbsa": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    },
+    "linux-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  },
+  "visual_studio_integration": {
+    "windows-x86_64": {
+      "outputs": {
+        "bin": false,
+        "dev": false,
+        "doc": false,
+        "lib": false,
+        "sample": false,
+        "static": false
+      }
+    }
+  }
+}

pkgs/development/cuda-modules/cuda/manifests/redistrib_12.3.0.json

···
-{
-    "release_date": "2023-10-19",
-    "release_label": "12.3.0",
-    "release_product": "cuda",
-    "cuda_cccl": {
-        "name": "CXX Core Compute Libraries",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_cccl/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "659f8f8fd58eb7f5bc8ba171712147a007a2c8c92f30b21d135cf2d12f80226d",
-            "md5": "e97f283762e4cc26a91368b545445888",
-            "size": "1148140"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_cccl/linux-ppc64le/cuda_cccl-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "1a188bc279ba32d910259bdf9b7106accacba163ce9ef92989af18ca8a50a6ea",
-            "md5": "a2c10d1037efe99ff2bd840a552500a0",
-            "size": "1148584"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "96b5465af73b77447c3997d923916f7aea0939ffd0d8be42bc197ee8d8965fca",
-            "md5": "7b33cb50efd7d589bc1da8fd292179b6",
-            "size": "1147616"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "074c26ca05bd305ee23fdc56c3e8115d21c7843c5778fb75052791d66ee73711",
-            "md5": "ac1857b6c543c5489c126fb6a1ef0b10",
-            "size": "3041533"
-        }
-    },
-    "cuda_cudart": {
-        "name": "CUDA Runtime (cudart)",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_cudart/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "0dcd864fcef10b7d4591cc545330c411f589b27b12c98c30ac6e3d5e14eb2ee4",
-            "md5": "d0857c0c2b568ca05aac12dc67a6871b",
-            "size": "1090372"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_cudart/linux-ppc64le/cuda_cudart-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "354d1ffdd1ce2da61ec2c3fb1b15cdf65270804aba78863d235cc0d69a9c9eec",
-            "md5": "8abeb75f2d60efe9f69eb3ae3266ae45",
-            "size": "1068716"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "4789a039df340581d7a71f5da6af9f222baa2265e8de8ce00365a31ac645adca",
-            "md5": "abe7432e966b61c9d6272ef5f0d889f0",
-            "size": "1079100"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "a01396eeb88b52137dd1878e1278a1608f848194a1bb7faa02d6b147894d17a9",
-            "md5": "5731383d0884a47d93e52772c0815042",
-            "size": "2462899"
-        }
-    },
-    "cuda_cuobjdump": {
-        "name": "cuobjdump",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_cuobjdump/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "cfedfd2e64aedec65793240c2814bc94463eaafe508bb34776b5d7bee783c899",
-            "md5": "9de85c598e48234db4ec743b2984205a",
-            "size": "171908"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_cuobjdump/linux-ppc64le/cuda_cuobjdump-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "33bbf67fbf5cfa5e1a451c3325330fc032a0e58ed31748839993ecb94711a9a0",
-            "md5": "d628a4c6ae76e52cec8bcb976a30edea",
-            "size": "215840"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "cce91131e57a901463ce1dc86577fe67db0bf6a17f8aefe3e269fff98689151d",
-            "md5": "c390408c5973d68eb7d292678dc201b8",
-            "size": "181628"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "90f583b64f97bd600d0f6d81026bee6cfd2712d5b4905d238b0b6ab21a0709c3",
-            "md5": "f789a23aa0fe7e38f5c874be8612502f",
-            "size": "4013028"
-        }
-    },
-    "cuda_cupti": {
-        "name": "CUPTI",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_cupti/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "f51ae93f02378d88b5f53b66abad675f0b2e8b4444192b4705a550b1d083de79",
-            "md5": "2ad99522a4e6a6aab309fb44b611e607",
-            "size": "19651160"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_cupti/linux-ppc64le/cuda_cupti-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "8dead100bec1dd9b02f56e34dfeae91381422cbf858ce1c9fd1a45fdde946a16",
-            "md5": "dbc7e027e4e2f1d9f2a59db6ec20b2f0",
-            "size": "10918684"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "39f07116b64d8b3b9bf17c65c45d97bf19886eb41847e30c6606751455cbb284",
-            "md5": "c701206a376dab8f82aae89c9d3d4085",
-            "size": "10086868"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "c177c59124f4ae41d46950999548931905f6097de57f88df7d2af62dffbdf249",
-            "md5": "4402839a83f9daed16007ba93fa528ec",
-            "size": "13149248"
-        }
-    },
-    "cuda_cuxxfilt": {
-        "name": "CUDA cuxxfilt (demangler)",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_cuxxfilt/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "932ef5f2f607b5fcb5a84b4489d562cd1239ef7cebfaf862070f9953d02e6cce",
-            "md5": "b1d37d6dd3a6f6218b73c8310cafbd12",
-            "size": "188368"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_cuxxfilt/linux-ppc64le/cuda_cuxxfilt-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "dc0490f0881ee51f803bfcd93fcd448216776fa347712d43823c09e687f013b1",
-            "md5": "7eadb41329c74d76212f2e830232e854",
-            "size": "180568"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "5a9c4d613a8120b21c1f44a9e48f2908bd429e2059f8aaabf4cb67bd5c468e04",
-            "md5": "755a801e5f34f090bda0139f32432e21",
-            "size": "174576"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "d7b94c8fa3198764e0664709543a9ee5820a004df9afa70af69c84d2cfca5bc4",
-            "md5": "ad52248ba90cc66a4f73e1914ef3b090",
-            "size": "170310"
-        }
-    },
-    "cuda_demo_suite": {
-        "name": "CUDA Demo Suite",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_demo_suite/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "ed9dd4e1b5fad1c21cfdab9df2d9c80c6360513f4ebd4dd1bc71d518c0a5f2d2",
-            "md5": "a18e17098bfc19e966e36152c7417b01",
-            "size": "4000328"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "a93c7712d3b2782964172c1677868684a4145f8bc8cb18b9173e4abb640ee353",
-            "md5": "17adbdccd94580c1b821ed6ea9a856cf",
-            "size": "5061022"
-        }
-    },
-    "cuda_documentation": {
-        "name": "CUDA Documentation",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_documentation/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "b2bea4ca04808c88fc34ce3da98457f789f6087effe9c12ec5c7cadc583f8c2e",
-            "md5": "6c898f430b8cc9f89c3acc2ecb3587c7",
-            "size": "67052"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_documentation/linux-ppc64le/cuda_documentation-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "ac53d750359c4c0bf92111ee46c0dc4ffc4e78c480e8319c48c6097697712847",
-            "md5": "870aa50e6b0d5627e44152dbbe28d100",
-            "size": "67156"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "2e95ef6bee1b78068d6a8a854effec0e31aed07cf6d81f48021cee213fd01c26",
-            "md5": "076cebe3b4f8f76c4e66b5369566ea8a",
-            "size": "67044"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "57f074a8fd407f9848fccbe6fb728d649938f315b3135ca0070682fa326df466",
-            "md5": "b6d4e19b1239e1f63856ce91bf058b38",
-            "size": "105364"
-        }
-    },
-    "cuda_gdb": {
-        "name": "CUDA GDB",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_gdb/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "597b1429d311e338023763c6e414f8b826f254c139a4422214f6f8d4f9af90f7",
-            "md5": "f6d3aa7856abf88e5c0c4e5cebf5af8e",
-            "size": "65762552"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_gdb/linux-ppc64le/cuda_gdb-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "2738151a55fcc13f01195722a5cd316eb3b2e49fc6ab4da066bdc13a1e2c98af",
-            "md5": "9940939654686fd3da00d1fa281e212c",
-            "size": "65482616"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "8eb60a57eec17d837aa4be481f4399aa6288262ae61990cedf8f202a5b2329f4",
-            "md5": "80a1a0127fff32fa4aadd6e7074303f9",
-            "size": "65463172"
-        }
-    },
-    "cuda_nsight": {
-        "name": "Nsight Eclipse Edition Plugin",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_nsight/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "7e96029a8a730c799d7e85d283d4d3f21601448e50e3af407ff54f4344a30847",
-            "md5": "6a688c24dd28528970f028f62763e907",
-            "size": "118689728"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_nsight/linux-ppc64le/cuda_nsight-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "8121c2f187e3bfc1542e155d52c69283ada1f5d8c17e4779306e095926856d6e",
-            "md5": "3dae1d37c213a1e76cd0f571214b1bc3",
-            "size": "118689712"
-        }
-    },
-    "cuda_nvcc": {
-        "name": "CUDA NVCC",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_nvcc/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "32302154a7ec122defdbb49f1c7cc8777f204c3199d9222f013046be256f72d6",
-            "md5": "858c4eea2da82037bae9b6eef47747ed",
-            "size": "47698868"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_nvcc/linux-ppc64le/cuda_nvcc-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "f7c647b74f2f85f5d9c42d951d810cb7130288b11d25ef7308fb489e1150232f",
-            "md5": "c19a78d3e11fde996b83e2ac21252199",
-            "size": "42947524"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "98940f1719b2ab1af943293601307b9e87ea71e30809d429fd7dc2e59b294c68",
-            "md5": "e47ff4a9f6d35fa01efc7c5f64ebf1e8",
-            "size": "41816996"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "1c9e275d10ce496f75efc2337284ab7b6b8c7deb2abc148ea90b0a7ac9ebd9fd",
-            "md5": "5a3765f447771c6a983b7a90ca2f5396",
-            "size": "62734155"
-        }
-    },
-    "cuda_nvdisasm": {
-        "name": "CUDA nvdisasm",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_nvdisasm/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "dfaa7c1bea5e4e833374da2f80156998bc303e8787a6e88d6a9c97fdead6e9a9",
-            "md5": "a800e8d833020a5794310c74b54e73c4",
-            "size": "49879928"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_nvdisasm/linux-ppc64le/cuda_nvdisasm-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "06e9e4ba698d9b29f0d36e732264e8f1ce920cbe9b4014227104280f665674f6",
-            "md5": "a59901cdbd2c583cd59053e863b673a0",
-            "size": "49879940"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "3d9b4e99966f9e9305b54a55991a64b59d85d804dc3876f0881b538cff09c84c",
-            "md5": "cb93fd227f8eb20df6b39176801d144f",
-            "size": "49820084"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "59f237756aa152cd1f18ee49e30cc9138ad6b0b451e338b467684f8c1b512117",
-            "md5": "860e10f6ffcf7312709cefcfa6067047",
-            "size": "50139397"
-        }
-    },
-    "cuda_nvml_dev": {
-        "name": "CUDA NVML Headers",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_nvml_dev/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "37537d1946513d41a0b4b350ee93d4722a52fd56293c66f3dbdb33bf96d799f8",
-            "md5": "691e15a41db1eac40f9ba96c3b702852",
-            "size": "87052"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_nvml_dev/linux-ppc64le/cuda_nvml_dev-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "eb107e7c12c89c221f34f700fd838d2788d40febb43df45a387653c677a38027",
-            "md5": "5ed3d7b3a60abef4f8e038976a8c4304",
-            "size": "85620"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "4cee78d3354f268730e40c04626abb38bfb7329a06feb9ab0ab4fc53b2ffe09a",
-            "md5": "5a2b431c55f26240d3b2806ffc92ad30",
-            "size": "86308"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "26309a28f1ea2ad58c8eac6725e39210889d8310e5eecd234fe385056ea4b4cf",
-            "md5": "c79c8a619506364c791aa5e7d0d354ac",
-            "size": "120977"
-        }
-    },
-    "cuda_nvprof": {
-        "name": "CUDA nvprof",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_nvprof/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "b4683cee4e0837e19d22a93d2b944a740de4837049ab4f7a4ac97f35a554c3b9",
-            "md5": "7ed9fe37b9fd3b84a24c4fcc04e500b8",
-            "size": "2441540"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_nvprof/linux-ppc64le/cuda_nvprof-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "38c9c81e0913cbce002d094b504c5c94418b8968cf951a3764919439957e5894",
-            "md5": "af1ea66babdfe389194447e65b4885b7",
-            "size": "2120596"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "4b82430be0be570dfbe9fb0b3aa316b413757444f7b7a36fb70de81b58cb61c3",
-            "md5": "d5bd756383bda6676c9c1e41793bd948",
-            "size": "1700913"
-        }
-    },
-    "cuda_nvprune": {
-        "name": "CUDA nvprune",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_nvprune/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "1ba95b8a3c0b44a91ab7f1c5c52a23bad56cd2ca651e4f9c6a820d666ade24e3",
-            "md5": "253cbe9af015b13868e88540530ac206",
-            "size": "56212"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_nvprune/linux-ppc64le/cuda_nvprune-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "66b8e6c69ca9e6368d5e6753bc3a38f51c43d58d3e1fa30fc41cab5af2d58bf0",
-            "md5": "b3a6f87df7d2288b5d01e31caab131e5",
-            "size": "57240"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "8161576c8b9b4eeb23fdb3def3373e17a82f3bf9ee75422c16ffc30f9a9bcec7",
-            "md5": "fa4958bdca0f2188508fcdf8790dd291",
-            "size": "48436"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "17b5efeaf20298ef51ecea0969e8013481717c1d73bb2df5c6a3c994546f9944",
-            "md5": "dcc3362f5b55bf3fc088a591a647ff2f",
-            "size": "146052"
-        }
-    },
-    "cuda_nvrtc": {
-        "name": "CUDA NVRTC",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_nvrtc/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "6d549612a9c61caf7356d8a13d99a85cfa644269ed856192bea13c7e5f8ce234",
-            "md5": "68aa875913caefbe11de5fded4df7ac9",
-            "size": "31333156"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_nvrtc/linux-ppc64le/cuda_nvrtc-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "0e12e3bc044d6b1d0440493e086d7b7ca8c31eafe79e4fe7fbada6dd209d5d57",
-            "md5": "5d64fbfc312afa6c0259de98917e447a",
-            "size": "28575620"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "8c1aa8bb711a31d50f613d8594103cfeaf062e9a422094dcf6d18646ecd99f17",
-            "md5": "f879465dd1304b83b82a8b895a37d7b2",
-            "size": "28661256"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "3dabf99c94d8cadd4efc5163fb53207f8c011e553b08c41cb760d18bbf2e3f0b",
-            "md5": "1fb1e8d9668177ce740a9e5f24d568c9",
-            "size": "102259575"
-        }
-    },
-    "cuda_nvtx": {
-        "name": "CUDA NVTX",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_nvtx/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "090068726f299ac218f125fe15fb845bef5670ce48eccb95e752479b40361771",
-            "md5": "59b253c005d1829560b740a1f83bdc04",
-            "size": "48388"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_nvtx/linux-ppc64le/cuda_nvtx-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "2c3a6c1f84139e706c1a329b80dc7afaf2b687cc2e65111a37eb90419cd9ffe5",
-            "md5": "90d934de07f3a1d297509c21ac7c0908",
-            "size": "48400"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "d28d0be121286f5fb3e55e2e358bbda18c0eedf16d37347806601cc90ebff789",
-            "md5": "157223166a9249869b0df211073ed11a",
-            "size": "49044"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "92e840d1b5a2f6a5e6f7328de3e99554fbe3d6acfe917010597135c3e69a104b",
-            "md5": "868895cecfa12a9fc5204a673403fcf4",
-            "size": "65690"
-        }
-    },
-    "cuda_nvvp": {
-        "name": "CUDA NVVP",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_nvvp/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "54871072910527bae22af3337163a873cd92ad08ece6ed26e9ca48b6e28ce7f9",
-            "md5": "4dfddacbbeb2b335d678a620848af6bd",
-            "size": "117759232"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_nvvp/linux-ppc64le/cuda_nvvp-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "7aacfde343022de7e13792d87bcc4f9d7826e9a4f5c11ea11949730098024b3e",
-            "md5": "15bb39a8a7ed622c640112aa5d9ec93f",
-            "size": "111830320"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "40919592c0f3b71264cd4d3de4674bcf775d16ea81209fb4d41fb74673b8d21c",
-            "md5": "efd029d36d6edd6ca074416d98ad68e9",
-            "size": "120340815"
-        }
-    },
-    "cuda_opencl": {
-        "name": "CUDA OpenCL",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_opencl/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_opencl/linux-x86_64/cuda_opencl-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "8e270a6369947e711b5df48c4dbaebcbfdf7245cc4ddb098cfad69f85efa626e",
-            "md5": "94e8d0efc5bf057cff8a55349956371a",
-            "size": "75540"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_opencl/windows-x86_64/cuda_opencl-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "92d4b713626add42437aae1a044cebb1b80c7c47d343963150e5c182f8e3c9a3",
-            "md5": "2288f81210af58bf38f4be7ee29492bc",
-            "size": "114719"
-        }
-    },
-    "cuda_profiler_api": {
-        "name": "CUDA Profiler API",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_profiler_api/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "4ab0f21627156b9e0f681863d4adcfe8924b07eb1a40a6381ef807ff588a6d47",
-            "md5": "e96e1c532cfff9287e0ed7b38e3a3ad2",
-            "size": "16048"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_profiler_api/linux-ppc64le/cuda_profiler_api-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "186094548cb3603f167cac03777bd31c6c02d794dc5312f31b8874e25a515b06",
-            "md5": "7ba4e575eaaaf0ffd39f59eeac156491",
-            "size": "16056"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "2c1b04b719e6cbccef1e140c4371c1fb119c66b8e788adf3e10313fdb456ba87",
-            "md5": "c2ec9b80c3abf4d404f4da6e934be1c8",
-            "size": "16060"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "a339bb2448d39b74e895a1b5321c58cd235d9c7719fe343f8a2cb00c7f5877d4",
-            "md5": "67ebaa93beb345ed1ba5f56c08090568",
-            "size": "20075"
-        }
-    },
-    "cuda_sanitizer_api": {
-        "name": "CUDA Compute Sanitizer API",
-        "license": "CUDA Toolkit",
-        "license_path": "cuda_sanitizer_api/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "9dbebdd45130df33685213d8d5c6443ef45b34b9a23cee08d1c8eb54ab662cf9",
-            "md5": "198b805f7dbd3e04bbca139cdd2810b2",
-            "size": "8204808"
-        },
-        "linux-ppc64le": {
-            "relative_path": "cuda_sanitizer_api/linux-ppc64le/cuda_sanitizer_api-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "8a5bd354931778eb18c0ab118c38748c6a5bafa553cf84fee79d07839763c13e",
-            "md5": "9f9fe626f4f84fec7ee206faa7872f69",
-            "size": "7772948"
-        },
-        "linux-sbsa": {
-            "relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "a301c71de5f8d786b675c4258a8dd4fdc6533468c81f946b327e1a7f1ae859c2",
-            "md5": "37712b47eff245ce1e1dcdf0f685f6d4",
-            "size": "6519848"
-        },
-        "windows-x86_64": {
-            "relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "9d7abb0c7df2b9104888ea11539055117023cf7354d6859789c233e6e5df14b8",
-            "md5": "53e6bdc5e662ceb0efd8b2c1f0704a29",
-            "size": "14116642"
-        }
-    },
-    "fabricmanager": {
-        "name": "NVIDIA Fabric Manager",
-        "license": "NVIDIA Driver",
-        "license_path": "fabricmanager/LICENSE.txt",
-        "version": "545.23.06",
-        "linux-x86_64": {
-            "relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-545.23.06-archive.tar.xz",
-            "sha256": "3c0e848f554b33cf941e54ce1775f4f11198dbbc0275e261082f8fca0d0a28d9",
-            "md5": "3a04213dcd349cc2964eb29cce4c6bcc",
-            "size": "5088924"
-        },
-        "linux-sbsa": {
-            "relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-545.23.06-archive.tar.xz",
-            "sha256": "ffe93591af3d1075177ff598ae02c7067db5b2edde8bb016356c8d2ea549eb6d",
-            "md5": "0c73afa460eaa469bb51e7c3fba8fa38",
-            "size": "4649044"
-        }
-    },
-    "libcublas": {
-        "name": "CUDA cuBLAS",
-        "license": "CUDA Toolkit",
-        "license_path": "libcublas/LICENSE.txt",
-        "version": "12.3.2.9",
-        "linux-x86_64": {
-            "relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-12.3.2.9-archive.tar.xz",
-            "sha256": "793fb630ffeac7aabd241e43cd41d5209fb93e9505cb7937bdd318188d47551f",
-            "md5": "7b3a5411eeb85a061e48ce77b6f1e695",
-            "size": "504998132"
-        },
-        "linux-ppc64le": {
-            "relative_path": "libcublas/linux-ppc64le/libcublas-linux-ppc64le-12.3.2.9-archive.tar.xz",
-            "sha256": "c6b00cf18831527543f93a2e35d98f3b297d7a5b6896a598995eb4a3fa47f39c",
-            "md5": "7842b3f6de4312b21b7910b85f56587e",
-            "size": "401263304"
-        },
-        "linux-sbsa": {
-            "relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-12.3.2.9-archive.tar.xz",
-            "sha256": "bb83278da1007847a72e8f8ad40186c70a2ead7e48bf9eb387aeda94a8b63672",
-            "md5": "2dadf0b64c0f1781b606bda508e1d8b8",
-            "size": "496892884"
-        },
-        "windows-x86_64": {
-            "relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-12.3.2.9-archive.zip",
-            "sha256": "35c177357715c9c326ee50fa87192dee6b9c25944725ec3107f63675d10df4cf",
-            "md5": "7f1b5517f09170f46bc97812b0c81b13",
-            "size": "443868444"
-        }
-    },
-    "libcufft": {
-        "name": "CUDA cuFFT",
-        "license": "CUDA Toolkit",
-        "license_path": "libcufft/LICENSE.txt",
-        "version": "11.0.11.19",
-        "linux-x86_64": {
-            "relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-11.0.11.19-archive.tar.xz",
-            "sha256": "f84d33026cc59f6bdfe4ce446b78912499fc4447e8b7b4e3f1617bb0dae2a27e",
-            "md5": "9becd4989c7b92bc2f7fa4429c613fd1",
-            "size": "172050036"
-        },
-        "linux-ppc64le": {
-            "relative_path": "libcufft/linux-ppc64le/libcufft-linux-ppc64le-11.0.11.19-archive.tar.xz",
-            "sha256": "45a7f4bef97846374cc11c637b4b6b635b8e6abd0a45555ebb3ef5afc3c9c159",
-            "md5": "76a2f1431da7985b8deaea7355a6f3cf",
-            "size": "173409752"
-        },
-        "linux-sbsa": {
-            "relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-11.0.11.19-archive.tar.xz",
-            "sha256": "c6867258f4347557435b2dfb7d7e05405cd6a21c954f9ab82a22a1280e93173c",
-            "md5": "78655b8a9b6d32d76bc5cff2e1e735d6",
-            "size": "172359036"
-        },
-        "windows-x86_64": {
-            "relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-11.0.11.19-archive.zip",
-            "sha256": "df838d3a085f3741410f86c90a3da8dc57b38d69d830b198473b04fb0e8cfe06",
-            "md5": "420b784f259ccafe210c04fef0edd1e6",
-            "size": "96307613"
-        }
-    },
-    "libcufile": {
-        "name": "CUDA cuFile",
-        "license": "CUDA Toolkit",
-        "license_path": "libcufile/LICENSE.txt",
-        "version": "1.8.0.34",
-        "linux-x86_64": {
-            "relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.8.0.34-archive.tar.xz",
-            "sha256": "16d9810a414354f084820b3dacd59baa0dcbdc1c951519803fa10784d1f43ec4",
-            "md5": "9a27732eee2556fe72009fbdb9007342",
-            "size": "41857344"
-        },
-        "linux-sbsa": {
-            "relative_path": "libcufile/linux-sbsa/libcufile-linux-sbsa-1.8.0.34-archive.tar.xz",
-            "sha256": "733c02066ac5b026337da0a6adfc0ce3c71a677cfac9528c4e22443f0cd615bc",
-            "md5": "f67ac3f54ba73bbd69411237fba00c87",
-            "size": "41296760"
-        }
-    },
-    "libcurand": {
-        "name": "CUDA cuRAND",
-        "license": "CUDA Toolkit",
-        "license_path": "libcurand/LICENSE.txt",
-        "version": "10.3.4.52",
-        "linux-x86_64": {
-            "relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.3.4.52-archive.tar.xz",
-            "sha256": "8ac8ca5b1ab22e13cbd474ea5dfe24a2d6d1ff02dc5ed06b07648066c7ea34fc",
-            "md5": "04779769c4d217ee94e034f60d0a0e43",
-            "size": "81714596"
-        },
-        "linux-ppc64le": {
-            "relative_path": "libcurand/linux-ppc64le/libcurand-linux-ppc64le-10.3.4.52-archive.tar.xz",
-            "sha256": "8de3fee960f55895af53a2817835086c4d0c260628a32120d2987ae4e1b48e9f",
-            "md5": "9a2900df6914baf192eff7fd886be734",
-            "size": "81766484"
-        },
-        "linux-sbsa": {
-            "relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.3.4.52-archive.tar.xz",
-            "sha256": "2923351205c6d078a0678857f507f57e0aeaab9570946faad2ade97362abafc7",
-            "md5": "c3064fc74451401d864c811588d7447d",
-            "size": "81702812"
-        },
-        "windows-x86_64": {
-            "relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.3.4.52-archive.zip",
-            "sha256": "e3634e5eb0d9133e92909c525775e43ebc9597b4f6dda1f95d09bea18e4f4c51",
-            "md5": "19e696cffbaa7acb889b8c0092ae7db4",
-            "size": "55099171"
-        }
-    },
-    "libcusolver": {
-        "name": "CUDA cuSOLVER",
-        "license": "CUDA Toolkit",
-        "license_path": "libcusolver/LICENSE.txt",
-        "version": "11.5.3.52",
-        "linux-x86_64": {
-            "relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.5.3.52-archive.tar.xz",
-            "sha256": "334470e66d74102fa7a80e7eeb9ab5b80fe4939204a67d4ef64d369fe254cae2",
-            "md5": "8430c15911f35fcbf2108820df8ddcff",
-            "size": "123465076"
-        },
-        "linux-ppc64le": {
-            "relative_path": "libcusolver/linux-ppc64le/libcusolver-linux-ppc64le-11.5.3.52-archive.tar.xz",
-            "sha256": "a71dcef7bccd565003120bb5d18cf8adb0ed4428b3a122f1869f4849827234a1",
-            "md5": "f4997ae343547742e63fcd819cd02bad",
-            "size": "123579460"
-        },
-        "linux-sbsa": {
-            "relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.5.3.52-archive.tar.xz",
-            "sha256": "3de3b43a6576a10adac99ac34984c3c623ad6666699aa0531ca239d9d27beee5",
-            "md5": "2c2ae3936e81a9338fab1f3f723eedc9",
-            "size": "122842492"
-        },
-        "windows-x86_64": {
-            "relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.5.3.52-archive.zip",
-            "sha256": "73251d1b23faed1a04a84801beeb643161a1d10c6cdccd5f321a7dda7b105290",
-            "md5": "d088b48c66d39651cc05952529d308c7",
-            "size": "120934003"
-        }
-    },
-    "libcusparse": {
-        "name": "CUDA cuSPARSE",
-        "license": "CUDA Toolkit",
-        "license_path": "libcusparse/LICENSE.txt",
-        "version": "12.1.3.153",
-        "linux-x86_64": {
-            "relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-12.1.3.153-archive.tar.xz",
-            "sha256": "62b091161967b830cb20cdd73ceb77da28bd88a33db9b734644531f36f3556f6",
-            "md5": "f6685c2b0e80052f77210a451daf5fb6",
-            "size": "212909260"
-        },
-        "linux-ppc64le": {
-            "relative_path": "libcusparse/linux-ppc64le/libcusparse-linux-ppc64le-12.1.3.153-archive.tar.xz",
-            "sha256": "b086126226b919f6fcacbf1ef547045ea848bbc739bd6524a6bd2aee46110f61",
-            "md5": "0df5916c88513e489a47a83b58dc9444",
-            "size": "212929864"
-        },
-        "linux-sbsa": {
-            "relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-12.1.3.153-archive.tar.xz",
-            "sha256": "9f61ff29dc5aa272b771ba0691565d73f167ffe544b3d10f42c3f84ae9aa510a",
-            "md5": "5f4a30593348a87234f612dd3dd7b204",
-            "size": "212557236"
-        },
-        "windows-x86_64": {
-            "relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-12.1.3.153-archive.zip",
-            "sha256": "ae79b3b756a1c2ba848c2931bf0c9ae62746ab7755d110d68a280392999a0b45",
-            "md5": "9c1caa26adc1cc51728c632f89e38fa7",
-            "size": "192897620"
-        }
-    },
-    "libnpp": {
-        "name": "CUDA NPP",
-        "license": "CUDA Toolkit",
-        "license_path": "libnpp/LICENSE.txt",
-        "version": "12.2.2.32",
-        "linux-x86_64": {
-            "relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-12.2.2.32-archive.tar.xz",
-            "sha256": "1f8f47aedb988eea8611eabe085e6f9e177981b4d942e4d45185d90f752eed3e",
-            "md5": "194a625a46f20799e8e0dc1ed7148a7a",
-            "size": "183688252"
-        },
-        "linux-ppc64le": {
-            "relative_path": "libnpp/linux-ppc64le/libnpp-linux-ppc64le-12.2.2.32-archive.tar.xz",
-            "sha256": "00f2a26ea9ce3f4090ac72a3e2659faba6ab000afa1f22f50eeabe72ed4bf5b1",
-            "md5": "b916512ad551b21fff9b2ec88e2b5658",
-            "size": "184496636"
-        },
-        "linux-sbsa": {
-            "relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-12.2.2.32-archive.tar.xz",
-            "sha256": "d2f5e784d4486663e4a0851e3bedd7fab769cf7960a4d37bfb07c2feb43ca4b7",
-            "md5": "8d4fd6cc3e070a263f527b3a2e4ec516",
-            "size": "183572808"
-        },
-        "windows-x86_64": {
-            "relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-12.2.2.32-archive.zip",
-            "sha256": "5b35180d336cb4cdc8d3ee362b91aef986de292bcbdbe1a71dc544dc3bae3b6a",
-            "md5": "0890caecbe7fdd94fbf82fe3f40fda6e",
-            "size": "153321627"
-        }
-    },
-    "libnvidia_nscq": {
-        "name": "NVIDIA NSCQ API",
-        "license": "NVIDIA Driver",
-        "license_path": "libnvidia_nscq/LICENSE.txt",
-        "version": "545.23.06",
-        "linux-x86_64": {
-            "relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-545.23.06-archive.tar.xz",
-            "sha256": "66abb1ec36f5e67f0c32c7f7fdd7b264a628528684d3b3647674eef914330926",
-            "md5": "ef4d098fb8d226b6e8b3197d54255eb5",
-            "size": "352880"
-        },
-        "linux-sbsa": {
-            "relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-545.23.06-archive.tar.xz",
-            "sha256": "4d60d9022c2228ef9f32705ffbc5aa72b5ce44e9e4aad859f8bf7aa2915dc8a7",
-            "md5": "3c48b4a62438026ac4a5bf563fead503",
-            "size": "319880"
-        }
-    },
-    "libnvjitlink": {
-        "name": "NVIDIA compiler library for JIT LTO functionality",
-        "license": "CUDA Toolkit",
-        "license_path": "libnvjitlink/LICENSE.txt",
-        "version": "12.3.52",
-        "linux-x86_64": {
-            "relative_path": "libnvjitlink/linux-x86_64/libnvjitlink-linux-x86_64-12.3.52-archive.tar.xz",
-            "sha256": "92f21102652a22ec735bac9ab236dae1b69d808d1391a96ba379bfa4dd83e6b8",
-            "md5": "107a984b8eb5712b3997cf3b56779356",
-            "size": "26483580"
-        },
-        "linux-ppc64le": {
-            "relative_path": "libnvjitlink/linux-ppc64le/libnvjitlink-linux-ppc64le-12.3.52-archive.tar.xz",
-            "sha256": "2802ed389e9c246415a6fc0dc8f8f5bc6cf9f43bcf53f30a921b6e5d80b1e314",
-            "md5": "b595ce0b4ac917063b9d3e417e1c0847",
-            "size": "24029696"
-        },
-        "linux-sbsa": {
-            "relative_path": "libnvjitlink/linux-sbsa/libnvjitlink-linux-sbsa-12.3.52-archive.tar.xz",
-            "sha256": "afcd59beb68d68115d0b020bca49e75ff3b407a9469d5578c25309e5ef83442e",
-            "md5": "4a4629c069aad8a564927990c167b01b",
-            "size": "24067300"
-        },
-        "windows-x86_64": {
-            "relative_path": "libnvjitlink/windows-x86_64/libnvjitlink-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "117ba27dc4086f895bade8d6314d5a2bd835342a6d46fef471b9932807e59e1e",
-            "md5": "ee72bcd855f46ad652acbe8a06457e59",
-            "size": "90900374"
-        }
-    },
-    "libnvjpeg": {
-        "name": "CUDA nvJPEG",
-        "license": "CUDA Toolkit",
-        "license_path": "libnvjpeg/LICENSE.txt",
-        "version": "12.2.3.32",
-        "linux-x86_64": {
-            "relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-12.2.3.32-archive.tar.xz",
-            "sha256": "19e7dedaaa07c451a84cc607711a22a6f852043559f5bd11cd8e50683628a590",
-            "md5": "8195a125d8dc67b9769ba4151f28b471",
-            "size": "2564332"
-        },
-        "linux-ppc64le": {
-            "relative_path": "libnvjpeg/linux-ppc64le/libnvjpeg-linux-ppc64le-12.2.3.32-archive.tar.xz",
-            "sha256": "cb77d773e261c0fb298da405036728e18be11f21f45c3ac474b9e3a69ad2ff46",
-            "md5": "e8323f5f3b00f3703b834a72171863ad",
-            "size": "2589976"
-        },
-        "linux-sbsa": {
-            "relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-12.2.3.32-archive.tar.xz",
-            "sha256": "a4c7a739905f42dce324845b5d27cb8402ec84c0d48a7e50b6426891ae62d429",
-            "md5": "fee67a165abdc83440788932cccf113b",
-            "size": "2390916"
-        },
-        "windows-x86_64": {
-            "relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-12.2.3.32-archive.zip",
-            "sha256": "dd931eb75934550421884d548d1e6c4504a11d4f71df07f1c088158b7b7466b7",
-            "md5": "5741a278df23d62f0e97be4d1013ddd2",
-            "size": "2829977"
-        }
-    },
-    "nsight_compute": {
-        "name": "Nsight Compute",
-        "license": "NVIDIA SLA",
-        "license_path": "nsight_compute/LICENSE.txt",
-        "version": "2023.3.0.12",
-        "linux-x86_64": {
-            "relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2023.3.0.12-archive.tar.xz",
-            "sha256": "12c96010d723f48702a342d7ae6dfa18e96154fc69225de0398c907fdd655499",
-            "md5": "40e9f41957a580680f88e7edce40e49a",
-            "size": "736137868"
-        },
-        "linux-ppc64le": {
-            "relative_path": "nsight_compute/linux-ppc64le/nsight_compute-linux-ppc64le-2023.3.0.12-archive.tar.xz",
-            "sha256": "d2003f65ec46ded90db0639990efa2a2b5e3acebafbc2f47f8b8d47c4624c85d",
-            "md5": "29eac226551bfeeadb394f6b2215765e",
-            "size": "139988468"
-        },
-        "linux-sbsa": {
-            "relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2023.3.0.12-archive.tar.xz",
-            "sha256": "e4e809260462a313c1ecb5705b535558289e60507d26e77495cd456a9e1cd85b",
-            "md5": "bc6d08cb6d6e485cc94939940d0feb50",
-            "size": "358992716"
-        },
-        "windows-x86_64": {
-            "relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2023.3.0.12-archive.zip",
-            "sha256": "97959a668e6c4732b34a294bd997ce37f8f08ab5714c47af426a5d00313eb435",
-            "md5": "a23e3d5e577624f95e35738e7507ded1",
-            "size": "674363811"
-        }
-    },
-    "nsight_systems": {
-        "name": "Nsight Systems",
-        "license": "NVIDIA SLA",
-        "license_path": "nsight_systems/LICENSE.txt",
-        "version": "2023.3.3.42",
-        "linux-x86_64": {
-            "relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2023.3.3.42-archive.tar.xz",
-            "sha256": "dafded1be045abea2804697646178a66bec4a5eebb1b28b2637a37c2f22c7b93",
-            "md5": "34208b6d0c71444babf10a9bfeac86b0",
-            "size": "227696524"
-        },
-        "linux-ppc64le": {
-            "relative_path": "nsight_systems/linux-ppc64le/nsight_systems-linux-ppc64le-2023.3.3.42-archive.tar.xz",
-            "sha256": "5095fc2a432267c002fa84d14f8c09985c7ba17becb6095699d7407fcbe3234d",
-            "md5": "8f873649a9686b23c71ab4f5c575bf74",
-            "size": "67233156"
-        },
-        "linux-sbsa": {
-            "relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2023.3.3.42-archive.tar.xz",
-            "sha256": "93976454c75ca4dc6da28c7e8cc886cc21ec513d4e0f294f56b9afad245e4071",
-            "md5": "98e172f249dfa5da3eaa564a86179601",
-            "size": "198960916"
-        },
-        "windows-x86_64": {
-            "relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2023.3.3.42-archive.zip",
-            "sha256": "9049d2bd0f17d967f7c84f33eee04b83c6b65349e3b12f97a3a9211d411e0009",
-            "md5": "54e49f657acf7b5e337c77f94b9d0943",
-            "size": "348461444"
-        }
-    },
-    "nsight_vse": {
-        "name": "Nsight Visual Studio Edition (VSE)",
-        "license": "NVIDIA SLA",
-        "license_path": "nsight_vse/LICENSE.txt",
-        "version": "2023.3.0.23248",
-        "windows-x86_64": {
-            "relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2023.3.0.23248-archive.zip",
-            "sha256": "10518927226a8a60c47bd1040e4be8b0396d37738ba1f11ba6bc918115e231a0",
-            "md5": "c2aba6d4604b9005b2a322dc68ce5534",
-            "size": "527217651"
-        }
-    },
-    "nvidia_driver": {
-        "name": "NVIDIA Linux Driver",
-        "license": "NVIDIA Driver",
-        "license_path": "nvidia_driver/LICENSE.txt",
-        "version": "545.23.06",
-        "linux-x86_64": {
-            "relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-545.23.06-archive.tar.xz",
-            "sha256": "e799421bdfee93a16c2bfd0b7622875ae1e993cc1955383d92a57f36a2ce47db",
-            "md5": "4c17b86e90fd601d9f787b2777949bfd",
-            "size": "371993760"
-        },
-        "linux-ppc64le": {
-            "relative_path": "nvidia_driver/linux-ppc64le/nvidia_driver-linux-ppc64le-545.23.06-archive.tar.xz",
-            "sha256": "09e8790c9c79419acf74dc3d3f20c812d073e156001e617a8a4af9fe11713a36",
-            "md5": "f9734bc55548492a4d3e2d991419b446",
-            "size": "100061728"
-        },
-        "linux-sbsa": {
-            "relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-545.23.06-archive.tar.xz",
-            "sha256": "6d0bf7e1adb49c0bcd968c9a4eb9ee324ebffa7683b34d92fd25f4ff2f99dbd1",
-            "md5": "9fe92968de77c9809d579582d5266b0a",
-            "size": "288683672"
-        }
-    },
-    "nvidia_fs": {
-        "name": "NVIDIA filesystem",
-        "license": "CUDA Toolkit",
-        "license_path": "nvidia_fs/LICENSE.txt",
-        "version": "2.18.3",
-        "linux-x86_64": {
-            "relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.18.3-archive.tar.xz",
-            "sha256": "4b2b045c932c1449f28be246b3b28658981e81507825d73a35e11e9450774ac4",
-            "md5": "74135e8f97454338505b58bbcc5483a5",
-            "size": "58448"
-        },
-        "linux-sbsa": {
-            "relative_path": "nvidia_fs/linux-sbsa/nvidia_fs-linux-sbsa-2.18.3-archive.tar.xz",
-            "sha256": "80bae8ef6f977e2aeecb392c00e056e579657632abb02eb75e86bbf306db6f50",
-            "md5": "f88dd5297012268400192de8877f4606",
-            "size": "58460"
-        }
-    },
-    "visual_studio_integration": {
-        "name": "CUDA Visual Studio Integration",
-        "license": "CUDA Toolkit",
-        "license_path": "visual_studio_integration/LICENSE.txt",
-        "version": "12.3.52",
-        "windows-x86_64": {
-            "relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-12.3.52-archive.zip",
-            "sha256": "b801075f82c789ac8014223ca3437ef87e9e0ee700b7b617f4495bcc273b788a",
-            "md5": "f456d7ab05e574cd8c2a20d8f1efd4e0",
-            "size": "518070"
-        }
-    }
-}

pkgs/development/cuda-modules/cuda/manifests/redistrib_12.3.2.json

···
+{
+    "release_date": "2024-01-02",
+    "release_label": "12.3.2",
+    "release_product": "cuda",
+    "cuda_cccl": {
+        "name": "CXX Core Compute Libraries",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cccl/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "dabd433bbef5f6d1b79f9a7eea909a3c273e20641f07a6a8667f42577462e34d",
+            "md5": "f3119f37a745c62d8d1656553e4463ae",
+            "size": "1148952"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cccl/linux-ppc64le/cuda_cccl-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "3be1948414533a6724d79dbfedd1963fb5074a4ed184626cd8735e38d10716f6",
+            "md5": "40beebf3920832ce4536686bf23a68ed",
+            "size": "1149484"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "77b22b4b5c54d7649edd62253979e7290314de73f268df152c1c21811ae20084",
+            "md5": "6a3f6d0a6dc231061cfb123c424c4979",
+            "size": "1148576"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "9ead3b6a606727ca05645f3f6b050d1158358c3bc9e518169666c9766f090306",
+            "md5": "fe38472401c6f4e30f99fdff4f5fb6b8",
+            "size": "3044697"
+        }
+    },
+    "cuda_cudart": {
+        "name": "CUDA Runtime (cudart)",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cudart/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "e37d478d1e7a10490d55fb87a5ef379a18c648f3010e1d3687c4298ddc3e9e19",
+            "md5": "4468b80ed363109753937f5367ed1dc1",
+            "size": "1088388"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cudart/linux-ppc64le/cuda_cudart-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "23f6ef558bb954dea3ef5b378c3ad28e1da93080890bd8bf1a18a75ae2ee605d",
+            "md5": "16395f8fd1eb591459897975c244d5fb",
+            "size": "1068376"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "131e62c60ba979f6870687db99a7537482f6df445915789d2a4799dc4e898b66",
+            "md5": "7e7175d5ca2e379062306b9779a2c990",
+            "size": "1078280"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "310a71bc9c92d6e61eeddf3489cc195519665fbfaca16c618b03da0ac5ea9f7d",
+            "md5": "92f4e20c900ce5a6ef368bf28bae842e",
+            "size": "2463054"
+        }
+    },
+    "cuda_cuobjdump": {
+        "name": "cuobjdump",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cuobjdump/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "0862d4b6a9e753fcfa4802e52ea917c5ae0e9ebdfe7e35bb3c1eb1f6f57857be",
+            "md5": "24fc1f4c0451a4246c6aab5fb508a207",
+            "size": "172472"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cuobjdump/linux-ppc64le/cuda_cuobjdump-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "46c759ec6faea974cf3218113fdcd2da4e92bc9ab12777d4c3b6c61aaf6c67a2",
+            "md5": "e0b0144945533913427739dc75b9f5c4",
+            "size": "215140"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "3fa1028791d0bc64532d33b080575f75f80150170fdcf3c0f2fa475da2f37167",
+            "md5": "6fe7599fe0e9ae4358c3664717cdb2c5",
+            "size": "181624"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "c37af9d07d7adff82096200ad73f96826a7a1153a1318917531abd06d311cbf0",
+            "md5": "3c61472d71d827d3d69e1cd0d6fa2cf8",
+            "size": "4013255"
+        }
+    },
+    "cuda_cupti": {
+        "name": "CUPTI",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cupti/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "082c178c1b94671d2feac5f1cc241ea0e8b46860b1fd1aed530eca2d919e4360",
+            "md5": "502cdf8cc1005e742f4cbbfe49d21fd0",
+            "size": "19315124"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cupti/linux-ppc64le/cuda_cupti-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "f3fdeb6ed036f6ff4771edc36eed421273780e9e9084f7821f6e85dfbe211c46",
+            "md5": "687a1b88a89c3fab3cf1b54d78ec286b",
+            "size": "10835996"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "a9417e7ef9af4e592099e372b0e6a1714d617866b2fc93c6832da2bdc07a707c",
+            "md5": "453fa202b2ec00286b6a14d8c5e1b06b",
+            "size": "10010512"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "fb57c570cbd71c167d8b4227508b39bdf8d2e79a38ba6f669217045d774df027",
+            "md5": "52e9ac3a512ad0ebab73382d333647ee",
+            "size": "13150781"
+        }
+    },
+    "cuda_cuxxfilt": {
+        "name": "CUDA cuxxfilt (demangler)",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cuxxfilt/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "6ecaa13bf5118a97d8f3275bd66646115f120ac76cdb1f88a5440504f173d864",
+            "md5": "fd640c2e78dacef9dfc047dc4748e90b",
+            "size": "188268"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_cuxxfilt/linux-ppc64le/cuda_cuxxfilt-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "6e838311106b5ae0d5c57456a5c7249033a2b6d413a65a333712792d3ca993a8",
+            "md5": "cd43912dc4fbee3dc8856632b23b058d",
+            "size": "182332"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "778d1ae0d2fd0245122dd357f34cb50a8264980697ba1cf8d7da51f6e5101df5",
+            "md5": "a5dd901e3af1f14820e8daba9e46dafe",
+            "size": "174444"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "25d1726e4d0d4cb1de60a8297d29432f0e04a4d69a510ddf3bd192c666591257",
+            "md5": "7323d0e137462f2329a77d0de3f64f76",
+            "size": "170357"
+        }
+    },
+    "cuda_demo_suite": {
+        "name": "CUDA Demo Suite",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_demo_suite/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "ee400c1695b2804ec7521e8d21b7571daea0e4fc32156e21e2fa507921a0019e",
+            "md5": "b7341feb37bc6d81c8764b47db095016",
+            "size": "4005468"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "d2b710cd189b851f60cbfc9a4d423ff94379d50af76f44bd7854d4b92010bd7d",
+            "md5": "538353b556bc50f59c178caa8761b0d8",
+            "size": "5061041"
+        }
+    },
+    "cuda_documentation": {
+        "name": "CUDA Documentation",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_documentation/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "3d2775809d57f9e65c52c311671768e2a3082ebd2c325a1315ab311508db9da2",
+            "md5": "ea6c8f16badb67fe841d879cf77cc9e7",
+            "size": "66988"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_documentation/linux-ppc64le/cuda_documentation-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "e27bd9984e23979aaf3ee54e748bd7bff32d50ff8d4e31031a891c0a4b625f2c",
+            "md5": "df246dc0d4d00390c775dd2568d76a3b",
+            "size": "67160"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "d7134f64a0644497aa27b7acb7a4f335978b60c01f012616fca669d404f3e352",
+            "md5": "14e27075244eeb433d0049f38fa5fe47",
+            "size": "67096"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "b15505f1a12cd42fb933867feccf1f7274371e9266f7e24edb9d408c03caf486",
+            "md5": "52b986cbe824279095f58e5fcfc83d27",
+            "size": "105380"
+        }
+    },
+    "cuda_gdb": {
+        "name": "CUDA GDB",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_gdb/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "3b8a692e7db61321c24896f151e72a761e1c7a88d84d3cde95eab0a97dc91e88",
+            "md5": "3b44bdf387bdb00026741833af010ece",
+            "size": "65763492"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_gdb/linux-ppc64le/cuda_gdb-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "0e3fb5c5ac8b03326e5a61bf72d7579718bf7498d887ae93ce6c7b08f0faa601",
+            "md5": "b97a75ea07ba1a1e5fd64f7ffce7f34c",
+            "size": "65489936"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "74ed3c6b0b69ac69faa2cc46d26627149b36e14e47394ba39f5ee49e988ce6f4",
+            "md5": "b4bdb7e478ac72037d63c17d03fe5eac",
+            "size": "65436776"
+        }
+    },
+    "cuda_nsight": {
+        "name": "Nsight Eclipse Edition Plugin",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nsight/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "299d7e9bd3171a9db0790f08666a85c14b9a6fd09818f3c572f300d5be46ac61",
+            "md5": "fa5c57f87c50676914aa3aecf7b5c2e0",
+            "size": "118685744"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nsight/linux-ppc64le/cuda_nsight-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "281c00d45a7b5d2e3456d084137a4a45858f2dc9333eea8a2644b6a61ca6189b",
+            "md5": "01d088acf0a6704510b249b6afc0be6e",
+            "size": "118685756"
+        }
+    },
+    "cuda_nvcc": {
+        "name": "CUDA NVCC",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvcc/LICENSE.txt",
+        "version": "12.3.107",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-12.3.107-archive.tar.xz",
+            "sha256": "65dba017ed1dbbe819a6ccc1841a4add4dfbc652603aa89be773888e82a5629e",
+            "md5": "896329e1059bd078b891e502c9292c08",
+            "size": "47766584"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvcc/linux-ppc64le/cuda_nvcc-linux-ppc64le-12.3.107-archive.tar.xz",
+            "sha256": "0a5caf3e0cfd44f3aaa235f861c98573ac735f550faf57bda199650551fa27f1",
+            "md5": "254aae27caef8ed77be1bd17acb6abe6",
+            "size": "42929084"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-12.3.107-archive.tar.xz",
+            "sha256": "4c0e6a79a67fb86489be9e0976cc22127ca2ae160b1ad22ac4742d52f0ebe32d",
+            "md5": "4f35923354104295911afdcac21145d6",
+            "size": "41813056"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-12.3.107-archive.zip",
+            "sha256": "8398faefe86092b434d6be2f0b74addae639965217b8fb8f77099c8d75eb99df",
+            "md5": "b167359cdccc00f021cc63c8084e6c94",
+            "size": "62744070"
+        }
+    },
+    "cuda_nvdisasm": {
+        "name": "CUDA nvdisasm",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvdisasm/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "02409ad45cad89920bb6b5f9ef8332f4566347a33037d3730a5db562e8b3e4bb",
+            "md5": "1678671b839e55487f9e5be6e58f56b7",
+            "size": "49893160"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvdisasm/linux-ppc64le/cuda_nvdisasm-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "54ed51e325e0fcf6b19598ed6e146fc5c3e99b291bb61e341e8b116448ad972e",
+            "md5": "d67d76f3d47cce4351d97e5a596324aa",
+            "size": "49890852"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "fa9a5b1f1c68080cb0e58297d52fff695c9fb4ab71906acc4a3500d7654fddc5",
+            "md5": "f91d8a5f0c8505a2ef47e62cc93ce7fd",
+            "size": "49807020"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "e4f984462be44e897d8e56382b5e18091d447ba46c0b325916dae197ac73007e",
+            "md5": "0f5dfa3054c730472104c6fab6935f93",
+            "size": "50139405"
+        }
+    },
+    "cuda_nvml_dev": {
+        "name": "CUDA NVML Headers",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvml_dev/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "34ab12792d46a839012236608ec446a13f6e7775556f9122a7c33bc742b3b29d",
+            "md5": "64a48a82f244d8db42f23973c544ce2d",
+            "size": "86476"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvml_dev/linux-ppc64le/cuda_nvml_dev-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "655c44679b0d5c6f8756257770d99ba01bf31557a831076c5623b372adaaeadd",
+            "md5": "0f58b219e6637978d5392e869bf5d11f",
+            "size": "85684"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "e14f15f6eb8dc25d37872d713bfb40530b67b68e7b8441078310f40a3aec121f",
+            "md5": "32b850819909bc3c61a4fe973f016e81",
+            "size": "86280"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "73fef685ec993d8abdae25e8b0b96a562811e8e3b8709f3bf97c7388234dd81d",
+            "md5": "a956bc3471267309a6b3cb4c702c9d43",
+            "size": "120959"
+        }
+    },
+    "cuda_nvprof": {
+        "name": "CUDA nvprof",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvprof/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "00a0a569a7cf56c7aefdfb70a4f9b9e75ef861f1e18b233ef557e9d00481ce53",
+            "md5": "013eb78294db5f16c2ee0110b0add032",
+            "size": "2442448"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvprof/linux-ppc64le/cuda_nvprof-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "0db875a38e947c038a7e67059d3b61863de751e36e2fa83c9f69aeac77b0b49d",
+            "md5": "f88d8cd79056574e325954a9bb685bae",
+            "size": "2119636"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "3abf2993dad74a981b5ea3405cdd0c5173ab848cbbd0a5ea140b04ae9fdf4baa",
+            "md5": "d8a34da67a0694c1166360312a8a4a03",
+            "size": "1700921"
+        }
+    },
+    "cuda_nvprune": {
+        "name": "CUDA nvprune",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvprune/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "61ac07de3c24e666932f61467ca79f8ac39560b04ea43b0c270e36bae64cd923",
+            "md5": "29304a18e402505195a0c79509313ab9",
+            "size": "56232"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvprune/linux-ppc64le/cuda_nvprune-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "32f921da04a1b76a3dcc0f82e10ae69f58e3ffd4436f29b9bd810456fabb5400",
+            "md5": "8b4c75036f9c9c65fa6dab7d8346ed49",
+            "size": "57128"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "bc91e618a3548631ee6a7990d615987ffd480a92b35a73bbb3db5c283d9506d2",
+            "md5": "b4ddce3f6d8cb16f435de19251dce143",
+            "size": "48384"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "ad7b454e8a7b9e7fb513dd7fcf73635b8b2023a34b9325c966f8743dcbb8d173",
+            "md5": "0bd3b4de6eae3c7e13f8e4797c15bfbc",
+            "size": "146071"
+        }
+    },
+    "cuda_nvrtc": {
+        "name": "CUDA NVRTC",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvrtc/LICENSE.txt",
+        "version": "12.3.107",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-12.3.107-archive.tar.xz",
+            "sha256": "bc9d2f9d8f8847f76cc936f61d66f55ea4a898294e1799e2a63480b553b60e0b",
+            "md5": "67a2de1833667dc19bf8663b47274d69",
+            "size": "31329444"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvrtc/linux-ppc64le/cuda_nvrtc-linux-ppc64le-12.3.107-archive.tar.xz",
+            "sha256": "456b3f7ddb55547fb5dfc6f61b2f06a16fa92336981baeb318f47ba2a456789d",
+            "md5": "30c2c5342a095d4ac75e4c6e2cfc47e4",
+            "size": "28578552"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-12.3.107-archive.tar.xz",
+            "sha256": "efadf1837f40eeecb29255516afaff258602e74fb9c436b15024b6a295c506f5",
+            "md5": "cb8a93362a74b798898eced4330d3b82",
+            "size": "28665080"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-12.3.107-archive.zip",
+            "sha256": "535f226462c1f5025e054f7f76dd55573b6c59bdc734b314df554085b9c782ed",
+            "md5": "1421ed79aff390a16335af12bcf7d4de",
+            "size": "102253018"
+        }
+    },
+    "cuda_nvtx": {
+        "name": "CUDA NVTX",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvtx/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "cd21f7fc329337f3c1be888e68aef5d580f243b5cc9a63d392cdb08e49be1689",
+            "md5": "33f40082431501318d3f7078a62be60d",
+            "size": "48380"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvtx/linux-ppc64le/cuda_nvtx-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "48c55ef200dc7164018ddf8c954b37805bae75419c2d80c4996d251e2d51058b",
+            "md5": "78af17ce108918a8e367fa090cf24a3d",
+            "size": "48396"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "69535a21d1db11e904eaddfa6861bec8203f5f4e97fe9b191ab35ca7ba5e5e1e",
+            "md5": "53a1a7e25de8bc5782995bb1f88b8853",
+            "size": "48964"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "5761c579e7381ae8f602eec14627ce89bfe4afed401bd788b72c70a45d5f0294",
+            "md5": "3544f2ef567d3725676ed0ac6a833306",
+            "size": "65732"
+        }
+    },
+    "cuda_nvvp": {
+        "name": "CUDA NVVP",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvvp/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "d186cae0f9a641b2777080272d6aab90955ebafa45667639c2326577e078dbe7",
+            "md5": "31f060b2ee6d6f9a5affafcf7f5a6550",
+            "size": "117712464"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_nvvp/linux-ppc64le/cuda_nvvp-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "5ddbd92cc6ddce5530f38bd2e874021b7927fd60b4d4eb22805c043317347cbb",
+            "md5": "30c313fd38404f59eee5531f0900507e",
+            "size": "117150880"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "6b05de592c734373ba4cad2df7cd5383916e95bbe6fbdc7def68f0fa16d76fc7",
+            "md5": "8e2c9c7593170e17248fbd9aa7001733",
+            "size": "120344076"
+        }
+    },
+    "cuda_opencl": {
+        "name": "CUDA OpenCL",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_opencl/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_opencl/linux-x86_64/cuda_opencl-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "e984ff10ee56651869b24dc74f80c404b2526abdaa16235d6edfff3d9f58b0fa",
+            "md5": "2fc8fa39f41c1ec4183219dc18f70e9b",
+            "size": "75660"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_opencl/windows-x86_64/cuda_opencl-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "fa854efbb672785d07aa4e680312d9dc43da1d315aa8cfe403d9f25cd4291020",
+            "md5": "9d01c79bad666504b33e17b5da73402c",
+            "size": "114767"
+        }
+    },
+    "cuda_profiler_api": {
+        "name": "CUDA Profiler API",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_profiler_api/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "0fc298c934a3081cd5f52d57286b25db81f14b2a370342313b40b157578a3e35",
+            "md5": "3016b7861e13125957a1bef416919ffe",
+            "size": "16052"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_profiler_api/linux-ppc64le/cuda_profiler_api-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "46081476f70995881d8afa3b541c33f10c13bf53a0510de738a6368735a6a94d",
+            "md5": "fe421fd21653eb1f13e471dfb0a8b687",
+            "size": "16048"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "0e803fdb13a1201ed4c5202c3c82a7aa0590c65b9075383e9dabe02d4d01e372",
+            "md5": "3fe9d3bdb34dcd182e6148e50c5f82a0",
+            "size": "16060"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "9eb456ec5d7c7b7e0b0eeac5c7624380ce249774b4e261eda621881aeb04b5b9",
+            "md5": "90ff175654c9133428ad46e191a57102",
+            "size": "20085"
+        }
+    },
+    "cuda_sanitizer_api": {
+        "name": "CUDA Compute Sanitizer API",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_sanitizer_api/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "e65b92b71467efc156bbc3d1ebaf5b14dfbc4e9f269ab2995a37bbf84530666c",
+            "md5": "c7def2056d5add8b5e9c6a9314864b4a",
+            "size": "8204980"
+        },
+        "linux-ppc64le": {
+            "relative_path": "cuda_sanitizer_api/linux-ppc64le/cuda_sanitizer_api-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "869d2dc46a291686f8c40f3b98232cddd85e4696be0d7e119ce92ec46e330590",
+            "md5": "6007da874390eb54cc366d0dde110ced",
+            "size": "7780796"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "c01d0b46a50e50292afcca33a3b768a900500d5b442925452801331ee0a61644",
+            "md5": "090ab33b8be87e5e2bd93b17ec20efa6",
+            "size": "6315216"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "8674b7e74d20ec9dc7566b9fa72a8ff1b4713c400000021d81d10e7497bc86d8",
+            "md5": "805e7a46427b35d6b71ac120f59a431e",
+            "size": "14115084"
+        }
+    },
+    "fabricmanager": {
+        "name": "NVIDIA Fabric Manager",
+        "license": "NVIDIA Driver",
+        "license_path": "fabricmanager/LICENSE.txt",
+        "version": "545.23.08",
+        "linux-x86_64": {
+            "relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-545.23.08-archive.tar.xz",
+            "sha256": "50af13d611cba79fe8c8f8d91b2d9203882f9c6c66080c73eb392b6a4ae91b74",
+            "md5": "e862955420ca5d0dc3ea6e2891bea964",
+            "size": "5086652"
+        },
+        "linux-sbsa": {
+            "relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-545.23.08-archive.tar.xz",
+            "sha256": "b72a3f396003311c7697cecda9b4504b48cd26d1998d2e9e83106fffa0f34d03",
+            "md5": "6710d5bb9c71763131ddd181f53f381d",
+            "size": "4649412"
+        }
+    },
+    "libcublas": {
+        "name": "CUDA cuBLAS",
+        "license": "CUDA Toolkit",
+        "license_path": "libcublas/LICENSE.txt",
+        "version": "12.3.4.1",
+        "linux-x86_64": {
+            "relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-12.3.4.1-archive.tar.xz",
+            "sha256": "2cb5c340f89d9bad6e0f1fb2a93a8a4962fe106eeb96d8887abd25c1552bd219",
+            "md5": "35f21496d6181b588e00705424668d5a",
+            "size": "499925424"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcublas/linux-ppc64le/libcublas-linux-ppc64le-12.3.4.1-archive.tar.xz",
+            "sha256": "bfe394a4f8374d59df406c9ce1b7bc11c6a9449a48a9ed3b30e88e6f35c76ab4",
+            "md5": "eff9572ed0cc1de20b06680c42790d44",
+            "size": "392625472"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-12.3.4.1-archive.tar.xz",
+            "sha256": "063f0e1a130b35ff662d21c2e05613122146bec2eab4818139eaee5a1c4d94bd",
+            "md5": "f0d5d343147859d83d12f00ad02973a5",
+            "size": "492030856"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-12.3.4.1-archive.zip",
+            "sha256": "e29c419a99a2f5e3ea0e7394a58c23536429a26b7eccc3f89f172f7fd2818a23",
+            "md5": "b0c9a8c8250eaeaa51fd48525e9ab620",
+            "size": "439481897"
+        }
+    },
+    "libcufft": {
+        "name": "CUDA cuFFT",
+        "license": "CUDA Toolkit",
+        "license_path": "libcufft/LICENSE.txt",
+        "version": "11.0.12.1",
+        "linux-x86_64": {
+            "relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-11.0.12.1-archive.tar.xz",
+            "sha256": "db057e20e123124fa43e71c97276a8bb02bb14dcdd467e901f542217ca603a48",
+            "md5": "d38b97c129aa0c288c690ef95e010522",
+            "size": "172057020"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcufft/linux-ppc64le/libcufft-linux-ppc64le-11.0.12.1-archive.tar.xz",
+            "sha256": "7ab861a691c82929f7b081f4c575b703ef6d08a5addae3da2684a2b228cd98c7",
+            "md5": "86924c66cb4d088c9f1a845c723b00f5",
+            "size": "173407672"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-11.0.12.1-archive.tar.xz",
+            "sha256": "8bde00bd10cba318998d6aee5677b5094be55c6e77259581495f8b31450c3ec2",
+            "md5": "0e73f8725bbc4ef94dc4776de52c67a2",
+            "size": "172362656"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-11.0.12.1-archive.zip",
+            "sha256": "c961016efe08da23f481f76efd8be0c2767496aaa7afead51789460ebac81cee",
+            "md5": "e45934973d0b3969313450fa2e4773bb",
+            "size": "96311678"
+        }
+    },
+    "libcufile": {
+        "name": "CUDA cuFile",
+        "license": "CUDA Toolkit",
+        "license_path": "libcufile/LICENSE.txt",
+        "version": "1.8.1.2",
+        "linux-x86_64": {
+            "relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.8.1.2-archive.tar.xz",
+            "sha256": "3f71f3497a7a87dffc3e8c7dc06e128bb4d876eebd8719be94f366c62975035e",
+            "md5": "6386959420d4222ea5334137d5af8f62",
+            "size": "41870208"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcufile/linux-sbsa/libcufile-linux-sbsa-1.8.1.2-archive.tar.xz",
+            "sha256": "5800140ba9b1e0b32a862e6ea0ec2685fc67745dc5bdcd22a5b24284de021031",
+            "md5": "003dd09b8c5e4feb3f62e3f522c579e0",
+            "size": "41313804"
+        }
+    },
+    "libcurand": {
+        "name": "CUDA cuRAND",
+        "license": "CUDA Toolkit",
+        "license_path": "libcurand/LICENSE.txt",
+        "version": "10.3.4.107",
+        "linux-x86_64": {
+            "relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.3.4.107-archive.tar.xz",
+            "sha256": "ae34384e17563b2bb156f0491ef30a280298509a243e4c32e6edf507606bdb4d",
+            "md5": "cfeed245f30607b56b6160a300741d31",
+            "size": "81716044"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcurand/linux-ppc64le/libcurand-linux-ppc64le-10.3.4.107-archive.tar.xz",
+            "sha256": "610f80af681113a0903b82e76092fbf889d14f55dc4fd5c1dcd714de07118d0c",
+            "md5": "0e21ddfc42e2899e567b0080781d5278",
+            "size": "81760420"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.3.4.107-archive.tar.xz",
+            "sha256": "eaf641c5f29b3e8984c489bdfbe57f5c64711446e5ff83486b9e2e3d1da92d37",
+            "md5": "5bd87490c85063c801d46d123f0cd56e",
+            "size": "81703492"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.3.4.107-archive.zip",
+            "sha256": "8cae76b0ad0ef62623cc6ee2b64646d5628fd3f7cf753c264607462426e1c7d7",
+            "md5": "f174af47d4f023753810c9965ede4c35",
+            "size": "55100204"
+        }
+    },
+    "libcusolver": {
+        "name": "CUDA cuSOLVER",
+        "license": "CUDA Toolkit",
+        "license_path": "libcusolver/LICENSE.txt",
+        "version": "11.5.4.101",
+        "linux-x86_64": {
+            "relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.5.4.101-archive.tar.xz",
+            "sha256": "c271621cba76a12dd3cbddc491416f6cfea975bea695c418abb1f7fe281b8596",
+            "md5": "841b67ce5b0616cacc8547982336b5b9",
+            "size": "123457448"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcusolver/linux-ppc64le/libcusolver-linux-ppc64le-11.5.4.101-archive.tar.xz",
+            "sha256": "203089b6418ec1dcc5867eed897558ba4202c2891d3d80da0e4cd004c8b90dbd",
+            "md5": "9c8ecbda4426e77d5a2a693f60df53a2",
+            "size": "123578832"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.5.4.101-archive.tar.xz",
+            "sha256": "66cfb75fa2941b13b0ac287230f38b686369f9a8eb1eec01690095daf4205939",
+            "md5": "923abae537f3cb534019884749d22245",
+            "size": "122842936"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.5.4.101-archive.zip",
+            "sha256": "698149cd3bbd09ac8c426f95a7598d84e62f4452cde13c1d29f707f8091047b9",
+            "md5": "fb748b4fca3f9a0634d6e1ae7a47c86a",
+            "size": "120932643"
+        }
+    },
+    "libcusparse": {
+        "name": "CUDA cuSPARSE",
+        "license": "CUDA Toolkit",
+        "license_path": "libcusparse/LICENSE.txt",
+        "version": "12.2.0.103",
+        "linux-x86_64": {
+            "relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-12.2.0.103-archive.tar.xz",
+            "sha256": "2705bea3c1ae1f0eeb5850a32b9af58bd9d3ecacca6cd2a557236e11a1c46efa",
+            "md5": "ae8b0830e1fc621b7f4104fe815b82e3",
+            "size": "214793932"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libcusparse/linux-ppc64le/libcusparse-linux-ppc64le-12.2.0.103-archive.tar.xz",
+            "sha256": "f2625f9c514985cc5caf0dbec8b4c2be80cf2d16af4c6ff9dabbf02a5bff76ee",
+            "md5": "2d1889ea035b3ae2b613ddab34843ea2",
+            "size": "214834608"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-12.2.0.103-archive.tar.xz",
+            "sha256": "f356b0fff937946e661582362c754bec29314191613d26867db2b1625c06e208",
+            "md5": "e2cb3a9f6608dc9bfb9a1ded5f74ec35",
+            "size": "214460600"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-12.2.0.103-archive.zip",
+            "sha256": "1913315cc0cf73dff68266cd130c67884615ac410d92fa97f1726f71ff7c5a29",
+            "md5": "cdc4d725b30e0cf9e600b0ad127f0ca4",
+            "size": "192264843"
+        }
+    },
+    "libnpp": {
+        "name": "CUDA NPP",
+        "license": "CUDA Toolkit",
+        "license_path": "libnpp/LICENSE.txt",
+        "version": "12.2.3.2",
+        "linux-x86_64": {
+            "relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-12.2.3.2-archive.tar.xz",
+            "sha256": "280ec785dc356b8a61d895c3bc798338d62a3ca280429e48a32ed7d4386ddf5f",
+            "md5": "51104b94654927aeb9e3a353aacb2cff",
+            "size": "188167540"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libnpp/linux-ppc64le/libnpp-linux-ppc64le-12.2.3.2-archive.tar.xz",
+            "sha256": "5107ffc94d1312075ce06698a7e50671190b6725266660b23bffec1ae7d6d0d1",
+            "md5": "11aafbf67e094504207916c4bf614589",
+            "size": "187563296"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-12.2.3.2-archive.tar.xz",
+            "sha256": "1763612518fa9ad2be622d571561142780d05877f780607e83d8bd6f42d5a52f",
+            "md5": "517636ea62f7b37b4d55b3ae1e2a8fd6",
+            "size": "187600180"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-12.2.3.2-archive.zip",
+            "sha256": "e2ab4695d9cc1ac77973e817711f6452e70af61aad0e5cb5108927681a0adbc0",
+            "md5": "9cc1f2e4270a8207a64044b27d7a4153",
+            "size": "159177860"
+        }
+    },
+    "libnvidia_nscq": {
+        "name": "NVIDIA NSCQ API",
+        "license": "NVIDIA Driver",
+        "license_path": "libnvidia_nscq/LICENSE.txt",
+        "version": "545.23.08",
+        "linux-x86_64": {
+            "relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-545.23.08-archive.tar.xz",
+            "sha256": "4fc2aaf5352fb3ecbabf6b5c4a09087b0c01bc74788af0a44962aad23a345890",
+            "md5": "344aebed1125fe43a01eed34b248984f",
+            "size": "352604"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-545.23.08-archive.tar.xz",
+            "sha256": "cef34e4f6ea0884c3f06c98b1721c96beba68cc13224ddbc589612022d27df3a",
+            "md5": "cd495095c1b1fd7eaf1449fd444a093e",
+            "size": "319228"
+        }
+    },
+    "libnvjitlink": {
+        "name": "NVIDIA compiler library for JIT LTO functionality",
+        "license": "CUDA Toolkit",
+        "license_path": "libnvjitlink/LICENSE.txt",
+        "version": "12.3.101",
+        "linux-x86_64": {
+            "relative_path": "libnvjitlink/linux-x86_64/libnvjitlink-linux-x86_64-12.3.101-archive.tar.xz",
+            "sha256": "c66ebf27cf9bcfc584918c98eb7683ea2f5ab68c9c95c361ccb9e27d0520df13",
+            "md5": "bbc8a16bde8cf7887ae0354966a064c8",
+            "size": "26484404"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libnvjitlink/linux-ppc64le/libnvjitlink-linux-ppc64le-12.3.101-archive.tar.xz",
+            "sha256": "b37ab8489d53ad90ad23d73d5b67b41bedf1c2653c42c7adb2f5b8fda3a52344",
+            "md5": "6875800c5d9ee0108537cf11dce56508",
+            "size": "24033912"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvjitlink/linux-sbsa/libnvjitlink-linux-sbsa-12.3.101-archive.tar.xz",
+            "sha256": "cae34a104a8b61f061ba5f133792c28e2f6f6c0b6a726ff15c225a58649816d2",
+            "md5": "5f51d2ac50e3d2b501592cd8311b2f63",
+            "size": "24067016"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnvjitlink/windows-x86_64/libnvjitlink-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "05de293d0f8bb2c23fc5953ae725d2281bca7ddc2971ada55de246265ecc5842",
+            "md5": "7c9d6acb21db85eaca42db5be2398832",
+            "size": "90896453"
+        }
+    },
+    "libnvjpeg": {
+        "name": "CUDA nvJPEG",
+        "license": "CUDA Toolkit",
+        "license_path": "libnvjpeg/LICENSE.txt",
+        "version": "12.3.0.81",
+        "linux-x86_64": {
+            "relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-12.3.0.81-archive.tar.xz",
+            "sha256": "2ab40ef82d528b0ccdf5326754915f8d89991360d57ca56c58ff1c25c65c2236",
+            "md5": "3a6602b920bd9005e90896d67f44f896",
+            "size": "2584092"
+        },
+        "linux-ppc64le": {
+            "relative_path": "libnvjpeg/linux-ppc64le/libnvjpeg-linux-ppc64le-12.3.0.81-archive.tar.xz",
+            "sha256": "dd397f31c66b948d03971c9463487549bc401e7891eeea3c5558bf3d22302613",
+            "md5": "6e5518111ebfc41cdd8a9c525bcd621e",
+            "size": "2580252"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-12.3.0.81-archive.tar.xz",
+            "sha256": "dc25a4b967c6fa8ddcea1f90448af7d18eb24d332639488fc9ed0316eb60a919",
+            "md5": "6e50dfcd7a0c9a95184bd9ab00d51f23",
+            "size": "2411660"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-12.3.0.81-archive.zip",
+            "sha256": "6cd5fc8ae477ea67c6d11f6c9d04fcf382e43378ee774b8a52b94ac68ee68b8c",
+            "md5": "bd4d9808fdf5bc6eb6ba368bb224aaba",
+            "size": "2830315"
+        }
+    },
+    "nsight_compute": {
+        "name": "Nsight Compute",
+        "license": "NVIDIA SLA",
+        "license_path": "nsight_compute/LICENSE.txt",
+        "version": "2023.3.1.1",
+        "linux-x86_64": {
+            "relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2023.3.1.1-archive.tar.xz",
+            "sha256": "78934c8cc402401814ad6f0046173fdb4f0d2875c7bc70b99d472856d0d525b8",
+            "md5": "623be3a561380437a2293f24a24cee96",
+            "size": "737391740"
+        },
+        "linux-ppc64le": {
+            "relative_path": "nsight_compute/linux-ppc64le/nsight_compute-linux-ppc64le-2023.3.1.1-archive.tar.xz",
+            "sha256": "0e54bf8e887fd2c3bafe3576596b358404f5a81c358244143be6d155ae11982c",
+            "md5": "aa53c45e692d05cccf5580870d910a7a",
+            "size": "141240260"
+        },
+        "linux-sbsa": {
+            "relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2023.3.1.1-archive.tar.xz",
+            "sha256": "20023f701cc9a79fbe3c42f7b2fb3d3e30a562fae9ced2c5c4a2e707caecf4ab",
+            "md5": "0f6ac65ad7f21b58d2b8682de119f3d9",
+            "size": "360258864"
+        },
+        "windows-x86_64": {
+            "relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2023.3.1.1-archive.zip",
+            "sha256": "5b090609aacd8cb41ad56a848a0b637a568f62869af701a77f3f61ce46e7ce48",
+            "md5": "47adc1bff6b0181472dd93dec7a40729",
+            "size": "675520339"
+        }
+    },
+    "nsight_systems": {
+        "name": "Nsight Systems",
+        "license": "NVIDIA SLA",
+        "license_path": "nsight_systems/LICENSE.txt",
+        "version": "2023.3.3.42",
+        "linux-x86_64": {
+            "relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2023.3.3.42-archive.tar.xz",
+            "sha256": "dafded1be045abea2804697646178a66bec4a5eebb1b28b2637a37c2f22c7b93",
+            "md5": "34208b6d0c71444babf10a9bfeac86b0",
+            "size": "227696524"
+        },
+        "linux-ppc64le": {
+            "relative_path": "nsight_systems/linux-ppc64le/nsight_systems-linux-ppc64le-2023.3.3.42-archive.tar.xz",
+            "sha256": "5095fc2a432267c002fa84d14f8c09985c7ba17becb6095699d7407fcbe3234d",
+            "md5": "8f873649a9686b23c71ab4f5c575bf74",
+            "size": "67233156"
+        },
+        "linux-sbsa": {
+            "relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2023.3.3.42-archive.tar.xz",
+            "sha256": "93976454c75ca4dc6da28c7e8cc886cc21ec513d4e0f294f56b9afad245e4071",
+            "md5": "98e172f249dfa5da3eaa564a86179601",
+            "size": "198960916"
+        },
+        "windows-x86_64": {
+            "relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2023.3.3.42-archive.zip",
+            "sha256": "9049d2bd0f17d967f7c84f33eee04b83c6b65349e3b12f97a3a9211d411e0009",
+            "md5": "54e49f657acf7b5e337c77f94b9d0943",
+            "size": "348461444"
+        }
+    },
+    "nsight_vse": {
+        "name": "Nsight Visual Studio Edition (VSE)",
+        "license": "NVIDIA SLA",
+        "license_path": "nsight_vse/LICENSE.txt",
+        "version": "2023.3.1.23311",
+        "windows-x86_64": {
+            "relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2023.3.1.23311-archive.zip",
+            "sha256": "b5525a09194a7523fe7195f3e75a5060bff3603825f0c360b858052702b45c27",
+            "md5": "15cc72b370af5298daf8fcd6d06b798a",
+            "size": "527222171"
+        }
+    },
+    "nvidia_driver": {
+        "name": "NVIDIA Linux Driver",
+        "license": "NVIDIA Driver",
+        "license_path": "nvidia_driver/LICENSE.txt",
+        "version": "545.23.08",
+        "linux-x86_64": {
+            "relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-545.23.08-archive.tar.xz",
+            "sha256": "cccca4ef72d9e2ac5e61f8c3338b6fc1570bfc9592f99a5f35cfbeffa7a6d893",
+            "md5": "127fdc550adfbdaee21875e73dd19dbd",
+            "size": "372041236"
+        },
+        "linux-ppc64le": {
+            "relative_path": "nvidia_driver/linux-ppc64le/nvidia_driver-linux-ppc64le-545.23.08-archive.tar.xz",
+            "sha256": "645795a18372096ce669fc23cbecd6ae2600d83f327ab02c5bed7dee67ca0125",
+            "md5": "d1c60c8d36c2746f1196ca8d7fa71611",
+            "size": "100070028"
+        },
+        "linux-sbsa": {
+            "relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-545.23.08-archive.tar.xz",
+            "sha256": "2a7afa5648131b4ad04c566a6177aa93cd506849d89474f1627bf9fa9d245399",
+            "md5": "caa756359c00f9f8ddf7731587531aa2",
+            "size": "288674496"
+        }
+    },
+    "nvidia_fs": {
+        "name": "NVIDIA filesystem",
+        "license": "CUDA Toolkit",
+        "license_path": "nvidia_fs/LICENSE.txt",
+        "version": "2.18.3",
+        "linux-x86_64": {
+            "relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.18.3-archive.tar.xz",
+            "sha256": "4b2b045c932c1449f28be246b3b28658981e81507825d73a35e11e9450774ac4",
+            "md5": "74135e8f97454338505b58bbcc5483a5",
+            "size": "58448"
+        },
+        "linux-sbsa": {
+            "relative_path": "nvidia_fs/linux-sbsa/nvidia_fs-linux-sbsa-2.18.3-archive.tar.xz",
+            "sha256": "80bae8ef6f977e2aeecb392c00e056e579657632abb02eb75e86bbf306db6f50",
+            "md5": "f88dd5297012268400192de8877f4606",
+            "size": "58460"
+        }
+    },
+    "visual_studio_integration": {
+        "name": "CUDA Visual Studio Integration",
+        "license": "CUDA Toolkit",
+        "license_path": "visual_studio_integration/LICENSE.txt",
+        "version": "12.3.101",
+        "windows-x86_64": {
+            "relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-12.3.101-archive.zip",
+            "sha256": "207d1feca96de6cce11a38293ccaa39ea548527912395fcd225a0a61ea870a58",
+            "md5": "ed679d6582e39344cb7d961ad9b7e647",
+            "size": "518226"
+        }
+    }
+}

pkgs/development/cuda-modules/cuda/manifests/redistrib_12.5.1.json

···
+{
+    "release_date": "2024-07-01",
+    "release_label": "12.5.1",
+    "release_product": "cuda",
+    "cuda_cccl": {
+        "name": "CXX Core Compute Libraries",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cccl/LICENSE.txt",
+        "version": "12.5.39",
+        "linux-x86_64": {
+            "relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-12.5.39-archive.tar.xz",
+            "sha256": "837c4e27939478ffa3d2ad18f9a109b83c05afbe891769732c5c615e53081fc1",
+            "md5": "aa178bee2e001ca04731a00233f8df7a",
+            "size": "1200412"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-12.5.39-archive.tar.xz",
+            "sha256": "7052855e3624aeb4abf91b0b9deed68f91054f898b85abef1d511c29ce544cc2",
+            "md5": "2b8b166bbea49b1de2ec33f79855b90f",
+            "size": "1199624"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-12.5.39-archive.zip",
+            "sha256": "748c07d466556b1562cc46a0389948af1e3fd92cc667ebf697bf6a9a30e736de",
+            "md5": "9767f947432a866baa5a31039c17dd0b",
+            "size": "3339288"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cccl/linux-aarch64/cuda_cccl-linux-aarch64-12.5.39-archive.tar.xz",
+            "sha256": "850714c86724c6b29e3e236ab7944a365691bb25083857c3ae9685c708d58f17",
+            "md5": "829276b4cbb021841bfe0161b770e550",
+            "size": "1200908"
+        }
+    },
+    "cuda_compat": {
+        "name": "CUDA compat L4T",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_compat/LICENSE.txt",
+        "version": "12.5.36505571",
+        "linux-aarch64": {
+            "relative_path": "cuda_compat/linux-aarch64/cuda_compat-linux-aarch64-12.5.36505571-archive.tar.xz",
+            "sha256": "9f4cf3a00d380a9175aa7f75314eeb1d9ca190a78a763f07588f07919a9fabb2",
+            "md5": "c9105ec7834e52dbd08af979d3844ca2",
+            "size": "18729484"
+        }
+    },
+    "cuda_cudart": {
+        "name": "CUDA Runtime (cudart)",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cudart/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "2e92179494712a41e9ba979ac81909cccbc7cbbadac9c3e0fd217fd410270df5",
+            "md5": "da14f0eef5c16f0dd1c8b18ea9a7f80f",
+            "size": "1106276"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "4b0421f8cde1d3276682954c20d3a5089c6297cdb2f4f5ea070846a0e7170a25",
+            "md5": "9ed351ee42a153b0ae79e08dc11363ee",
+            "size": "1095644"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "079dd4349ee536a80308bfeb745a75b729d3957a430dd1cd0051bbd26fe4007e",
+            "md5": "5fe0de7bbdff5b9de31a58524bec03b7",
+            "size": "2488589"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cudart/linux-aarch64/cuda_cudart-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "fb2108b7af85d7334d06accc44080e4da0a8caec0069b0e89ce4d6a7e08e2d64",
+            "md5": "dbd9fc3f3d7ee99191a7012689fc0d04",
+            "size": "1156376"
+        }
+    },
+    "cuda_cuobjdump": {
+        "name": "cuobjdump",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cuobjdump/LICENSE.txt",
+        "version": "12.5.39",
+        "linux-x86_64": {
+            "relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-12.5.39-archive.tar.xz",
+            "sha256": "aaeb67ca9d9e4a024d8e7974c89c194abe75997b71aedfbf137a5755fe6b3bff",
+            "md5": "5788f59668e766d5c5ae888b03f45a8e",
+            "size": "217844"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-12.5.39-archive.tar.xz",
+            "sha256": "4ee35638cdd9848a79fc3edda02a8cba9eca0bd75006ce945663f512ccfdb0d6",
+            "md5": "93adc92e12cc88676e50dfafe0549917",
+            "size": "207640"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-12.5.39-archive.zip",
+            "sha256": "39ca9868db618af029cbbcf36950fbd02dbbc2e8dcb61758a68ae5ebb70dd6d9",
+            "md5": "27602ed464175243cb7820e637dde8f6",
+            "size": "4223325"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cuobjdump/linux-aarch64/cuda_cuobjdump-linux-aarch64-12.5.39-archive.tar.xz",
+            "sha256": "1374a78b9598b67e9b57b898bdc4e67992070e40ecaa3f29fd5603c25dbe9d6f",
+            "md5": "d7b05a9a6339f4e9be12e84003ffc0d1",
+            "size": "195076"
+        }
+    },
+    "cuda_cupti": {
+        "name": "CUPTI",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cupti/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "5054985d6454cdb1ef67a3baacd19cac98a89fe8d39fd31bd727bfa65eed6b0a",
+            "md5": "f4a00ff36cfd9d2ea83da0799d6d7ecc",
+            "size": "20789416"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "1fe17ad05fa001d06e9a3aacd1720d956a9d370e8d9a25349aee8bfa3d42bf2c",
+            "md5": "5830f10c489beaac533117b263f5c324",
+            "size": "11317604"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "efaaa348b74d697f5f8267c3d49132b43fa71127ed74310696b94c4d26a2eb49",
+            "md5": "b9a271a9440519a9e27b23055aeecab5",
+            "size": "14911905"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cupti/linux-aarch64/cuda_cupti-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "ca4f11504c336146e6b4fd5c6d363607e5c41aaf7cfbd917db7e3e06aa869cab",
+            "md5": "f8f0ef7a786abf0220aba79ef2e90c25",
+            "size": "8050824"
+        }
+    },
+    "cuda_cuxxfilt": {
+        "name": "CUDA cuxxfilt (demangler)",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cuxxfilt/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "24d131d9ee45d4096ff617fbaa93dc175a387b6f9300829040d4bd94511564d2",
+            "md5": "28b1f35dbdc21a62fb1b99e9f8435916",
+            "size": "188308"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "9f3542cc095b283c6e35471afd493d970b46d305d0b39361bc646acd0ec214cc",
+            "md5": "b774de0528a21c1d8dfd719515d37b7c",
+            "size": "177496"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "3805c9ec6c9bbe323e1677aa2338ecdcc72ef217402281ac4b4065a473f1dca4",
+            "md5": "8fa5475be1c9e91bf2f4961a49876f50",
+            "size": "170575"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cuxxfilt/linux-aarch64/cuda_cuxxfilt-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "2441e488f0114dacf5f44b8e1b7acdcba0da4469f35bc377edcbac9f87f80ed6",
+            "md5": "fb2d456d467cf750c59baba4079faf81",
+            "size": "170080"
+        }
+    },
+    "cuda_demo_suite": {
+        "name": "CUDA Demo Suite",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_demo_suite/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "da777a9d688160359659c5b9efa2713e8b30a56e2753e0232e37d77ac2d33c83",
+            "md5": "d94e838576d2b58e9c443a9ea0d3e5b1",
+            "size": "3989036"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "5003fe6758f6ce1e9c341eeda149eabd77f2236d033258a17b05263070b1c2b5",
+            "md5": "6fc684e4ec2ef235ad9a45214368aa40",
+            "size": "5064355"
+        }
+    },
+    "cuda_documentation": {
+        "name": "CUDA Documentation",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_documentation/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "e68fc3b2cfbe7cf8cee048dbe70986c4d0f86a7da2e901e045d369bae5270527",
+            "md5": "6dec210d4a129983f3671f3df2b484cd",
+            "size": "67320"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "ebb834f54d34eb66eaaa982e5cd37754c01e8b5259177cdb4cb1ae1647773e02",
+            "md5": "9ca24df4a742d87e8bf034439a385827",
+            "size": "67184"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "54ee6f09aaeeada8b3682cf150d04fd1e7273206c1fedbd7300f535eebe3f52f",
+            "md5": "3a081bd9915079974529e53f60d846ec",
+            "size": "105658"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_documentation/linux-aarch64/cuda_documentation-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "4b60a9f2a16cf3d1a27500a666e02b46d5811ed78e8f58b802d05cbecbfe8339",
+            "md5": "b2157b172ea83ce67c9423f2f8b8fc9c",
+            "size": "67052"
+        }
+    },
+    "cuda_gdb": {
+        "name": "CUDA GDB",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_gdb/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "25bc68ff2ec6133ad7271aece6535f4820b057821421d16932a8c9080b162520",
+            "md5": "782a5ab410f402dea98643018e0b92ad",
+            "size": "66192652"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "0cecc82647b80b42c3e7cd934485407588d0143917ebd3673bfaf935855ef252",
+            "md5": "63c6c99f1b8b60df839bdc103e26a48d",
+            "size": "43791708"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_gdb/linux-aarch64/cuda_gdb-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "d285b73ed1df5ea5a691ca8f18d48a62235adb549269b24cb8fd2d2eac1a451f",
+            "md5": "4d7512e2ee05948e2aad90f86a43c246",
+            "size": "43694356"
+        }
+    },
+    "cuda_nsight": {
+        "name": "Nsight Eclipse Edition Plugin",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nsight/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "3250e4670ebe2729b0d2e3075493473f00d007e813de0eb14b65c8a5ec62e984",
+            "md5": "4c0d97ac6f6fd4962300d53e646c5890",
+            "size": "118683344"
+        }
+    },
+    "cuda_nvcc": {
+        "name": "CUDA NVCC",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvcc/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "ded05fe3c8d075c6c1bf892005d3c50bde3eceaa049b879fcdff6158e068e3be",
+            "md5": "ea26f9d1fea3a355064feb61bb8e2e50",
+            "size": "51687876"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "345a80c87627a414516e1bfdd99ec97f6a02039c9b82b2610bc5a93e035ca954",
+            "md5": "03a918bb58c49e05c1e489b6fb8a8c0a",
+            "size": "45264504"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "51cec40087b524478c4d204a102ad5de86cd30d0bd2f9e87339032b55296448b",
+            "md5": "1cda218e27ac1d7be9943319eabbc998",
+            "size": "79630604"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvcc/linux-aarch64/cuda_nvcc-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "76f57ce3e4294fe9f69eb93b04ab294f696d5e7cde996f33929e68fdde7ab462",
+            "md5": "40120c80e89585e5d29a12c27bf974d8",
+            "size": "46840484"
+        }
+    },
+    "cuda_nvdisasm": {
+        "name": "CUDA nvdisasm",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvdisasm/LICENSE.txt",
+        "version": "12.5.39",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-12.5.39-archive.tar.xz",
+            "sha256": "fa775b95352302585732644bdd3254a210ccbe477fe5ab85f81956299ca40909",
+            "md5": "22acb62e972a1ff2d9bdf161516c24cb",
+            "size": "49895304"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-12.5.39-archive.tar.xz",
+            "sha256": "b6a2a8f74cb4ccf5f489308b95568e24917fd384471f0e41235d2a48c2d71729",
+            "md5": "f4c4e8e0b722f6d1e48f4d0937fd7d14",
+            "size": "49810460"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-12.5.39-archive.zip",
+            "sha256": "2b378494913d9e86c9f6210c2e5389df2fe9de1be1b1dd4a229b86f2bca0cd98",
+            "md5": "67ce76f6d57eb80a5c70b7dd3d786f0a",
+            "size": "50153445"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvdisasm/linux-aarch64/cuda_nvdisasm-linux-aarch64-12.5.39-archive.tar.xz",
+            "sha256": "07c6861cef0953997feaca5d897a8b15ab7466f193c9f7c07b6ef34dae710a23",
+            "md5": "bb17a840f1c18d2c35446944ca7ee4d4",
+            "size": "49832920"
+        }
+    },
+    "cuda_nvml_dev": {
+        "name": "CUDA NVML Headers",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvml_dev/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "52991dfd16427cf7c99b808b3ff259a1064cec11a8663c7a76611704d4990903",
+            "md5": "d35cee9fcc88d9705011c98db773d574",
+            "size": "143876"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "529a79fc189088004e1929961f06c978052aea9cec0db93eecf74e51e3bfe608",
+            "md5": "3a22a1f39556d0c8e0f60b106756d1e3",
+            "size": "146604"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "9826ff7f00ed6ae9a8787cd6a20b935114bef7a22bb64ad2490dfd5f13eebb30",
+            "md5": "48a8d7a915deb29f284e0157ad75deef",
+            "size": "128184"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvml_dev/linux-aarch64/cuda_nvml_dev-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "13ff2985c3074239461458a1fe3a44449642b9345360f7a297a95d7e5a3c954c",
+            "md5": "52a91607a85221b23f594e7c3157849d",
+            "size": "146740"
+        }
+    },
+    "cuda_nvprof": {
+        "name": "CUDA nvprof",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvprof/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "ff3750690c2d3e085dae08c31d31064364cb68d89d96fb2dc0f3adac7c19ad72",
+            "md5": "b4e40b9ddd48cc964ad64341428c704d",
+            "size": "2436132"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "d2e6c92b116b940d7bd689af21f77c4783b86f6dd9afa00dd0c856335ddd0e39",
+            "md5": "1984ed508759a187e41604f2ecef436f",
+            "size": "1702615"
+        }
+    },
+    "cuda_nvprune": {
+        "name": "CUDA nvprune",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvprune/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "afced555949fb3be875d467fcbf6903166917aa5ad42672f1ceca0a972d6b49f",
+            "md5": "e1739ef9ddfc01a4c522a4afff9dcdfb",
+            "size": "56904"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "ab2fa66bce3553b6a497575d476c81105d8d8c3f2b3646eb52a6edb624cc2b14",
+            "md5": "8daba43096a5d323c0bc747552723384",
+            "size": "48920"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "d3de38ab97d772e7a002fdedbf0fc3cb701c18a3602e54d05282337bc70b7707",
+            "md5": "ef77b32b6f7a23e68676b2913f0480db",
+            "size": "146639"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvprune/linux-aarch64/cuda_nvprune-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "4dd0f3e1229998e0aae5d196d8458bb9b80deccae1b5955ff92c7ff9942aa854",
+            "md5": "05944a2a3213629109c0bd8ce1d7f42b",
+            "size": "50656"
+        }
+    },
+    "cuda_nvrtc": {
+        "name": "CUDA NVRTC",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvrtc/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "6745275167fd1c84f95cab9117066a7c41178cd26d4615ae685cb1b777b456b1",
+            "md5": "524c2f9b14ed8dcf502aa03c5d060510",
+            "size": "34189932"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "a086a54a207477eb7e89ac670021bab514faf689d9ebbe67f5d26cf70c441610",
+            "md5": "fd59c73266a8ccdabc304dbd885b1a2e",
+            "size": "31681388"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "0bc5443fe432d69495412e1ee275fcc5f7590a65bda360ee5e25c20eb192632e",
+            "md5": "4b803550386a0045c4536f038248cc8b",
+            "size": "187054336"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvrtc/linux-aarch64/cuda_nvrtc-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "9a10a8cccd427fc6e47ab6632267c72579d19801b3c0fd2066cd9ef3669d9b83",
+            "md5": "9d6e25cd90c5ad00193f5529a00cdfc3",
+            "size": "32917400"
+        }
+    },
+    "cuda_nvtx": {
+        "name": "CUDA NVTX",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvtx/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "f12a029386f8fbd87f71311d8f4cc51a94414b997c52cf5eabc62c83c655ea47",
+            "md5": "4480413ab9426f999c866ae8f59af806",
+            "size": "48492"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "8a0d3787f1cce8db70cbad05e6303e72602415c171f8a383da4d1118ce5e89b3",
+            "md5": "b78f9f24b2816b44518aafdbdd83e08d",
+            "size": "49120"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "07f301cff5390b9b56361dda033c2f467f1bddbe3609285afa5a79f31c6e38d6",
+            "md5": "474ef9b449c1731723468a0ccab807f8",
+            "size": "65837"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvtx/linux-aarch64/cuda_nvtx-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "8289c3e857f74ef53b2960d19fd211324a62f72169f2bc5d1fb0a7f26889c2f6",
+            "md5": "0ef0b905e0be2cf1e99c76970af1654f",
+            "size": "51720"
+        }
+    },
+    "cuda_nvvp": {
+        "name": "CUDA NVVP",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvvp/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "2031d1a86ba91f2deaa2cea115e2c49c65766fb93bbadd780257789a0924207c",
+            "md5": "a49ce8919b3321e9e13f7fada49c3e8e",
+            "size": "117718568"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "d82f6452cbd9194690e054feb6ae1c00e4c110fe6b8419221cc92efa6ceebdd5",
+            "md5": "f7c10c359e14a24aa7d3966008e965e2",
+            "size": "120340741"
+        }
+    },
+    "cuda_opencl": {
+        "name": "CUDA OpenCL",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_opencl/LICENSE.txt",
+        "version": "12.5.39",
+        "linux-x86_64": {
+            "relative_path": "cuda_opencl/linux-x86_64/cuda_opencl-linux-x86_64-12.5.39-archive.tar.xz",
+            "sha256": "e754a2d3b95b52602d68f011a8b8e9bdfce16eaf5f9bb281503ab503d24d12f4",
+            "md5": "d215116f98cbd9bb754712e0885cd416",
+            "size": "92184"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_opencl/windows-x86_64/cuda_opencl-windows-x86_64-12.5.39-archive.zip",
+            "sha256": "0b01ecdd86229e7e2cb58933cc9204a636767c885a5659752d46296d376427bb",
+            "md5": "85087c5b356945928ec086c9017311c7",
+            "size": "137329"
+        }
+    },
+    "cuda_profiler_api": {
+        "name": "CUDA Profiler API",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_profiler_api/LICENSE.txt",
+        "version": "12.5.39",
+        "linux-x86_64": {
+            "relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-12.5.39-archive.tar.xz",
+            "sha256": "4dfefe155e042d1e00a7a8d847a2d886ca5f39a7019dd14ae72b69aaf6e94986",
+            "md5": "48eb7058e4352518fcc1a8a88474ff49",
+            "size": "16168"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-12.5.39-archive.tar.xz",
+            "sha256": "09417ae94cbfe41203b825906083a7658e3ba7b4380fb6de7e896fc741d3046c",
+            "md5": "14c620b09b47202140cc41ef87bcafb4",
+            "size": "16168"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-12.5.39-archive.zip",
+            "sha256": "1397be6e24a773dab8550ba9df2231dde2dca7a4a15c48363bd03621a48fee91",
+            "md5": "6d5038cda340581274073141bb829829",
+            "size": "20222"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_profiler_api/linux-aarch64/cuda_profiler_api-linux-aarch64-12.5.39-archive.tar.xz",
+            "sha256": "5895e01303f58d5ee2e18d3fbed3db5447342b4d52ca75193666bb1b60be51a4",
+            "md5": "ff5db05a57ab712adc0e4fe5d9a3a7af",
+            "size": "16180"
+        }
+    },
+    "cuda_sanitizer_api": {
+        "name": "CUDA Compute Sanitizer API",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_sanitizer_api/LICENSE.txt",
+        "version": "12.5.81",
+        "linux-x86_64": {
+            "relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-12.5.81-archive.tar.xz",
+            "sha256": "2c86bd1b37bc9b085914076e0db0122c667da32aa62463edd8bdcfc047eb10e3",
+            "md5": "45187c4b8426971972c9d43ed3d24a30",
+            "size": "8539520"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-12.5.81-archive.tar.xz",
+            "sha256": "f76b88164b0642ddf6ff80031ed35bd3b851512b8af405cf6838351c518a8000",
+            "md5": "a0dca8f9226fec8c35b5f67bdabca4d3",
+            "size": "6472844"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-12.5.81-archive.zip",
+            "sha256": "09a8e3438cae3a2f391f3befe7d092bfd2c2157ec4383e5494a2904a2d708ca3",
+            "md5": "6b512975fd30874955d66c6755d0ddde",
+            "size": "14150887"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_sanitizer_api/linux-aarch64/cuda_sanitizer_api-linux-aarch64-12.5.81-archive.tar.xz",
+            "sha256": "bd14ce734d61b2545b7a92b0d2212555a747dec0e8e4de9b956cbf0bc05ce4c3",
+            "md5": "9be2da4482e894a42be51aead752903d",
+            "size": "3821148"
+        }
+    },
+    "fabricmanager": {
+        "name": "NVIDIA Fabric Manager",
+        "license": "NVIDIA Driver",
+        "license_path": "fabricmanager/LICENSE.txt",
+        "version": "555.42.06",
+        "linux-x86_64": {
+            "relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-555.42.06-archive.tar.xz",
+            "sha256": "e9fde09dab3474b2e9f71bdb7f31b179f12a5023c67dc5b73fb267af4402f6c6",
+            "md5": "5284b959080ed610324668f6ed5ce33e",
+            "size": "5805572"
+        },
+        "linux-sbsa": {
+            "relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-555.42.06-archive.tar.xz",
+            "sha256": "89acd66b0622cbb1bf05025e8ba8a1d7db9cf82081a808bec1960f5cccc29fa0",
+            "md5": "70a043fb0504ef67ce7438c5e844829a",
+            "size": "5239004"
+        }
+    },
+    "imex": {
+        "name": "Nvidia-Imex",
+        "license": "NVIDIA Proprietary",
+        "license_path": "imex/LICENSE.txt",
+        "version": "555.42.06",
+        "linux-x86_64": {
+            "relative_path": "imex/linux-x86_64/nvidia-imex-linux-x86_64-555.42.06-archive.tar.xz",
+            "sha256": "91fa5001dfe985519ffff015b545893fb917ff401942103e8d999b43fa1e1828",
+            "md5": "60dffe74401a419378b3c5c78767bbaf",
+            "size": "7331868"
+        },
+        "linux-sbsa": {
+            "relative_path": "imex/linux-sbsa/nvidia-imex-linux-sbsa-555.42.06-archive.tar.xz",
+            "sha256": "c26979b1d0f6a4d2ce77ad0190fcccc5de83fb2b2b6450813e2059180fa48720",
+            "md5": "37409d412e0868395dc806ca847a4a3c",
+            "size": "6536312"
+        }
+    },
+    "libcublas": {
+        "name": "CUDA cuBLAS",
+        "license": "CUDA Toolkit",
+        "license_path": "libcublas/LICENSE.txt",
+        "version": "12.5.3.2",
+        "linux-x86_64": {
+            "relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-12.5.3.2-archive.tar.xz",
+            "sha256": "5cac4f3cf97aebc947442aad606069cb747dc585c5b36cb022770046d984d9da",
+            "md5": "79fef7e2cb333b07f506458e570b34cc",
+            "size": "490244196"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-12.5.3.2-archive.tar.xz",
+            "sha256": "136491297d7bcedad4449ac442557ae0c583b8408bad4dde5223c4acf387dce1",
+            "md5": "350710e77f110438a8b8670c9447bb21",
+            "size": "488650160"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-12.5.3.2-archive.zip",
+            "sha256": "d3628039eb3d39ba9fe6a5350447b10483dd13d5973b5e4cde1d3e917d457d01",
+            "md5": "40121a00c01df1791160fb2d291a8458",
+            "size": "392940930"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcublas/linux-aarch64/libcublas-linux-aarch64-12.5.3.2-archive.tar.xz",
+            "sha256": "90d2f6abfc66ce6226cd42af54f0e94adf8c49be3e161cf4cb31c6c01441e42c",
+            "md5": "98fb0c138ac1e8a147f87b69d09b662d",
+            "size": "433236344"
+        }
+    },
+    "libcudla": {
+        "name": "cuDLA",
+        "license": "CUDA Toolkit",
+        "license_path": "libcudla/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-aarch64": {
+            "relative_path": "libcudla/linux-aarch64/libcudla-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "874e64e52cbfe7abc3aaf4df0593d340e166671b71f4aa693fc8f17bc77bb05e",
+            "md5": "1d8bd670086190a99cd89fd72694b1e0",
+            "size": "38560"
+        }
+    },
+    "libcufft": {
+        "name": "CUDA cuFFT",
+        "license": "CUDA Toolkit",
+        "license_path": "libcufft/LICENSE.txt",
+        "version": "11.2.3.61",
+        "linux-x86_64": {
+            "relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-11.2.3.61-archive.tar.xz",
+            "sha256": "c69cc32712f2396aaf497894945572e8c3e2668b89614e1a56c2d8e3cece4e54",
+            "md5": "5abb4f9ecf5f4eb5af13fc9bb100877f",
+            "size": "453127556"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-11.2.3.61-archive.tar.xz",
+            "sha256": "50831766eb16a52a803484e746197d604e5e5181fdadbc0fbfaf90ff90e6b18f",
+            "md5": "7a855c8afa71a5a577c9dec9ca1fa1fe",
+            "size": "453105776"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-11.2.3.61-archive.zip",
+            "sha256": "afe77d89bce4ee669516597bfb635adddc156988409ee2e220f7b492fe81201e",
+            "md5": "6a4d81e5cde4ee3de495ce9f5d741360",
+            "size": "189989107"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcufft/linux-aarch64/libcufft-linux-aarch64-11.2.3.61-archive.tar.xz",
+            "sha256": "314e7437de38a69e0ea38db79525174e0fab99c4720532acdfe74efe89804dbb",
+            "md5": "0177ef0599c2d44261f6d19e432f251c",
+            "size": "453207636"
+        }
+    },
+    "libcufile": {
+        "name": "CUDA cuFile",
+        "license": "CUDA Toolkit",
+        "license_path": "libcufile/LICENSE.txt",
+        "version": "1.10.1.7",
+        "linux-x86_64": {
+            "relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.10.1.7-archive.tar.xz",
+            "sha256": "4198c85cabadd8f3744d0a84b88d8d80173fca0ab2216b49214be05c5e6155d5",
+            "md5": "1a1ea838dbe086aeb19f2d095afd65c0",
+            "size": "41843020"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcufile/linux-sbsa/libcufile-linux-sbsa-1.10.1.7-archive.tar.xz",
+            "sha256": "63b0b113709a1e3b7ffef27199ae017330b6d68b0c5e87526294e71e7179ddc5",
+            "md5": "fa0ce44ec65e5d79ec08a29f2424da05",
+            "size": "41298932"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcufile/linux-aarch64/libcufile-linux-aarch64-1.10.1.7-archive.tar.xz",
+            "sha256": "516daa26f7715da233592f552e80ef2986b1929351d732b251486e5538c31d93",
+            "md5": "6c62ddb80f3e5cbf1c0b6a26fbb6b6fc",
+            "size": "41264800"
+        }
+    },
+    "libcurand": {
+        "name": "CUDA cuRAND",
+        "license": "CUDA Toolkit",
+        "license_path": "libcurand/LICENSE.txt",
+        "version": "10.3.6.82",
+        "linux-x86_64": {
+            "relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.3.6.82-archive.tar.xz",
+            "sha256": "af41597788fd30eb5ccae390be5fe0db59b0a3285a8db97de604a75eeaac93f7",
+            "md5": "6fa9b816ea551f992756a7e8b69afde2",
+            "size": "81700968"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.3.6.82-archive.tar.xz",
+            "sha256": "35584cad6b5908d69ace5bc223e96cadcc7f2940d71468535503033fcbd9a7f3",
+            "md5": "130469d5157de7b51e09977245b1b2a9",
+            "size": "81685744"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.3.6.82-archive.zip",
+            "sha256": "49f1d18d35af5b446b47d81757f822c054058bade9107c4d96e42b06baafaa2c",
+            "md5": "45a1d93c726428d9f24fa175285447e8",
+            "size": "55085680"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcurand/linux-aarch64/libcurand-linux-aarch64-10.3.6.82-archive.tar.xz",
+            "sha256": "e5dfb488e1a232e35b159d89de01755389e175d1d39e8d1841fbd5ef98457c41",
+            "md5": "9cb2736be27ce7d902826171cf864982",
+            "size": "83909736"
+        }
+    },
+    "libcusolver": {
+        "name": "CUDA cuSOLVER",
+        "license": "CUDA Toolkit",
+        "license_path": "libcusolver/LICENSE.txt",
+        "version": "11.6.3.83",
+        "linux-x86_64": {
+            "relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.6.3.83-archive.tar.xz",
+            "sha256": "f2fae41cd7637e22cb539c79dc44845cbd7ab932f006c5a8faf459a89054bf7f",
+            "md5": "f651fb361354f3d5d48f22856c7cea08",
+            "size": "129904672"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.6.3.83-archive.tar.xz",
+            "sha256": "846d86d8f4e5af49abd311d158cab5c2affbb47d65942735cca3310d32c55751",
+            "md5": "ced65f6dbdb46f220b77af8f2bad299e",
+            "size": "129073208"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.6.3.83-archive.zip",
+            "sha256": "2f4d929f206937e9d87d7ef6e5340923e4d8a47db1dbdd560eb968cf53b9ea47",
+            "md5": "80ec1591594c35ccda0f7061fd408649",
+            "size": "125989954"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcusolver/linux-aarch64/libcusolver-linux-aarch64-11.6.3.83-archive.tar.xz",
+            "sha256": "eff8e95800dfb3cc332b26e93e6ecfe6c1c95a4e185ed48adc95fa8d3b6fbd6f",
+            "md5": "1ec6884593ce4327269ea10e8b2a0f7f",
+            "size": "141195340"
+        }
+    },
+    "libcusparse": {
+        "name": "CUDA cuSPARSE",
+        "license": "CUDA Toolkit",
+        "license_path": "libcusparse/LICENSE.txt",
+        "version": "12.5.1.3",
+        "linux-x86_64": {
+            "relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-12.5.1.3-archive.tar.xz",
+            "sha256": "2b1c4295f7c5d57b986268086ee3e05b599afcc6fe303ccacf393cda2a7b1aff",
+            "md5": "d86d9b52332c189104e89c13ca0ab62f",
+            "size": "236855792"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-12.5.1.3-archive.tar.xz",
+            "sha256": "a93e0e59c378405de53a47363759fdeed30c1c9b23df98a4b86dc375a77e56d8",
+            "md5": "154f94fc89d22d5b50ef54fae08c22ab",
+            "size": "236438924"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-12.5.1.3-archive.zip",
+            "sha256": "c526cbf7db1fff65229433733027ef4e8daeec36dc7cd8f3043754ebca704da3",
+            "md5": "7554101787fc62098d08e93796cecf30",
+            "size": "212374153"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcusparse/linux-aarch64/libcusparse-linux-aarch64-12.5.1.3-archive.tar.xz",
+            "sha256": "d1c083686f8dbb7db77160d6a14eef940f587fb8942be024a2f3a32aff1d72cc",
+            "md5": "85a955b8e58d836acea8ddab9383dc80",
+            "size": "254219868"
+        }
+    },
+    "libnpp": {
+        "name": "CUDA NPP",
+        "license": "CUDA Toolkit",
+        "license_path": "libnpp/LICENSE.txt",
+        "version": "12.3.0.159",
+        "linux-x86_64": {
+            "relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-12.3.0.159-archive.tar.xz",
+            "sha256": "5bcb6af62e3affac26c7716bc3d91c1b69ecdd86668a7dc62f3a9c7bf25edd11",
+            "md5": "0315f315a6b2eb441288bc98547754cf",
+            "size": "184260856"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-12.3.0.159-archive.tar.xz",
+            "sha256": "0a109d01c2a497e18630f06ff5c407c59346d93e5cb7d48916cce6f1de0a1d05",
+            "md5": "cddc03965f1244722ec6f5e4363292cc",
+            "size": "184506068"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-12.3.0.159-archive.zip",
+            "sha256": "1aa7e6243dffebeb7aa9c50a64f64c4af37d2eacf639e624ff97f3c3f0cf7dc0",
+            "md5": "38b25dca7eaaf92fc07b16374e8e0a8d",
+            "size": "157072527"
+        },
+        "linux-aarch64": {
+            "relative_path": "libnpp/linux-aarch64/libnpp-linux-aarch64-12.3.0.159-archive.tar.xz",
+            "sha256": "fd5241c8657851d159ac11bab351ed42a2bc2930a447aa5aa21b725f659fd36d",
+            "md5": "2996db520d7bc71eec9e63843efc83d9",
+            "size": "202520548"
+        }
+    },
+    "libnvfatbin": {
+        "name": "NVIDIA compiler library for fatbin interaction",
+        "license": "CUDA Toolkit",
+        "license_path": "libnvfatbin/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "libnvfatbin/linux-x86_64/libnvfatbin-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "d04cc1a3ff99cd2022a10293beec12f3590344fe23ef3dc0eff5178a65a8c728",
+            "md5": "cd26d7b2ec80780e675595fb41ba9502",
+            "size": "909052"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvfatbin/linux-sbsa/libnvfatbin-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "fa975e8a90ec8473e60ca41b65a379a9258601c3243d8354959df21e23318df8",
+            "md5": "46ddc2e60b63164195479520f5b387bf",
+            "size": "810644"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnvfatbin/windows-x86_64/libnvfatbin-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "8c3733310059c64650b8b0e1da4ec46e9c4aa24cb7c7411c1d3b37035b9c620b",
+            "md5": "b92b8459a06330f53a552df0c88326a9",
+            "size": "2134142"
+        },
+        "linux-aarch64": {
+            "relative_path": "libnvfatbin/linux-aarch64/libnvfatbin-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "a7a103ffacc1e5226a8147c371144f3a32789095c71e3c6cf74b8db90b915e07",
+            "md5": "c95d8d95640f1d24af75c7d50b40f48a",
+            "size": "784440"
+        }
+    },
+    "libnvidia_nscq": {
+        "name": "NVIDIA NSCQ API",
+        "license": "NVIDIA Driver",
+        "license_path": "libnvidia_nscq/LICENSE.txt",
+        "version": "555.42.06",
+        "linux-x86_64": {
+            "relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-555.42.06-archive.tar.xz",
+            "sha256": "e1b0be458914bc29119dd6e8cbaa596960f2e1f0db87a9e50d6877cb6a68675a",
+            "md5": "5d59e7e1a2c93e6c7a2f97e485672ba2",
+            "size": "352772"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-555.42.06-archive.tar.xz",
+            "sha256": "c1fdc42798a1c8f7a1c18bf2bc5fa2c6647f93c187916097e785674efdb768e1",
+            "md5": "aded2da9827d0662192f3666c3ab25d0",
+            "size": "346884"
+        }
+    },
+    "libnvjitlink": {
+        "name": "NVIDIA compiler library for JIT LTO functionality",
+        "license": "CUDA Toolkit",
+        "license_path": "libnvjitlink/LICENSE.txt",
+        "version": "12.5.82",
+        "linux-x86_64": {
+            "relative_path": "libnvjitlink/linux-x86_64/libnvjitlink-linux-x86_64-12.5.82-archive.tar.xz",
+            "sha256": "cbe265b0b2db1e99468191d9cab896bf94a532dfb41827f17ed8e91d0ea0b5dd",
+            "md5": "bb7d7a50c162ee2bb07f27db1bef190d",
+            "size": "29454740"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvjitlink/linux-sbsa/libnvjitlink-linux-sbsa-12.5.82-archive.tar.xz",
+            "sha256": "7fcbd26170ee91891e497f728cd25c91c61e23ff490eef2aaf4791b3535cda7d",
+            "md5": "d89d18b59d048c8231b0357683202d23",
+            "size": "26917044"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnvjitlink/windows-x86_64/libnvjitlink-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "410e0bd78ee7e89e9b0ddbeb6825c898a18d7fb637450db8df6b3fec57c2a5bd",
+            "md5": "9d22664b4e22f9c8014f13401d121167",
+            "size": "152952500"
+        },
+        "linux-aarch64": {
+            "relative_path": "libnvjitlink/linux-aarch64/libnvjitlink-linux-aarch64-12.5.82-archive.tar.xz",
+            "sha256": "359ee281f4e8ef4c50163659d9efd1e4e3b677ad045013ad40af9bb86bcfda68",
+            "md5": "cb1fabfe2827102eb6b9e4f6d827186f",
+            "size": "28159356"
+        }
+    },
+    "libnvjpeg": {
+        "name": "CUDA nvJPEG",
+        "license": "CUDA Toolkit",
+        "license_path": "libnvjpeg/LICENSE.txt",
+        "version": "12.3.2.81",
+        "linux-x86_64": {
+            "relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-12.3.2.81-archive.tar.xz",
+            "sha256": "e39aebec1678033184f666d0ab0114c8c55c2e0dfae3e310ede9c42d3ee3957a",
+            "md5": "c507a27d4183ae8b81f81e46e6e258a1",
+            "size": "2584788"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-12.3.2.81-archive.tar.xz",
+            "sha256": "1d0da2db76adc55441385e334a439db064b4b2f38b09dc37a29681de973d5a9d",
+            "md5": "9ef0a31458a3b51c635ddec911426f12",
+            "size": "2422156"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-12.3.2.81-archive.zip",
+            "sha256": "c543b35b16ab5bc696cddd7ede02c15714643a1b1458ca2c041efe04c01d9c01",
+            "md5": "6bd2d7efa5657c1e14e4eb0b82f48b5a",
+            "size": "2835792"
+        },
+        "linux-aarch64": {
+            "relative_path": "libnvjpeg/linux-aarch64/libnvjpeg-linux-aarch64-12.3.2.81-archive.tar.xz",
+            "sha256": "559165ea790b5471b5b072f5f97caaace8a7ddacf27280f57a2de9cf7f10c522",
+            "md5": "491bc2257755acdc4fb459d78b7a4fc2",
+            "size": "2564048"
+        }
+    },
+    "nsight_compute": {
+        "name": "Nsight Compute",
+        "license": "NVIDIA SLA",
+        "license_path": "nsight_compute/LICENSE.txt",
+        "version": "2024.2.1.2",
+        "linux-x86_64": {
+            "relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2024.2.1.2-archive.tar.xz",
+            "sha256": "8790e5cdfa35ab99f5046854523ca4a3f6a877dfbb5359fb090a9cbc7c844c47",
+            "md5": "95a21c0375b86961027377e4d0494c6b",
+            "size": "435413360"
+        },
+        "linux-sbsa": {
+            "relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2024.2.1.2-archive.tar.xz",
+            "sha256": "c598d394ebbcfa9dd34641bdead530315823cbf25412dbcf74bc184763e3740d",
+            "md5": "c0271d59029b03c9469518c799417427",
+            "size": "222043308"
+        },
+        "windows-x86_64": {
+            "relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2024.2.1.2-archive.zip",
+            "sha256": "c3259047dfd59b2b958b7b865f64353391f78d77722b0d3e1be95ac19ceb074e",
+            "md5": "9dde35d4531c4b5d93a15ccb2291e948",
+            "size": "469359174"
+        },
+        "linux-aarch64": {
+            "relative_path": "nsight_compute/linux-aarch64/nsight_compute-linux-aarch64-2024.2.1.2-archive.tar.xz",
+            "sha256": "08602ad114ac704efc51e486739aaaf12631a2417188f5b27cb96a6ba5c84a76",
+            "md5": "83f01dd315b3f5582baf23ca31e30601",
+            "size": "439441508"
+        }
+    },
+    "nsight_systems": {
+        "name": "Nsight Systems",
+        "license": "NVIDIA SLA",
+        "license_path": "nsight_systems/LICENSE.txt",
+        "version": "2024.2.3.38",
+        "linux-x86_64": {
+            "relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2024.2.3.38-archive.tar.xz",
+            "sha256": "36b457ec34572699c7ddba94aec659a02d4ec78fe19bec7750918fd7e9b79119",
+            "md5": "4bdc45128eaef2473f8f55ca000e523e",
+            "size": "241641720"
+        },
+        "linux-sbsa": {
+            "relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2024.2.3.38-archive.tar.xz",
+            "sha256": "ca55ab91c8b81a05c44f2298b06579f412b8b2627312626e69e74dd4661553e0",
+            "md5": "d45cdbec6291127a4873cf18b300c6e8",
+            "size": "205635660"
+        },
+        "windows-x86_64": {
+            "relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2024.2.3.38-archive.zip",
+            "sha256": "6f48b9ad4309021be0218e4a57501c15783a867c55ec208338430a64362d4190",
+            "md5": "074c4861711fcfb4244706a53512e39b",
+            "size": "363718912"
+        }
+    },
+    "nsight_vse": {
+        "name": "Nsight Visual Studio Edition (VSE)",
+        "license": "NVIDIA SLA",
+        "license_path": "nsight_vse/LICENSE.txt",
+        "version": "2024.2.1.24155",
+        "windows-x86_64": {
+            "relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2024.2.1.24155-archive.zip",
+            "sha256": "c3dc85353506f689c79f62054d27ddd6a890c8229db3b9a11b3e3bd1a50e125e",
+            "md5": "4adc497894c1f44f3b02bdb32e5ffc48",
+            "size": "473152523"
+        }
+    },
+    "nvidia_driver": {
+        "name": "NVIDIA Linux Driver",
+        "license": "NVIDIA Driver",
+        "license_path": "nvidia_driver/LICENSE.txt",
+        "version": "555.42.06",
+        "linux-x86_64": {
+            "relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-555.42.06-archive.tar.xz",
+            "sha256": "944a7b3c30265f440fe8d2d2579fca82a2bd01431d4ad3ab43f9a03725a0c447",
+            "md5": "b746cdd33f83142380f04b4a0eb556df",
+            "size": "348473024"
+        },
+        "linux-sbsa": {
+            "relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-555.42.06-archive.tar.xz",
+            "sha256": "a764c03c9be66fb35144ec23aafa7cf73f9d392fced38db982c32ac53f997a7d",
+            "md5": "bea12d882f9440064ac310698979e41e",
+            "size": "265918892"
+        }
+    },
+    "nvidia_fs": {
+        "name": "NVIDIA filesystem",
+        "license": "CUDA Toolkit",
+        "license_path": "nvidia_fs/LICENSE.txt",
+        "version": "2.20.6",
+        "linux-x86_64": {
+            "relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.20.6-archive.tar.xz",
+            "sha256": "3930523280dceb2bb491d063949911a620672f4f38472ba9af4161f40581534f",
+            "md5": "ed8dfbba5df4ac381af4a356629811c8",
+            "size": "59268"
+        },
+        "linux-sbsa": {
+            "relative_path": "nvidia_fs/linux-sbsa/nvidia_fs-linux-sbsa-2.20.6-archive.tar.xz",
+            "sha256": "52e088d6caf89e1510bf53ddc8e0dbeb2e9b6ea523e4e0dabe654e33f1dd4850",
+            "md5": "39bb3d1e65b529f0245c5a3ab90db843",
+            "size": "59276"
+        },
+        "linux-aarch64": {
+            "relative_path": "nvidia_fs/linux-aarch64/nvidia_fs-linux-aarch64-2.20.6-archive.tar.xz",
+            "sha256": "3b193267ac26bc58e15f0f6afc130527bd21306fd25263d4facd5e8e23e1d2e5",
+            "md5": "e10534905b16c1725f9003d22e80211d",
+            "size": "59296"
+        }
+    },
+    "visual_studio_integration": {
+        "name": "CUDA Visual Studio Integration",
+        "license": "CUDA Toolkit",
+        "license_path": "visual_studio_integration/LICENSE.txt",
+        "version": "12.5.82",
+        "windows-x86_64": {
+            "relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-12.5.82-archive.zip",
+            "sha256": "bde772fbe66039b0450d0997f1c5bce217082389ac950b0f900d0fd6f7dfe229",
+            "md5": "4f3337f5a4b65437ba69d9aaa8d6299d",
+            "size": "533174"
+        }
+    }
+}

pkgs/development/cuda-modules/cuda/manifests/redistrib_12.6.0.json

···
-{
-  "release_date": "2024-08-01",
-  "release_label": "12.6.0",
-  "release_product": "cuda",
-  "cuda_cccl": {
-    "name": "CXX Core Compute Libraries",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_cccl/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "478adda30882b8fbff54d7da109708be5e6a988eafb18d9397868f8d6633981f",
-      "md5": "0aa87816194845693c6892628387a616",
-      "size": "932208"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-12.6.37-archive.tar.xz",
-      "sha256": "0985a1a4fe3f1e1b68d90909a1cad922194b111c5c965098978b66038c700436",
-      "md5": "ef44af859b3c9f4030029879b3c1fd99",
-      "size": "932348"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "4fe0460b101887a62fd8ceb1e518926439148c23ec95ef41b694c583031392e9",
-      "md5": "886a846848192218aee2bf8982116aa7",
-      "size": "2929962"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_cccl/linux-aarch64/cuda_cccl-linux-aarch64-12.6.37-archive.tar.xz",
-      "sha256": "90166f9066db13bfb017a7a9a1cea52ac7d2d23637b555192f3f071bededa054",
-      "md5": "5904ec75b0853a4d26520f3486da2589",
-      "size": "932860"
-    }
-  },
-  "cuda_compat": {
-    "name": "CUDA compat L4T",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_compat/LICENSE.txt",
-    "version": "12.6.36890662",
-    "linux-aarch64": {
-      "relative_path": "cuda_compat/linux-aarch64/cuda_compat-linux-aarch64-12.6.36890662-archive.tar.xz",
-      "sha256": "007cdab536bf0a1ec274faff73cde2233f3ccfe0e6dba2b015fb1b527e7e231f",
-      "md5": "de7405e0e2e570b52d16dedc14ebc44e",
-      "size": "19628624"
-    }
-  },
-  "cuda_cudart": {
-    "name": "CUDA Runtime (cudart)",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_cudart/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "75af44a162ee204adf0afcb81bf0448d64baee787d9d694e92722dbbcd05a42c",
-      "md5": "f6d4b5eeb13842c383a4ba153e819bbb",
-      "size": "1125188"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-12.6.37-archive.tar.xz",
-      "sha256": "c2efb179cf90aa18c6fd4f7a7103d43ead400f0af1859033a19478a45bca8f62",
-      "md5": "2759642f20c8aa441b20dc13cf4e3d93",
-      "size": "1113088"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "c66badb16921c4acb7abc38f211d530c2f290bd52c2cbdb5fb12095dc6eab0a9",
-      "md5": "92866e246041dc9edce483ed0d60972d",
-      "size": "2512085"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_cudart/linux-aarch64/cuda_cudart-linux-aarch64-12.6.37-archive.tar.xz",
-      "sha256": "061fd21ab9274172094f903708d44af6ecbd0102a77568e3304d76d9fca27308",
-      "md5": "044127d6f6b3c76a430a52aa88339f84",
-      "size": "1176084"
-    }
-  },
-  "cuda_cuobjdump": {
-    "name": "cuobjdump",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_cuobjdump/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-x86_64": {
-      "relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-12.6.20-archive.tar.xz",
-      "sha256": "2e46b5b095625686e7909c18678e93e0654aa71b52af544f3aa0d55c260e7f90",
-      "md5": "479852ce6a592b6d8d8aa0cc37a055c5",
-      "size": "218612"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-12.6.20-archive.tar.xz",
-      "sha256": "b858cabd5894544e4f5f99f003f030d67633b93c90a09593251e0dd980ff132b",
-      "md5": "0c5a857d08f3519eca810f6b16aebfc1",
-      "size": "208872"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-12.6.20-archive.zip",
-      "sha256": "b6a75a68cd6c8320f9c4a12921c5b05c8995d2e6035c502f24b691f7b9a09b86",
-      "md5": "cd98acb1d89bf5aece441d0464ef1d8e",
-      "size": "4248446"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_cuobjdump/linux-aarch64/cuda_cuobjdump-linux-aarch64-12.6.20-archive.tar.xz",
-      "sha256": "5c5e817580f6e9324928e9d27babb5d0c2880159fbe16ccd1cebba7c5989af5c",
-      "md5": "3d42cd9cf6fe46c3e3d2fa4ef9aa8a84",
-      "size": "196380"
-    }
-  },
-  "cuda_cupti": {
-    "name": "CUPTI",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_cupti/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "0f6e58132433617ab1ca279e0cfc1d82737d2320061ab7033a6e32f23f9fb25f",
-      "md5": "02e5720dcfe7e484b8e42a69fa2dd6c8",
-      "size": "13774776"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-12.6.37-archive.tar.xz",
-      "sha256": "9b203ba8cf9265efb4a518e6911d2f2a4353a489c11e7c9b4f043b0feb6d2aea",
-      "md5": "4237cc74796efbbee160c607a5afca23",
-      "size": "11196596"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "3c8aceca20d531ab5928027c132cc1f2cd0d4ad119e3d0cba27fce06142f431c",
-      "md5": "cfe3a2a820ab0b50ff2be3e5b9963798",
-      "size": "10981748"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_cupti/linux-aarch64/cuda_cupti-linux-aarch64-12.6.37-archive.tar.xz",
-      "sha256": "cb033b7b180a99485dca32db3f07642577d42fc30943f5cee7a751a971c3d1a5",
-      "md5": "a253a65389ee2139494ba124be9b1ae0",
-      "size": "4087960"
-    }
-  },
-  "cuda_cuxxfilt": {
-    "name": "CUDA cuxxfilt (demangler)",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_cuxxfilt/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-x86_64": {
-      "relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-12.6.20-archive.tar.xz",
-      "sha256": "ce83cae28ce59bc57c08d95f2af9ee094f0ef436e28788822b3ac63dd90769a3",
-      "md5": "f8c4ab23d0980b980b8e1a9edf381f96",
-      "size": "188484"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-12.6.20-archive.tar.xz",
-      "sha256": "985bdff002d46aa2a3a352551f91d1de059c6a9464c982a66284e48ce418161e",
-      "md5": "625e38128834233777fc62c12ec62c3e",
-      "size": "176852"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-12.6.20-archive.zip",
-      "sha256": "5346a24fea309c37299f88180c99a11156d5a0e2e7f69fc18e79db805e86e89f",
-      "md5": "5940e132242f420b511307aba509221d",
-      "size": "170742"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_cuxxfilt/linux-aarch64/cuda_cuxxfilt-linux-aarch64-12.6.20-archive.tar.xz",
-      "sha256": "899f215d054bd6ce7e18518313ef218c75781ea32d3b9827e66d6ce4780ba820",
-      "md5": "41a0d96e8558d8f0795a68724a7a62cc",
-      "size": "170564"
-    }
-  },
-  "cuda_demo_suite": {
-    "name": "CUDA Demo Suite",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_demo_suite/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "0a088cf533d444d85e555ac2fce026af0d9563a3837ff42dc2b1e0518fc91645",
-      "md5": "4038521ac9f6ceef17500b8ca980c3a9",
-      "size": "4016660"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "98f8a84a854a0d04cd4674a39909d385658efc0b0b437fe2b45eff46c6a6d1d6",
-      "md5": "df0c9397780e8d335701136bc28ef4c1",
-      "size": "5065769"
-    }
-  },
-  "cuda_documentation": {
-    "name": "CUDA Documentation",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_documentation/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "935605cc2e312e194730200f25d42307dc7bd59e991c97f62367851b504b0c6a",
-      "md5": "17e0c8a99474c49aab86c0c4a77b5664",
-      "size": "67284"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-12.6.37-archive.tar.xz",
-      "sha256": "ea7c7f817d2f2ebbd7a43b60298ff9081934a5d090ac437af2fe689194d1e2ae",
-      "md5": "d03b24f940b859a110226606628123e2",
-      "size": "67256"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "c23005736c9c37bac18235217062d8c4afb6281e3f128b7267b77f93145bfd44",
-      "md5": "efa4911d884b192a35e6db5b162daea0",
-      "size": "105658"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_documentation/linux-aarch64/cuda_documentation-linux-aarch64-12.6.37-archive.tar.xz",
-      "sha256": "4c7435524a1a63617034718dec2a5e6555987662f108e783853730b10c75ec37",
-      "md5": "c28d9938105f701033998ce437e9be63",
-      "size": "67152"
-    }
-  },
-  "cuda_gdb": {
-    "name": "CUDA GDB",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_gdb/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "67eacd5a8800656e7fe5da2e13a3f8ae44c77f8602044cd698c2b7089e1e1def",
-      "md5": "018d371b2d2a22dbf9284fc901982f55",
-      "size": "64552872"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-12.6.37-archive.tar.xz",
-      "sha256": "ede4cc0df5d9e926cc32d89bacd83959ba10995517e1a9f3a34cfdde2d96e1fb",
-      "md5": "9891a9722f245d01a1dd1ed1082b48cb",
-      "size": "43519672"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_gdb/linux-aarch64/cuda_gdb-linux-aarch64-12.6.37-archive.tar.xz",
-      "sha256": "1cbe8ebda2021fbf7a46a5e60d11b5f0207199a278a25d7a1596359dfc5697b9",
-      "md5": "a9793f512a702f16fd9666d0d2494513",
-      "size": "43420800"
-    }
-  },
-  "cuda_nsight": {
-    "name": "Nsight Eclipse Edition Plugin",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_nsight/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-x86_64": {
-      "relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-12.6.20-archive.tar.xz",
-      "sha256": "ccd4ee4c869a4a974b7d4ef034f8031759986d2ef26134ca9e434a843e8a4042",
-      "md5": "c039492390bc6a0cc5a765f4d9701c3d",
-      "size": "118683048"
-    }
-  },
-  "cuda_nvcc": {
-    "name": "CUDA NVCC",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_nvcc/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-x86_64": {
-      "relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-12.6.20-archive.tar.xz",
-      "sha256": "4336a230269db14336ca1f727a0502631390a52d37c17d3bde05ccda5d534406",
-      "md5": "87a4f1258aba2e8fa23e314854581bcc",
-      "size": "50046060"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-12.6.20-archive.tar.xz",
-      "sha256": "06112bf1cc0cfb6b881a2e0420cb4611b6d701decbb195fbfb4f0e9966a42006",
-      "md5": "9fccd171e3f1bf757e782bdc0b893aa9",
-      "size": "43972764"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-12.6.20-archive.zip",
-      "sha256": "03282a36fb98c2f227877a62efd04c36b1ab01fb1b676d9edbd0b10179e0a40a",
-      "md5": "9898c14c601e235be49e91986c482570",
-      "size": "79358872"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_nvcc/linux-aarch64/cuda_nvcc-linux-aarch64-12.6.20-archive.tar.xz",
-      "sha256": "468c5c31a49740cae8edff724aad10a0f20c5ca7fb9eef54881c01f68a48d713",
-      "md5": "27549d26cac1a783bb94123ff0f1fc8e",
-      "size": "45395828"
-    }
-  },
-  "cuda_nvdisasm": {
-    "name": "CUDA nvdisasm",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_nvdisasm/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-x86_64": {
-      "relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-12.6.20-archive.tar.xz",
-      "sha256": "ba60cc8c9cfabb399b70aa49ee3428f7c489330b0aa7c8616121651e56dacc3e",
-      "md5": "af4b438995e57268bd30d5c48865eec6",
-      "size": "49896088"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-12.6.20-archive.tar.xz",
-      "sha256": "7ed318e59165e4d838df65618042b139f7743b80c22f3f28764287732503f52b",
-      "md5": "11ca1a4823e20f3f1eed5eba1b4cbdee",
-      "size": "49812164"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-12.6.20-archive.zip",
-      "sha256": "9ac787efbcd20c4c871038ee5ca1c0757139990b25ea90d368aa9c1759952be6",
-      "md5": "21aeff3b5a59917fa77c03899d83b0f6",
-      "size": "50158278"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_nvdisasm/linux-aarch64/cuda_nvdisasm-linux-aarch64-12.6.20-archive.tar.xz",
-      "sha256": "d9bd48904d11a707988201566478eb3dc50b04e40d7eff8db005089c21d1e00c",
-      "md5": "df5f113ba7ccbb1205a42b54837577e4",
-      "size": "49821444"
-    }
-  },
-  "cuda_nvml_dev": {
-    "name": "CUDA NVML Headers",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_nvml_dev/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "db21efb8e2f3d05196aef2b41378f96955312e539ffa3d0c4bc98baa04128376",
-      "md5": "2b31fcc6f03341648e70f50ba35eb4d2",
-      "size": "145524"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-12.6.37-archive.tar.xz",
-      "sha256": "2ebfa603850fd1498189b67d4a00ca6e34aea25dd4d0c761c2bc8ceafa6db26f",
-      "md5": "80f4ca0debd6732b259d29a39cd060aa",
-      "size": "148308"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "700e17949a17db4bc7703f9140c56eb1eb9ec7ee79bba76b072ec17eacada5ef",
-      "md5": "8d002e05434bc0af06daa4db5fdde103",
-      "size": "129922"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_nvml_dev/linux-aarch64/cuda_nvml_dev-linux-aarch64-12.6.37-archive.tar.xz",
-      "sha256": "611871b70d3ca2a5e64e1bd54365ca616a51fb89013145f210b844edf9e07ae7",
-      "md5": "4a55b8d6f29581fbfe8f8881c53ef0bf",
-      "size": "148376"
-    }
-  },
-  "cuda_nvprof": {
-    "name": "CUDA nvprof",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_nvprof/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "2df45141995feed32fd8ca0a88738604a4d61989b7d4394caf868f1b92d63d2b",
-      "md5": "625d280a5aaa7c01bf1868d233eccdca",
-      "size": "2437928"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "7d7f6cb89fc22c8b711a48f9deceaf21908014ab07c44d1a53e064b4bcd26582",
-      "md5": "21689852da1b96726c3aef752d499451",
-      "size": "1703120"
-    }
-  },
-  "cuda_nvprune": {
-    "name": "CUDA nvprune",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_nvprune/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-x86_64": {
-      "relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-12.6.20-archive.tar.xz",
-      "sha256": "8ad2a26164cfaea08038363ebe9628503abba5440a708800f013771d1eec0f03",
-      "md5": "6924ca0576c035274e1af87b139b58c4",
-      "size": "57032"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-12.6.20-archive.tar.xz",
-      "sha256": "9de86514d4262bd8af499631fac3f40d8a1f002983342990d511219224b6e498",
-      "md5": "f469834a24a2a457c6d0f18e3d7cf511",
-      "size": "48852"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-12.6.20-archive.zip",
-      "sha256": "9a5abccbbd8132417a86f2419f52a93ca48272a9d89336f060225bf955f7ee2c",
-      "md5": "c533e2163250873eb6d34ff02a48a0a8",
-      "size": "146652"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_nvprune/linux-aarch64/cuda_nvprune-linux-aarch64-12.6.20-archive.tar.xz",
-      "sha256": "f3c8410ceb349304303c44a8b8385411403db20a6df336ed67bb135683df4f11",
-      "md5": "3e51c413f08ea3cdad1291ae73f06be7",
-      "size": "50688"
-    }
-  },
-  "cuda_nvrtc": {
-    "name": "CUDA NVRTC",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_nvrtc/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-x86_64": {
-      "relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-12.6.20-archive.tar.xz",
-      "sha256": "e8f85fc2f9a7e32838723f2f138662a87e3d74eb05ff3a864f1059e7400d9bb6",
-      "md5": "5a1dd9e80c805aed8054f650cbf866a4",
-      "size": "34417392"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-12.6.20-archive.tar.xz",
-      "sha256": "7c19bbdea7cf054d0dc42db7c619c754b590006a60284e7ffdfd8be327c69ed1",
-      "md5": "b110c7c43146f499a5a6ad0e9a4e442b",
-      "size": "31938896"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-12.6.20-archive.zip",
-      "sha256": "0838c4b8e0a4ed60af8028b2e57ca18410922df7550bf8eb175d61e384f165d3",
-      "md5": "0768af782ab53263957fe781997f478e",
-      "size": "187470695"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_nvrtc/linux-aarch64/cuda_nvrtc-linux-aarch64-12.6.20-archive.tar.xz",
-      "sha256": "5fd36dcf809771befc30b6a7b4a652c1e479dc1e6e6f9edc4eb20c26b0eddb02",
-      "md5": "ab661283879e8128c99f4fcc7966e25d",
-      "size": "33106688"
-    }
-  },
-  "cuda_nvtx": {
-    "name": "CUDA NVTX",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_nvtx/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "bb70f2dc55a7475b073edc681254e4b5b428bdd49c003bdb8628df5b8ecc4690",
-      "md5": "426e58e33f4571b880f0ad0b8dc61d7c",
-      "size": "48556"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-12.6.37-archive.tar.xz",
-      "sha256": "10340336b529157ab47d34ede3a4bc253097a99d17cd3cb8b8c1b677c1a99a89",
-      "md5": "bab7efe3802a7b00d073bab57fd7a8ff",
-      "size": "49140"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "694786f26f72c9d7d5980e685ec28e2e8936a94613c90c89a4c57bf61273030a",
-      "md5": "583f4da262c770019914069c3b286e52",
-      "size": "65837"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_nvtx/linux-aarch64/cuda_nvtx-linux-aarch64-12.6.37-archive.tar.xz",
-      "sha256": "50febf6a40ff0d684c7dded5b855a710927a68968685e9e70894ce80e20ed7d1",
-      "md5": "64ffd8be03399c479921c9c337ecf9cf",
-      "size": "51752"
-    }
-  },
-  "cuda_nvvp": {
-    "name": "CUDA NVVP",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_nvvp/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "a81bb02d101e32317c055fd836f3cc4a2450beb69f379ed7802c82ccf4b728a8",
-      "md5": "dc9161723ee6e8ba2ba7445784d59ad6",
-      "size": "117718700"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "62504d9dbe2eaa61a2cb22d55b66e666e4a16498e4e2477ed0994010ebb13c74",
-      "md5": "f5371255f42d24f503915e90ac4fd9da",
-      "size": "120342243"
-    }
-  },
-  "cuda_opencl": {
-    "name": "CUDA OpenCL",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_opencl/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_opencl/linux-x86_64/cuda_opencl-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "8cf5d1e7e499d984a4edf324d437feb760fe1d968d237c3cdce5ddcbcfec74c3",
-      "md5": "1593cf3441acda8079d44db60e5745fd",
-      "size": "92328"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_opencl/windows-x86_64/cuda_opencl-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "f9490978dff3adc505a662271f391136dba14e62e16c8ca18beb737a1a85a1dd",
-      "md5": "539317476d135a4da603d6f9325bc85f",
-      "size": "137329"
-    }
-  },
-  "cuda_profiler_api": {
-    "name": "CUDA Profiler API",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_profiler_api/LICENSE.txt",
-    "version": "12.6.37",
-    "linux-x86_64": {
-      "relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-12.6.37-archive.tar.xz",
-      "sha256": "11795a3d7fe0ce551aa1ccaaa363b6581f363de8648d8d1b0221c77a6abb4906",
-      "md5": "443337cfc10f5abe9a6a35e52f86238b",
-      "size": "16184"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-12.6.37-archive.tar.xz",
-      "sha256": "75f6477808e2685eafded60334d1f1d25ab410b84d285303f8486ed3812cdfb1",
-      "md5": "185956bcbc7ce765cac2d0d986276741",
-      "size": "16184"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "4755d260fb95d029f1cbe050a2b881beaf1a0cc2d004f431d7559c40299c3484",
-      "md5": "d1c59886f99430271031f93f1fada4fe",
-      "size": "20222"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_profiler_api/linux-aarch64/cuda_profiler_api-linux-aarch64-12.6.37-archive.tar.xz",
-      "sha256": "f347b67749067c3815821e1fbe6b2aff50f82ac4c97d53a54c575142b117afac",
-      "md5": "a0133a431055a4e3ec5ecb75f6cfcc61",
-      "size": "16168"
-    }
-  },
-  "cuda_sanitizer_api": {
-    "name": "CUDA Compute Sanitizer API",
-    "license": "CUDA Toolkit",
-    "license_path": "cuda_sanitizer_api/LICENSE.txt",
-    "version": "12.6.34",
-    "linux-x86_64": {
-      "relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-12.6.34-archive.tar.xz",
-      "sha256": "c7c11f19000b06fa722dc601eeb63ae947cb431cbf2bc47f6e20623977026804",
-      "md5": "1f9bdaab65a6633744b8d641dc6b3b29",
-      "size": "9545036"
-    },
-    "linux-sbsa": {
-      "relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-12.6.34-archive.tar.xz",
-      "sha256": "32c5b3ab3e98d0539abaedf24f2339bddbee50fc3d13fec79be6328e747ed737",
-      "md5": "195ef2a24b21455ffd49248d5dfd89db",
-      "size": "7301920"
-    },
-    "windows-x86_64": {
-      "relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-12.6.34-archive.zip",
-      "sha256": "c03df7f2f82653d19fcaa391fd27ab135eada49f037b07a217b5e65e6b9722de",
-      "md5": "a3899421789890cd31481a44f5be5430",
-      "size": "9741696"
-    },
-    "linux-aarch64": {
-      "relative_path": "cuda_sanitizer_api/linux-aarch64/cuda_sanitizer_api-linux-aarch64-12.6.34-archive.tar.xz",
-      "sha256": "702de338886684a50c98452c8d13ad72e4ddebd534d0026e0ca8a08082747098",
-      "md5": "df7ff3e952c39fc7f53eafad2de0380d",
-      "size": "3944532"
-    }
-  },
-  "fabricmanager": {
-    "name": "NVIDIA Fabric Manager",
-    "license": "NVIDIA Driver",
-    "license_path": "fabricmanager/LICENSE.txt",
-    "version": "560.28.03",
-    "linux-x86_64": {
-      "relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-560.28.03-archive.tar.xz",
-      "sha256": "306fcba1b9eee60303b3f3e9b65c42be73874bd0c0fbfcde9d9132e66c71f3f1",
-      "md5": "c57ccb8df7bc142ffdca05678d2f0546",
-      "size": "6071684"
-    },
-    "linux-sbsa": {
-      "relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-560.28.03-archive.tar.xz",
-      "sha256": "54c60d00cafdff69f678617ef98d0d18b775a6b371c27f62437c9e10e59179d4",
-      "md5": "15fb812d5da343fe581485e023f253ee",
-      "size": "5483676"
-    }
-  },
-  "imex": {
-    "name": "Nvidia-Imex",
-    "license": "NVIDIA Proprietary",
-    "license_path": "imex/LICENSE.txt",
-    "version": "560.28.03",
-    "linux-x86_64": {
-      "relative_path": "imex/linux-x86_64/nvidia-imex-linux-x86_64-560.28.03-archive.tar.xz",
-      "sha256": "cb55326901e0725484c5ebb95fe0c9f0077cfa2d1a3f0f5e59a7fe62e798b1c1",
-      "md5": "d82ac4203f2e2921cc818cf954cca747",
-      "size": "7419404"
-    },
-    "linux-sbsa": {
-      "relative_path": "imex/linux-sbsa/nvidia-imex-linux-sbsa-560.28.03-archive.tar.xz",
-      "sha256": "82553814c8f2b5032ea337292b250db69dd6b5c5b6986e306b539b2dc4313597",
-      "md5": "f2b92c8868f6e992e0f77456d7388fc5",
-      "size": "6617548"
-    }
-  },
-  "libcublas": {
-    "name": "CUDA cuBLAS",
-    "license": "CUDA Toolkit",
-    "license_path": "libcublas/LICENSE.txt",
-    "version": "12.6.0.22",
-    "linux-x86_64": {
-      "relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-12.6.0.22-archive.tar.xz",
-      "sha256": "1bac7ba106e19d7f8d40a60b1eec8decbd9522718db15df043b4329225923d5f",
-      "md5": "4c5c65db9d9577988cc5fe665ae354b7",
-      "size": "498284668"
-    },
-    "linux-sbsa": {
-      "relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-12.6.0.22-archive.tar.xz",
-      "sha256": "a4e5cc7dd46010850330641938b3167c705197d6db7503e97dd43aa6fb1d12fa",
-      "md5": "710728404b3522dbfc776b4a65d6d539",
-      "size": "496692428"
-    },
-    "windows-x86_64": {
-      "relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-12.6.0.22-archive.zip",
-      "sha256": "4f38ba0ab036296bcc48727cc3ed27e633911c0fc5dccb60d5131657b1a58002",
-      "md5": "2f4538b86d009c2af3267a6e57b31ba6",
-      "size": "404037803"
-    },
-    "linux-aarch64": {
-      "relative_path": "libcublas/linux-aarch64/libcublas-linux-aarch64-12.6.0.22-archive.tar.xz",
-      "sha256": "8c98b14e527e555f969ffacb86baa11eb1a96370ba57e7c8bb5138236136a907",
-      "md5": "28eb394e5142d2d4b0051f4aca49ae1a",
-      "size": "441196020"
-    }
-  },
-  "libcudla": {
-    "name": "cuDLA",
-    "license": "CUDA Toolkit",
-    "license_path": "libcudla/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-aarch64": {
-      "relative_path": "libcudla/linux-aarch64/libcudla-linux-aarch64-12.6.20-archive.tar.xz",
-      "sha256": "7c16a6701a815afbf90c14e63f8319525a8fef6bcc7388071c904be016ab2efd",
-      "md5": "00f3e39fa30128fc035226c3d02466be",
-      "size": "38568"
-    }
-  },
-  "libcufft": {
-    "name": "CUDA cuFFT",
-    "license": "CUDA Toolkit",
-    "license_path": "libcufft/LICENSE.txt",
-    "version": "11.2.6.28",
-    "linux-x86_64": {
-      "relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-11.2.6.28-archive.tar.xz",
-      "sha256": "9af45404b4ae48ec44c564c5e2cbb896d89e10b66f68fa32e47dbdb0e62bdb20",
-      "md5": "327c338b78228fa497d4f1aba2e3f6cb",
-      "size": "453141340"
-    },
-    "linux-sbsa": {
-      "relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-11.2.6.28-archive.tar.xz",
-      "sha256": "d9042f93b5222161df3495bc6eb8cc9516cf618c1bf778b39adf589d46119893",
-      "md5": "fca04fbab460746985e72d778c68c281",
-      "size": "453107820"
-    },
-    "windows-x86_64": {
-      "relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-11.2.6.28-archive.zip",
-      "sha256": "1eb247d48ae39a259e7d65a1bd6face05cedc37cdee3c26d8a5fcf7492c3444a",
-      "md5": "b19929277b56d6fd17a036b30e38e5a0",
-      "size": "189989045"
-    },
-    "linux-aarch64": {
-      "relative_path": "libcufft/linux-aarch64/libcufft-linux-aarch64-11.2.6.28-archive.tar.xz",
-      "sha256": "27a8d511accf18c58126d71a069974a4d13d0d5ad003be0813b503b85a3ac232",
-      "md5": "b361a83296efa4c16f6d1a542c534655",
-      "size": "453208548"
-    }
-  },
-  "libcufile": {
-    "name": "CUDA cuFile",
-    "license": "CUDA Toolkit",
-    "license_path": "libcufile/LICENSE.txt",
-    "version": "1.11.0.15",
-    "linux-x86_64": {
-      "relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.11.0.15-archive.tar.xz",
-      "sha256": "735783b817edd5c4431df5f4b5d5ee3b00496441148243155024da3d82da3d15",
-      "md5": "ebe5475327ddac9df3efed272f0e915b",
-      "size": "41836036"
-    },
-    "linux-sbsa": {
-      "relative_path": "libcufile/linux-sbsa/libcufile-linux-sbsa-1.11.0.15-archive.tar.xz",
-      "sha256": "9e3e41ac3ae9e368a2aaee2518557cfdb34c1f1db72e094777f59f84b424688d",
-      "md5": "90f2daf2071c06a5ebccd1d763397c1b",
-      "size": "41283512"
-    },
-    "linux-aarch64": {
-      "relative_path": "libcufile/linux-aarch64/libcufile-linux-aarch64-1.11.0.15-archive.tar.xz",
-      "sha256": "697132545001080d0138a8303eccc3877974c2188099dff9b232658cac8aaa7e",
-      "md5": "da8378c3116a5eaa5b412fd81595be34",
-      "size": "41270500"
-    }
-  },
-  "libcurand": {
-    "name": "CUDA cuRAND",
-    "license": "CUDA Toolkit",
-    "license_path": "libcurand/LICENSE.txt",
-    "version": "10.3.7.37",
-    "linux-x86_64": {
-      "relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.3.7.37-archive.tar.xz",
-      "sha256": "92575006cd1fcb55edc91c5be660de5f94c796d8c840b5827a52d18168fda099",
-      "md5": "f6eaaed3e3ab457092a34e715d19b875",
-      "size": "81727424"
-    },
-    "linux-sbsa": {
-      "relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.3.7.37-archive.tar.xz",
-      "sha256": "ede18730ce95c0c4492a952216470cab2c82163f19d26006c66919f8dcfde58d",
-      "md5": "7100a53721b9aa0a525306c4464ee87c",
-      "size": "81711744"
-    },
-    "windows-x86_64": {
-      "relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.3.7.37-archive.zip",
-      "sha256": "5db79007bde6f0cb2d1f062c1c4d51465f6b6a56173e575b140eeae0f9c5ee4f",
-      "md5": "6b59bb25ca870321a6841209d4fc22f1",
-      "size": "55078901"
-    },
-    "linux-aarch64": {
-      "relative_path": "libcurand/linux-aarch64/libcurand-linux-aarch64-10.3.7.37-archive.tar.xz",
-      "sha256": "1f2346a36ad8b989432583fea0186ba2f6c84bfb0a0cd1b35b7261763161d53f",
-      "md5": "7c7f528988b69c3b9b95fa7947aabc5c",
-      "size": "83950692"
-    }
-  },
-  "libcusolver": {
-    "name": "CUDA cuSOLVER",
-    "license": "CUDA Toolkit",
-    "license_path": "libcusolver/LICENSE.txt",
-    "version": "11.6.4.38",
-    "linux-x86_64": {
-      "relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.6.4.38-archive.tar.xz",
-      "sha256": "625801d29840f6d022b6af73c7db9638c439423d97b504edf83bc27a2bf7ef54",
-      "md5": "affc3901970e0ceaaccfb15ff30492e8",
-      "size": "129942132"
-    },
-    "linux-sbsa": {
-      "relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.6.4.38-archive.tar.xz",
-      "sha256": "df97eb51b2669c3951d3e3ca41a33a848e1b7461f26eeac7e6cc6b6d043bd82b",
-      "md5": "4744321a9a6dc000f079c36a22e78efa",
-      "size": "129208412"
-    },
-    "windows-x86_64": {
-      "relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.6.4.38-archive.zip",
-      "sha256": "3d82c16f8331707aa3ca516a1beaaca0e8169f6e34991d0d824873cfe6197044",
-      "md5": "050b7da685672e1e2cc8ab1242318bff",
-      "size": "126191983"
-    },
-    "linux-aarch64": {
-      "relative_path": "libcusolver/linux-aarch64/libcusolver-linux-aarch64-11.6.4.38-archive.tar.xz",
-      "sha256": "2ffbabc3fd9c9bd0a482123673bc5c57c2e805d0ad864678f37cab93551000cf",
-      "md5": "095ca68e20643519e26b5439aadaeb27",
-      "size": "141678100"
-    }
-  },
-  "libcusparse": {
-    "name": "CUDA cuSPARSE",
-    "license": "CUDA Toolkit",
-    "license_path": "libcusparse/LICENSE.txt",
-    "version": "12.5.2.23",
-    "linux-x86_64": {
-      "relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-12.5.2.23-archive.tar.xz",
-      "sha256": "ee3ec738f7dccb19d91b0d0714f56090369d4adeae5eade259f84d44281da311",
-      "md5": "53a2c05f694ce6e263ef38c71012e3ca",
-      "size": "236907508"
-    },
-    "linux-sbsa": {
-      "relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-12.5.2.23-archive.tar.xz",
-      "sha256": "d9981407c6af8a3ed07d956f888426093a34a81fd9199d020c28714509ee050e",
-      "md5": "f7617eac8c5a51d104d99ab7189c0e06",
-      "size": "236556584"
-    },
-    "windows-x86_64": {
-      "relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-12.5.2.23-archive.zip",
-      "sha256": "8ca7f006ecdd89ba1faf7b7eac2c0b6abfabe1c732f4520a82c653f80fc50cff",
-      "md5": "d03e9f50f9d10d400d56a1f63805f376",
-      "size": "212353352"
-    },
-    "linux-aarch64": {
-      "relative_path": "libcusparse/linux-aarch64/libcusparse-linux-aarch64-12.5.2.23-archive.tar.xz",
-      "sha256": "39f2080143d9d97a3c075c9310c4380350eb44ea96ab59e5b198e4984da6253e",
-      "md5": "ca7b3af07228794bdad2267e914e765e",
-      "size": "254625232"
-    }
-  },
-  "libnpp": {
-    "name": "CUDA NPP",
-    "license": "CUDA Toolkit",
-    "license_path": "libnpp/LICENSE.txt",
-    "version": "12.3.1.23",
-    "linux-x86_64": {
-      "relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-12.3.1.23-archive.tar.xz",
-      "sha256": "ce1981caf8b083b92fba9f16b14a1fba8e8087f702f354155abfd29ee71170e6",
-      "md5": "c0573257ddd5639fcb3807a8f9a50a9c",
-      "size": "182782160"
-    },
-    "linux-sbsa": {
-      "relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-12.3.1.23-archive.tar.xz",
-      "sha256": "a3c4a3c2f3110adf41db621585ac12fec153bef36be75f06af3a4353566c6455",
-      "md5": "068a8fe22dbd11ca14583821bb2893e3",
-      "size": "182334704"
-    },
-    "windows-x86_64": {
-      "relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-12.3.1.23-archive.zip",
-      "sha256": "fdc4eb5217a6c13d8075cb9c57ab3ebdd4a194358231d90b53c6ab7b19d830fe",
-      "md5": "8ed6ca830492f364a8ef8366310f1c26",
-      "size": "154934891"
-    },
-    "linux-aarch64": {
-      "relative_path": "libnpp/linux-aarch64/libnpp-linux-aarch64-12.3.1.23-archive.tar.xz",
-      "sha256": "fce78a19918f61538b0215f32f816e105e3102ddd16917535deec6e9b94e2460",
-      "md5": "4e0303cdcb0286295615724d8f803558",
-      "size": "200211544"
-    }
-  },
-  "libnvfatbin": {
-    "name": "NVIDIA compiler library for fatbin interaction",
-    "license": "CUDA Toolkit",
-    "license_path": "libnvfatbin/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-x86_64": {
-      "relative_path": "libnvfatbin/linux-x86_64/libnvfatbin-linux-x86_64-12.6.20-archive.tar.xz",
-      "sha256": "039d2a6be8ed7208a5ba3a3c04afdd423b524f9f747c73f6165d725d2aca70cf",
-      "md5": "607c99694913565205514428821d2145",
-      "size": "909260"
-    },
-    "linux-sbsa": {
-      "relative_path": "libnvfatbin/linux-sbsa/libnvfatbin-linux-sbsa-12.6.20-archive.tar.xz",
-      "sha256": "6b7abcfa16f8c25c554ecd7c4bb6cc6f98b77601ea66ac6d1e698a092c0aec14",
-      "md5": "5e6fbf5ac49fcfcffb7f5664189e4361",
-      "size": "819628"
-    },
-    "windows-x86_64": {
-      "relative_path": "libnvfatbin/windows-x86_64/libnvfatbin-windows-x86_64-12.6.20-archive.zip",
-      "sha256": "80f9ef23d4e3744facedcad62af34ae330a7ab7873405ed8c40f5d2f273f4f5a",
-      "md5": "8934c38ab9147418e2807e4a727a487e",
-      "size": "2180735"
-    },
-    "linux-aarch64": {
-      "relative_path": "libnvfatbin/linux-aarch64/libnvfatbin-linux-aarch64-12.6.20-archive.tar.xz",
-      "sha256": "b40bb546231d434e5bebd961952b82ed3679be1682149c02b9c91d86a176a5b8",
-      "md5": "3a4b1fddd2fb72e00c37fc908b3cc68b",
-      "size": "791412"
-    }
-  },
-  "libnvidia_nscq": {
-    "name": "NVIDIA NSCQ API",
-    "license": "NVIDIA Driver",
-    "license_path": "libnvidia_nscq/LICENSE.txt",
-    "version": "560.28.03",
-    "linux-x86_64": {
-      "relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-560.28.03-archive.tar.xz",
-      "sha256": "8ce02d35b47f7c6ff1078a72a47f24610603b799a5b4e884b06b4e8e4f4e85b0",
-      "md5": "bd8c794531f3672f96132cab2f1e9b89",
-      "size": "357044"
-    },
-    "linux-sbsa": {
-      "relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-560.28.03-archive.tar.xz",
-      "sha256": "93c4838c2705bfcb275fbe9ccaff5cc5fe74753a51de718941638b07da269b62",
-      "md5": "d025d27dc697f6f8b3bd640a752c8229",
-      "size": "351108"
-    }
-  },
-  "libnvjitlink": {
-    "name": "NVIDIA compiler library for JIT LTO functionality",
-    "license": "CUDA Toolkit",
-    "license_path": "libnvjitlink/LICENSE.txt",
-    "version": "12.6.20",
-    "linux-x86_64": {
-      "relative_path": "libnvjitlink/linux-x86_64/libnvjitlink-linux-x86_64-12.6.20-archive.tar.xz",
-      "sha256": "7e57521fc4065f264bd7fd118d267636c2cdf0e542465f281e767e206cf5a794",
-      "md5": "69474f3eba69c334f8246e9ad51d4c23",
-      "size": "29002588"
-    },
-    "linux-sbsa": {
-      "relative_path": "libnvjitlink/linux-sbsa/libnvjitlink-linux-sbsa-12.6.20-archive.tar.xz",
-      "sha256": "a25199ea3a109f216e14bb55c5043feac237f6c5adfdc28e709cbad0a6783317",
-      "md5": "2ffee7213ebbb4cad26da8b2a2e528ee",
-      "size": "26761092"
-    },
-    "windows-x86_64": {
-      "relative_path": "libnvjitlink/windows-x86_64/libnvjitlink-windows-x86_64-12.6.20-archive.zip",
-      "sha256": "e7577c412f7ff3d7f6fde50733ef2af6bcfc4e093f8cb4e282129bc55f5aba06",
-      "md5": "a5bee346c175d408c463c7df166922cb",
-      "size": "153527323"
-    },
-    "linux-aarch64": {
-      "relative_path": "libnvjitlink/linux-aarch64/libnvjitlink-linux-aarch64-12.6.20-archive.tar.xz",
-      "sha256": "33d13a47a84401bae9c66a23613a8fd18862affeb13ee402f27779674e8fa857",
-      "md5": "bc7ae8463e4bba5c761738f53dd443cd",
-      "size": "27928804"
-    }
-  },
-  "libnvjpeg": {
-    "name": "CUDA nvJPEG",
-    "license": "CUDA Toolkit",
-    "license_path": "libnvjpeg/LICENSE.txt",
-    "version": "12.3.3.23",
-    "linux-x86_64": {
-      "relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-12.3.3.23-archive.tar.xz",
-      "sha256": "4beb2ee853f791eddd7365bfa2de71456bfc7ee4a7a49a9b14083207f1905a9c",
-      "md5": "4236dbe25a02ee466a583f7c7d011203",
-      "size": "2580132"
-    },
-    "linux-sbsa": {
-      "relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-12.3.3.23-archive.tar.xz",
-      "sha256": "85e19a7d31105db44feb986373a079bce0f9aee4b7339d54081d40ed5c6864aa",
-      "md5": "60db48adac8d547382e5b7e6673d2cf4",
-      "size": "2418628"
-    },
-    "windows-x86_64": {
-      "relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-12.3.3.23-archive.zip",
-      "sha256": "731e97201a96adb53aa8960db0ab694b4fc289dc5d45ae65599e5fabbeda3d6e",
-      "md5": "ea4c38b5e81067c02bd5709385791c83",
-      "size": "2829128"
-    },
-    "linux-aarch64": {
-      "relative_path": "libnvjpeg/linux-aarch64/libnvjpeg-linux-aarch64-12.3.3.23-archive.tar.xz",
-      "sha256": "5aea63a5f39ee50e9c5a7658081bf90a7f9c5414a1e37b2c2f9e47d9b7c2b75c",
-      "md5": "937841101629bd756ff7284b958ad652",
-      "size": "2561560"
-    }
-  },
-  "libnvsdm": {
-    "name": "LIBNVSDM",
-    "license": "NVIDIA",
-    "license_path": "libnvsdm/LICENSE.txt",
-    "version": "560.28.03",
-    "linux-x86_64": {
-      "relative_path": "libnvsdm/linux-x86_64/libnvsdm-linux-x86_64-560.28.03-archive.tar.xz",
-      "sha256": "4dbdefde4ef7887706f75dc364efa1406c771c34f7de5704d0eeca563b9695b5",
-      "md5": "fd5639e9d0f834d759397c9be78df3b0",
-      "size": "550168"
-    }
-  },
-  "nsight_compute": {
-    "name": "Nsight Compute",
-    "license": "NVIDIA SLA",
-    "license_path": "nsight_compute/LICENSE.txt",
-    "version": "2024.3.0.15",
-    "linux-x86_64": {
-      "relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2024.3.0.15-archive.tar.xz",
-      "sha256": "438fd13ee0bcccbfbbcd71419c9c60a491096d20599e623abc9885e6153929dd",
-      "md5": "4549ef7615fc4b3847b836bcaeee9067",
-      "size": "429309152"
-    },
-    "linux-sbsa": {
-      "relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2024.3.0.15-archive.tar.xz",
-      "sha256": "6a38835fc5fab866f9d0f4e35d6344f5d82ef6ee98f9e23c3de990a814548eaa",
-      "md5": "dad3d36cb8549a09b162312ecd268d12",
-      "size": "219322980"
-    },
-    "windows-x86_64": {
-      "relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2024.3.0.15-archive.zip",
-      "sha256": "4ddaf359f36a8ebc1b9237d297f34d1faa4e8dcba1f0fd3d851956d88c29482b",
-      "md5": "b423290bd7ca8bcde2e4ff506a4458e3",
-      "size": "462192979"
-    },
-    "linux-aarch64": {
-      "relative_path": "nsight_compute/linux-aarch64/nsight_compute-linux-aarch64-2024.3.0.15-archive.tar.xz",
-      "sha256": "5d91f96a99188ee60c05f9f5341d2f8e16f0a27a5e7b9e9d946262084af5fa02",
-      "md5": "d86b14d665e1800de87bb22df5f31f69",
-      "size": "430001220"
-    }
-  },
-  "nsight_systems": {
-    "name": "Nsight Systems",
-    "license": "NVIDIA SLA",
-    "license_path": "nsight_systems/LICENSE.txt",
-    "version": "2024.4.2.133",
-    "linux-x86_64": {
-      "relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2024.4.2.133-archive.tar.xz",
-      "sha256": "7e5dae8b23da110462e2b9545360e37d9931a336ac8d4e1e14364fa516acc4db",
-      "md5": "f922c51cb16567c64737486d3cca9edd",
-      "size": "254795020"
-    },
-    "linux-sbsa": {
-      "relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2024.4.2.133-archive.tar.xz",
-      "sha256": "9fa78d9f72160dea2a8a4075eaba6dbb61b54126fcec53138aec86df7f052660",
-      "md5": "a186b2aade2f2057e00995c67eeee7b4",
-      "size": "206467024"
-    },
-    "windows-x86_64": {
-      "relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2024.4.2.133-archive.zip",
-      "sha256": "77cd8cd2cd4588acf5be36508db71e40e725dbd2c96c89d88ac243e26844d9ef",
-      "md5": "f15fda899004953ff9704b3e5cc594cd",
-      "size": "367169284"
-    }
-  },
-  "nsight_vse": {
-    "name": "Nsight Visual Studio Edition (VSE)",
-    "license": "NVIDIA SLA",
-    "license_path": "nsight_vse/LICENSE.txt",
-    "version": "2024.3.0.24164",
-    "windows-x86_64": {
-      "relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2024.3.0.24164-archive.zip",
-      "sha256": "f06b1b9d9e4bcdf6cb44a85c506ecbf55482c4557df02c1906c1d469986b371a",
-      "md5": "e86b066ca8aa0922c2db274757e40dad",
-      "size": "471792358"
-    }
-  },
-  "nvidia_driver": {
-    "name": "NVIDIA Linux Driver",
-    "license": "NVIDIA Driver",
-    "license_path": "nvidia_driver/LICENSE.txt",
-    "version": "560.28.03",
-    "linux-x86_64": {
-      "relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-560.28.03-archive.tar.xz",
-      "sha256": "88cc9982dc18435dad6f62c549736b0680b6df518144331234df3ccd3150512c",
-      "md5": "da1cc544e6655eeace7bc43db04b020d",
-      "size": "377251444"
-    },
-    "linux-sbsa": {
-      "relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-560.28.03-archive.tar.xz",
-      "sha256": "bad8d2c150366429538526344c6b9f64d3b4b6c8006fc76bc8e3123c207a9d0d",
-      "md5": "86dd3549f55cb43510a6a2575162cfd9",
-      "size": "289677692"
-    }
-  },
-  "nvidia_fs": {
-    "name": "NVIDIA filesystem",
-    "license": "CUDA Toolkit",
-    "license_path": "nvidia_fs/LICENSE.txt",
-    "version": "2.22.3",
-    "linux-x86_64": {
-      "relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.22.3-archive.tar.xz",
-      "sha256": "67ac2e05a6388db2824c454e0bdd808d662aa1fe63ad3292471b144fb0c7fad1",
-      "md5": "605ff67650a8ae1f72a9bd8540ed0ee0",
-      "size": "59284"
-    },
-    "linux-sbsa": {
-      "relative_path": "nvidia_fs/linux-sbsa/nvidia_fs-linux-sbsa-2.22.3-archive.tar.xz",
-      "sha256": "1c73cfb016ce4c6b0c99d46084a678a5e062875e1180b556bda624f7648653f6",
-      "md5": "8debe062baaa33cd4283237d112633c4",
-      "size": "59284"
-    },
-    "linux-aarch64": {
-      "relative_path": "nvidia_fs/linux-aarch64/nvidia_fs-linux-aarch64-2.22.3-archive.tar.xz",
-      "sha256": "7d8db9cf65b6c29198a6c29749ffb5aea3367c1adee71c6bd10169fcaca488db",
-      "md5": "076dbd175b9dbacd9a199f29069161e5",
-      "size": "59288"
-    }
-  },
-  "visual_studio_integration": {
-    "name": "CUDA Visual Studio Integration",
-    "license": "CUDA Toolkit",
-    "license_path": "visual_studio_integration/LICENSE.txt",
-    "version": "12.6.37",
-    "windows-x86_64": {
-      "relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-12.6.37-archive.zip",
-      "sha256": "ab43531c3a13aeca7eeac35a0027b9063bcc03e9d788e59b7000607856264f9b",
-      "md5": "571995a1fd83da361b0c5f0e8b9c7a61",
-      "size": "533182"
-    }
-  }
-}

pkgs/development/cuda-modules/cuda/manifests/redistrib_12.6.3.json

···
+{
+    "release_date": "2024-11-20",
+    "release_label": "12.6.3",
+    "release_product": "cuda",
+    "cuda_cccl": {
+        "name": "CXX Core Compute Libraries",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cccl/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_cccl/linux-x86_64/cuda_cccl-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "9c3145ef01f73e50c0f5fcf923f0899c847f487c529817daa8f8b1a3ecf20925",
+            "md5": "93c6af9115fe841e0b70c61313fd3784",
+            "size": "934952"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cccl/linux-sbsa/cuda_cccl-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "cea5f1487b9ff78a01cadd96e950bfe6fe4bc638849fae81b8739adfdde47146",
+            "md5": "d45c87f6a996db35c91561b1be0a0b19",
+            "size": "934808"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cccl/windows-x86_64/cuda_cccl-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "469b783b6731964170b3d27ae214e97e2a63ec93c57ace3ed4052e6d01261f2e",
+            "md5": "6e472a3821a5eb3e6a4d52aaf87f7757",
+            "size": "2929962"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cccl/linux-aarch64/cuda_cccl-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "ab8bd5c346ca69c96ac9afb9d317e8cbc0ec8fc32629ca17b38c14b3dede2fb7",
+            "md5": "0726a103aec56a5f726e5868ee6e29c2",
+            "size": "935196"
+        }
+    },
+    "cuda_compat": {
+        "name": "CUDA compat L4T",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_compat/LICENSE.txt",
+        "version": "12.6.36890662",
+        "linux-aarch64": {
+            "relative_path": "cuda_compat/linux-aarch64/cuda_compat-linux-aarch64-12.6.36890662-archive.tar.xz",
+            "sha256": "007cdab536bf0a1ec274faff73cde2233f3ccfe0e6dba2b015fb1b527e7e231f",
+            "md5": "de7405e0e2e570b52d16dedc14ebc44e",
+            "size": "19628624"
+        }
+    },
+    "cuda_cudart": {
+        "name": "CUDA Runtime (cudart)",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cudart/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_cudart/linux-x86_64/cuda_cudart-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "f74689258a60fd9c5bdfa7679458527a55e22442691ba678dcfaeffbf4391ef9",
+            "md5": "868af7d55bed8ce473f6a9c1416f846e",
+            "size": "1126072"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cudart/linux-sbsa/cuda_cudart-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "c73c8e5bfe8fcd7468d012c9eebff15063005a3bba44423d541d573dc058de58",
+            "md5": "e0d2f3ee94af8d68bb7e40affd70cb75",
+            "size": "1112288"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "7a313bc0c93b1a50bb03aa9783a199ae70c3b66e2d8084da65e8254a8577b925",
+            "md5": "27da2c088df06222d204c88f3d7e6831",
+            "size": "2512007"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cudart/linux-aarch64/cuda_cudart-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "d5b8f6f5a2ab34066c267daf5f73f25d2f24ea25d8fa3dce427c196ff07504e7",
+            "md5": "f99fdf8e2a33ec402cc209d650ddb60d",
+            "size": "1175528"
+        }
+    },
+    "cuda_cuobjdump": {
+        "name": "cuobjdump",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cuobjdump/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_cuobjdump/linux-x86_64/cuda_cuobjdump-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "54d0edf14284249baf8e2db1c26c71d079ad7afd1f41779e22f239ff9e8bf60f",
+            "md5": "dd84a355927fff7134e968074d40f82e",
+            "size": "219068"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cuobjdump/linux-sbsa/cuda_cuobjdump-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "a55dcccc834b018b994a9592ca20245e5e14449dbb8c61d76e43347e4bfa21b9",
+            "md5": "429926be33ad495c506c5a8036973bf7",
+            "size": "208736"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cuobjdump/windows-x86_64/cuda_cuobjdump-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "b9207c09a5d6b34e6bdd8ff2093b3d101ef85f08b34c8ba8d710050b522661ae",
+            "md5": "bee233537c8ea01ca1e22e398d5e97c2",
+            "size": "4248722"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cuobjdump/linux-aarch64/cuda_cuobjdump-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "c75d148dca4d4672a81a83601f06ae7466367ea5c9a4e61cf74fa7396a437eb4",
+            "md5": "a3c6e47e36427d6e6ffd892b86e174f7",
+            "size": "196188"
+        }
+    },
+    "cuda_cupti": {
+        "name": "CUPTI",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cupti/LICENSE.txt",
+        "version": "12.6.80",
+        "linux-x86_64": {
+            "relative_path": "cuda_cupti/linux-x86_64/cuda_cupti-linux-x86_64-12.6.80-archive.tar.xz",
+            "sha256": "5ef9aa8229f81e16f243ebe5b710a8b6a871374bbe1aeb5b95c0ed35791592b7",
+            "md5": "c7b643aa8744ed25065233e660ce159a",
+            "size": "13922028"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cupti/linux-sbsa/cuda_cupti-linux-sbsa-12.6.80-archive.tar.xz",
+            "sha256": "990b04b1e17c0c29612438b0f31bef94b4c5151f51384a51873a50cb23f88c75",
+            "md5": "216065a718351644ae1eb9010bdd8266",
+            "size": "10877748"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cupti/windows-x86_64/cuda_cupti-windows-x86_64-12.6.80-archive.zip",
+            "sha256": "6b69bad461cd54f6555a11785b6e5878407df5bdc3caeadf2ff729cf45376128",
+            "md5": "c285a8a43b40ae31f258a6b9da95dc36",
+            "size": "11216576"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cupti/linux-aarch64/cuda_cupti-linux-aarch64-12.6.80-archive.tar.xz",
+            "sha256": "9a3945219e5cf98c8df612681bd1984a9fdad6d86226bb0e99a515d18f736b4b",
+            "md5": "4e825a435ed237ee97370d8a4f9f669c",
+            "size": "4093644"
+        }
+    },
+    "cuda_cuxxfilt": {
+        "name": "CUDA cuxxfilt (demangler)",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_cuxxfilt/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_cuxxfilt/linux-x86_64/cuda_cuxxfilt-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "f8c4c9434621597367ce826f6ad3c0267cf06ca50625b36ff32777604013235d",
+            "md5": "1cd4eb0e893fc3c148e0e435e1ed7cef",
+            "size": "189148"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_cuxxfilt/linux-sbsa/cuda_cuxxfilt-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "b8f82d3dd97fed289f40e8552ead4ddd88db70775074fc3ed06fe89dd17be320",
+            "md5": "161cd522f27d7f213fc7245d2d852d2e",
+            "size": "176760"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_cuxxfilt/windows-x86_64/cuda_cuxxfilt-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "e771414a1d96eb4b89c0759cd2d2f127b929c5c2a0961f176c3a8f0736e94b64",
+            "md5": "8478f284513a59e15e32cfc032f64468",
+            "size": "170746"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_cuxxfilt/linux-aarch64/cuda_cuxxfilt-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "f860a51d5baf19ada53ed9af6746ab7a256290ac9c579d3f9de93756b66e4734",
+            "md5": "ceba05046b5056fa274747cb91fbf3e7",
+            "size": "170252"
+        }
+    },
+    "cuda_demo_suite": {
+        "name": "CUDA Demo Suite",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_demo_suite/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_demo_suite/linux-x86_64/cuda_demo_suite-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "8911660314f06d9e1876be7c4d5ebd432ee7ac19df34b9866bde3ce9be0ac4c6",
+            "md5": "8807586a517743187f0afa4078372196",
+            "size": "4016948"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_demo_suite/windows-x86_64/cuda_demo_suite-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "829480fff285de7668b39d821703bce2f75d564690886ac6970545b4749f7fc3",
+            "md5": "3ac5275c99c7d6696fb84bef9f5c9858",
+            "size": "5065609"
+        }
+    },
+    "cuda_documentation": {
+        "name": "CUDA Documentation",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_documentation/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_documentation/linux-x86_64/cuda_documentation-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "438a9875891b197ce3129a4dfc52e4d30e13b876ddd8ae0dbeb522969a4066c6",
+            "md5": "ac71a1bba443e0c3f53b79af99462356",
+            "size": "67324"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_documentation/linux-sbsa/cuda_documentation-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "b02f326f3e96b847358ecb3dc1de5d0d83fee512b8aea33fe30a5c8b63647eaa",
+            "md5": "18b1833075c0b3c995cc2114dceacf6e",
+            "size": "67144"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_documentation/windows-x86_64/cuda_documentation-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "397931b1bf6981ecbfb5afbbb203e243e6af950a97913577c3ddbcbf9f7eaffb",
+            "md5": "d80708e0d0a696c5e78d84ba876f57d5",
+            "size": "105658"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_documentation/linux-aarch64/cuda_documentation-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "7f05a2d72ea16b75ffffe4389ae295a55a33d98d05bbcf4a987f1fc72b620d09",
+            "md5": "908512080538115b91f70a685c5e56d0",
+            "size": "67140"
+        }
+    },
+    "cuda_gdb": {
+        "name": "CUDA GDB",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_gdb/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_gdb/linux-x86_64/cuda_gdb-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "458cb1c88eb0af9d986071782c48134b9871633b1c7b29b1f73df194b5ae70db",
+            "md5": "314d69883a38d39d0aa7710ff279627e",
+            "size": "64688388"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_gdb/linux-sbsa/cuda_gdb-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "914e6e44ec4174c4961275644e9fa675d3cb7a6962761772d48e414f95dce575",
+            "md5": "2abf0f4d63483c86cca66c898d68d240",
+            "size": "43505780"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_gdb/linux-aarch64/cuda_gdb-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "2cd9a9e949ccd1c5f3aea55fb023eb7fc87d4c1d9ac5bd2ba6301e1aed7631a1",
+            "md5": "cbfdc9bb202a819e48a7336f3a715abe",
+            "size": "43422588"
+        }
+    },
+    "cuda_nsight": {
+        "name": "Nsight Eclipse Edition Plugin",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nsight/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_nsight/linux-x86_64/cuda_nsight-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "9e13b2784eed7c6edad031d5f8561a675370a39c2f6f1e6fb915af31ccfc11d1",
+            "md5": "9b48cfe6dcaef7ed91a162e81b60677a",
+            "size": "118682264"
+        }
+    },
+    "cuda_nvcc": {
+        "name": "CUDA NVCC",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvcc/LICENSE.txt",
+        "version": "12.6.85",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvcc/linux-x86_64/cuda_nvcc-linux-x86_64-12.6.85-archive.tar.xz",
+            "sha256": "840deff234d9bef20d6856439c49881cb4f29423b214f9ecd2fa59b7ac323817",
+            "md5": "727970ed15c7e1b102b7d5e5cc6ded54",
+            "size": "49996208"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvcc/linux-sbsa/cuda_nvcc-linux-sbsa-12.6.85-archive.tar.xz",
+            "sha256": "1b834df41cb071884f33b1e4ffc185e4799975057baca57d80ba7c4591e67950",
+            "md5": "ac245387e81f003e3b4ca85945117ce5",
+            "size": "43942552"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-12.6.85-archive.zip",
+            "sha256": "3fb9f76b87c37d02f947354be89b718ad5f2c76b6ab47995265bfa3a068a5e14",
+            "md5": "6ca4c0f2ef35c4d74e0ffa5a9d16fe24",
+            "size": "79950764"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvcc/linux-aarch64/cuda_nvcc-linux-aarch64-12.6.85-archive.tar.xz",
+            "sha256": "ef9dfb2c7327e196f8601ed216908de56911578f26e6ab9ac13c3e7dfff784f9",
+            "md5": "fdb7672b28f63bb348aa20b8713a3840",
+            "size": "45536592"
+        }
+    },
+    "cuda_nvdisasm": {
+        "name": "CUDA nvdisasm",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvdisasm/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvdisasm/linux-x86_64/cuda_nvdisasm-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "aeae4d2bdeaaa0b9149f1c6f486d40b248e8f4f5f1fccba42de5ab69337f7252",
+            "md5": "837df3229ef75698f2cafb4cf8431705",
+            "size": "49896188"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvdisasm/linux-sbsa/cuda_nvdisasm-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "aeed7512466923f91f339573c110dd8187a21c110f70fc391510372148de47b5",
+            "md5": "3657a465fd33820850b6aed6452b24fa",
+            "size": "49812236"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvdisasm/windows-x86_64/cuda_nvdisasm-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "f3e52fc4cb3bab0e097c7f5d1ee19ff90bf40f3304aef02281dfde989b5d008c",
+            "md5": "5ab1d53d0a54ff7a01a271a82a466f71",
+            "size": "50158269"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvdisasm/linux-aarch64/cuda_nvdisasm-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "5f9616270bb35bf4bfa519c8ec1097e51e786646800077df2ed0409b3d728b68",
+            "md5": "fe319e2ff5084624209f7348879bcb3e",
+            "size": "49821656"
+        }
+    },
+    "cuda_nvml_dev": {
+        "name": "CUDA NVML Headers",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvml_dev/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvml_dev/linux-x86_64/cuda_nvml_dev-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "bf297acf16ddc9340859180c5395689fcd890c1e3295915851de3977f306d601",
+            "md5": "2153a3e64008e638ce2d5e298534ee1b",
+            "size": "145364"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvml_dev/linux-sbsa/cuda_nvml_dev-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "3083c53ca6fcde4f5a41eebee647fe6b49a408431e1bd53ab5b0a38e4fd2268e",
+            "md5": "7f502ebe3aba5cfae3043922533e218f",
+            "size": "147848"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvml_dev/windows-x86_64/cuda_nvml_dev-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "45f2466ff154a44701388a90913b7d1c4c0ec591f0ec33b3d30464d5c2ffbe8d",
+            "md5": "50774ef4ccf9253357b27389647d2509",
+            "size": "129922"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvml_dev/linux-aarch64/cuda_nvml_dev-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "56abe6ff8e45f1d07433963093557a82ed92689a4ce9bc6f9a5e1c076141c5bb",
+            "md5": "93ad8f14c5ca47c30b3e35b39185db28",
+            "size": "148564"
+        }
+    },
+    "cuda_nvprof": {
+        "name": "CUDA nvprof",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvprof/LICENSE.txt",
+        "version": "12.6.80",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvprof/linux-x86_64/cuda_nvprof-linux-x86_64-12.6.80-archive.tar.xz",
+            "sha256": "c206de5394cd7411f7793fad077f39be235533323b7dc4c1d463f3cdc1cc838d",
+            "md5": "025440d214b5e3a227abd900567afccf",
+            "size": "2438040"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvprof/windows-x86_64/cuda_nvprof-windows-x86_64-12.6.80-archive.zip",
+            "sha256": "a7aba7f1a24d721e659bf058cc1abfeceaad50bdf1cc9f88e1f67d4de5584663",
+            "md5": "f43132255cb5ab3dcdd0241b7c91671b",
+            "size": "1703106"
+        }
+    },
+    "cuda_nvprune": {
+        "name": "CUDA nvprune",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvprune/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvprune/linux-x86_64/cuda_nvprune-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "c633bf85f0263ff01fd2c34bd8341e65363faef775b3127dfdac48d74e6d2b8b",
+            "md5": "7f5b2a558dbc2e98e30f7809b7f469ce",
+            "size": "57080"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvprune/linux-sbsa/cuda_nvprune-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "94e0fb67ac1329b22f1e459aad5bdf0188a65c9f03d8635601fc88180d089199",
+            "md5": "057dd355a4eacf501085b35cfcd63cee",
+            "size": "48972"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvprune/windows-x86_64/cuda_nvprune-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "b586c315e32731794f8bc7b3cbccbeb7f535d361f0191b456f730c70ad74612e",
+            "md5": "a42de97cfad819da9f8a9fb7a82a3281",
+            "size": "146651"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvprune/linux-aarch64/cuda_nvprune-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "d5f69d4b4b88d6da0175c9f8ec44b428867a6675dac166de93995b21b69735d7",
+            "md5": "651d49f5add932ee6a631ef99dc7ba0f",
+            "size": "50800"
+        }
+    },
+    "cuda_nvrtc": {
+        "name": "CUDA NVRTC",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvrtc/LICENSE.txt",
+        "version": "12.6.85",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvrtc/linux-x86_64/cuda_nvrtc-linux-x86_64-12.6.85-archive.tar.xz",
+            "sha256": "a4289ba86f0deeccf4e1d94c58559eae4c8184fcb6eaade8fcab45584e6cf402",
+            "md5": "851ab50afd67e9fb4e4dbd6ca71ee10a",
+            "size": "34380240"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvrtc/linux-sbsa/cuda_nvrtc-linux-sbsa-12.6.85-archive.tar.xz",
+            "sha256": "8b8218447645909934712085cad0de259383b5b3f6fd8beea861959fcdcb3663",
+            "md5": "35bcf1f6ce1bda61a562d089dd499015",
+            "size": "31901268"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-12.6.85-archive.zip",
+            "sha256": "b1221a95a3758561bc73c56905743730f7459cbaff54a4870aa899fa3489219e",
+            "md5": "c76df61d80f9b199ad57ea107cdb948a",
+            "size": "188661594"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvrtc/linux-aarch64/cuda_nvrtc-linux-aarch64-12.6.85-archive.tar.xz",
+            "sha256": "9debdacfd445d7c8c2bb79e90088e45544f3ed194f614d2904ab6a749b7997ca",
+            "md5": "9101fcc6051fd3863984a81f37b99854",
+            "size": "33069060"
+        }
+    },
+    "cuda_nvtx": {
+        "name": "CUDA NVTX",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvtx/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvtx/linux-x86_64/cuda_nvtx-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "d97dd4f3bbc23e57302990c1573f737bea55f3174b2c8e3d19067d9b189a446b",
+            "md5": "7064b8cfa7085a9892c47e8e98ac4f7a",
+            "size": "48536"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_nvtx/linux-sbsa/cuda_nvtx-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "498b10e525d4721c127ddefbd81fd97942c011cebf5fe5cbbd7f71814e038c56",
+            "md5": "d1050b70467d8fc6ab0cb09a678689b7",
+            "size": "49076"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "d7726a135f5dc25b4222d684aac6ae98e4cc8a53a49a1235c7c6ca175f8e1e0a",
+            "md5": "a1c5ffd55791dc60212bb54ec55cdbe3",
+            "size": "65837"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_nvtx/linux-aarch64/cuda_nvtx-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "38cafee61f9cf1001e3c2b03de3c85fbea1b4c1b5d84f7fdac72ed7c98cb314a",
+            "md5": "d285db42a0e148ee2ded26bce43226c3",
+            "size": "51720"
+        }
+    },
+    "cuda_nvvp": {
+        "name": "CUDA NVVP",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_nvvp/LICENSE.txt",
+        "version": "12.6.80",
+        "linux-x86_64": {
+            "relative_path": "cuda_nvvp/linux-x86_64/cuda_nvvp-linux-x86_64-12.6.80-archive.tar.xz",
+            "sha256": "ff2bd6d98af535e85d8e216b3110f13fb203130fbe132c0a49b02c872fbdbff5",
+            "md5": "327376a9f604166f5bf2f5175fbc7e7e",
+            "size": "117718608"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_nvvp/windows-x86_64/cuda_nvvp-windows-x86_64-12.6.80-archive.zip",
+            "sha256": "30145b90dd0439ca1389f2eed67d40fd03888798a7853ffac3d1221bd618e860",
+            "md5": "78dd9a6c2cc1965f5e549b60eb66bad1",
+            "size": "120343280"
+        }
+    },
+    "cuda_opencl": {
+        "name": "CUDA OpenCL",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_opencl/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_opencl/linux-x86_64/cuda_opencl-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "aaf8aedb89ad5e4a63ccf564a6ec1073ac17863a7ae2a211a5d8127b3e1d09f4",
+            "md5": "5344e01d090f74d5926c45723dabf849",
+            "size": "92304"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_opencl/windows-x86_64/cuda_opencl-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "dc4555a8920f02d2142d266a8516b26cda7cc2609a20adedb8b268c2c4660971",
+            "md5": "f1f052a1c59d63d981ae47c055424313",
+            "size": "137329"
+        }
+    },
+    "cuda_profiler_api": {
+        "name": "CUDA Profiler API",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_profiler_api/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_profiler_api/linux-x86_64/cuda_profiler_api-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "0807ec2335ea358a96f984ce08cc0b3d572b5cc486f9082fc3afa9a1773f2a58",
+            "md5": "78ff6eced1fc8d26c94c41fb71af7d71",
+            "size": "16188"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_profiler_api/linux-sbsa/cuda_profiler_api-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "a8401ac3a2a4da39febd73b5008a2f0388f4facf52168b15dd5aefbed46bd481",
+            "md5": "fff49b98490bc2aa06b62bee1ba73f60",
+            "size": "16180"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "d0ed383bac1a84d5c1e1d6a3076b80bc581e488093fef5655d55c39a198aea29",
+            "md5": "c66247462b1f770fc9d2798d911e54dd",
+            "size": "20222"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_profiler_api/linux-aarch64/cuda_profiler_api-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "f09f8b865fa07093400faaf1ca24133cf9014d5eebe9596d667687a9e16400f9",
+            "md5": "d0210f5dd6811fb211e2622fe3b7e340",
+            "size": "16176"
+        }
+    },
+    "cuda_sanitizer_api": {
+        "name": "CUDA Compute Sanitizer API",
+        "license": "CUDA Toolkit",
+        "license_path": "cuda_sanitizer_api/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "cuda_sanitizer_api/linux-x86_64/cuda_sanitizer_api-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "6839933c940fe023c133f0e2b41a5d02d4068359a1487ec8bcb82ea9a7237d57",
+            "md5": "d93bcc3e55e23e7c90adb583ca3f854b",
+            "size": "9756336"
+        },
+        "linux-sbsa": {
+            "relative_path": "cuda_sanitizer_api/linux-sbsa/cuda_sanitizer_api-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "686eb7bf05f3dbff6700606f2d65aba7ad413843f7c62cccd7c1433399280c2f",
+            "md5": "b026e2007ae409af19ad6854dd6ea24a",
+            "size": "7252516"
+        },
+        "windows-x86_64": {
+            "relative_path": "cuda_sanitizer_api/windows-x86_64/cuda_sanitizer_api-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "b35cd306e7c61ca224eaf5a4d3a0ee2efb1c8fa6b0fb90f5e2315dcd4c356f71",
+            "md5": "8de75d81500d27768e039efd74fb582e",
+            "size": "9755411"
+        },
+        "linux-aarch64": {
+            "relative_path": "cuda_sanitizer_api/linux-aarch64/cuda_sanitizer_api-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "dbf5b1c1cf51327c449123a80f5b4b3551da3470ff8aa8a11a11902887a6dff8",
+            "md5": "75cda6f13274536fb7f83190739ecd6d",
+            "size": "4105012"
+        }
+    },
+    "fabricmanager": {
+        "name": "NVIDIA Fabric Manager",
+        "license": "NVIDIA Driver",
+        "license_path": "fabricmanager/LICENSE.txt",
+        "version": "560.35.05",
+        "linux-x86_64": {
+            "relative_path": "fabricmanager/linux-x86_64/fabricmanager-linux-x86_64-560.35.05-archive.tar.xz",
+            "sha256": "2e90c351d95d4d5ba2359dbb8ce33d169a585adcbfb888861bed7ab7029bf17a",
+            "md5": "29b695371f46378f7d2da6ffef7b8d0c",
+            "size": "6067832"
+        },
+        "linux-sbsa": {
+            "relative_path": "fabricmanager/linux-sbsa/fabricmanager-linux-sbsa-560.35.05-archive.tar.xz",
+            "sha256": "fe77d0d0d7e0b9082c9d55a601f5408447c825ff19e47e59cbd5d06137a127a2",
+            "md5": "91e8c0678e17479e0c2669ff11263fcc",
+            "size": "5483368"
+        }
+    },
+    "imex": {
+        "name": "Nvidia-Imex",
+        "license": "NVIDIA Proprietary",
+        "license_path": "imex/LICENSE.txt",
+        "version": "560.35.05",
+        "linux-x86_64": {
+            "relative_path": "imex/linux-x86_64/nvidia-imex-linux-x86_64-560.35.05-archive.tar.xz",
+            "sha256": "bc883f4b02cafe57e7abe9160efc1b1f3bdec17c4ae89b50277f0654e702d737",
+            "md5": "74c797604d372ca78c339e88f33f9df5",
+            "size": "7423648"
+        },
+        "linux-sbsa": {
+            "relative_path": "imex/linux-sbsa/nvidia-imex-linux-sbsa-560.35.05-archive.tar.xz",
+            "sha256": "2243a2206554dc653074ded0cbc7112515badf3ad9e5642af3b12eaea8675f9a",
+            "md5": "2fd9e130c8285e28ccb0b261bf43bab9",
+            "size": "6617024"
+        }
+    },
+    "libcublas": {
+        "name": "CUDA cuBLAS",
+        "license": "CUDA Toolkit",
+        "license_path": "libcublas/LICENSE.txt",
+        "version": "12.6.4.1",
+        "linux-x86_64": {
+            "relative_path": "libcublas/linux-x86_64/libcublas-linux-x86_64-12.6.4.1-archive.tar.xz",
+            "sha256": "ec682bac6387f9cdfd0c20b25a16cd6ed0b8b3b7ff42be9eaeb41828e3a72572",
+            "md5": "31f44a2287434fa4d02a96098ec64444",
+            "size": "522827284"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcublas/linux-sbsa/libcublas-linux-sbsa-12.6.4.1-archive.tar.xz",
+            "sha256": "84668dcb2159f9efd912a66ed5afe5d6533b72a81bbabc98b26ac7ac7a36105a",
+            "md5": "cba5edfa0ddf41dc18a56a5198f7d42e",
+            "size": "521142388"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcublas/windows-x86_64/libcublas-windows-x86_64-12.6.4.1-archive.zip",
+            "sha256": "1a87ec80f8c0e5a39badc87010d479930c5b63abd788b3a05bd688a5980a3d07",
+            "md5": "d255e7d0c3716724e4e801393706ada5",
+            "size": "428583217"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcublas/linux-aarch64/libcublas-linux-aarch64-12.6.4.1-archive.tar.xz",
+            "sha256": "3324e0a995794704874c71397964c4739667c279d3e3cb183e482476df9b57ed",
+            "md5": "653242910d499bb5496bcec1ef426aa2",
+            "size": "186089704"
+        }
+    },
+    "libcudla": {
+        "name": "cuDLA",
+        "license": "CUDA Toolkit",
+        "license_path": "libcudla/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-aarch64": {
+            "relative_path": "libcudla/linux-aarch64/libcudla-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "d255c6b436e46d514af4d2899a5166b07204808eaafa6a37539819e360e9cfd1",
+            "md5": "f165e8fb65aa83476b4a3792d5a64eb8",
+            "size": "38464"
+        }
+    },
+    "libcufft": {
+        "name": "CUDA cuFFT",
+        "license": "CUDA Toolkit",
+        "license_path": "libcufft/LICENSE.txt",
+        "version": "11.3.0.4",
+        "linux-x86_64": {
+            "relative_path": "libcufft/linux-x86_64/libcufft-linux-x86_64-11.3.0.4-archive.tar.xz",
+            "sha256": "63a046d51a45388e10612c3fd423bb7fa5127496aa9bb3951a609e8b9d996852",
+            "md5": "de19c7d0e525761fad7b3554ff5dda0c",
+            "size": "476376920"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcufft/linux-sbsa/libcufft-linux-sbsa-11.3.0.4-archive.tar.xz",
+            "sha256": "bce2ae627c9fee47d59850f622e28213aa7dc39fec6759505b9195c858f8701d",
+            "md5": "883ad3ffae02618cb111022028faae25",
+            "size": "476669696"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcufft/windows-x86_64/libcufft-windows-x86_64-11.3.0.4-archive.zip",
+            "sha256": "7b3c75e90a907b3a2d215f7c846d67b684c6ddb76369d1bced67d2cdd411014b",
+            "md5": "336ebef70375322fd258796f831b1c8d",
+            "size": "197843242"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcufft/linux-aarch64/libcufft-linux-aarch64-11.3.0.4-archive.tar.xz",
+            "sha256": "beafc176148563833a4271a6913bc318a004037a8b4f5b73904667a33fe6ecb1",
+            "md5": "2a101674bea1630906205187097dd408",
+            "size": "476526352"
+        }
+    },
+    "libcufile": {
+        "name": "CUDA cuFile",
+        "license": "CUDA Toolkit",
+        "license_path": "libcufile/LICENSE.txt",
+        "version": "1.11.1.6",
+        "linux-x86_64": {
+            "relative_path": "libcufile/linux-x86_64/libcufile-linux-x86_64-1.11.1.6-archive.tar.xz",
+            "sha256": "99ee42e0ebf826f13cea9d15d63f54f225ddc42ff87be1427c58be9692ae25bc",
+            "md5": "1cb6fc8741517038ab956e6eb141a262",
+            "size": "41841440"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcufile/linux-sbsa/libcufile-linux-sbsa-1.11.1.6-archive.tar.xz",
+            "sha256": "fda8d0491f9e3311adb317841893a531737b82316187619e2116d86d7a84faaf",
+            "md5": "9a3dcdf43d42e78ac29d366c46c17764",
+            "size": "41290172"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcufile/linux-aarch64/libcufile-linux-aarch64-1.11.1.6-archive.tar.xz",
+            "sha256": "2d2e461830748ebb508be8cc93c804486618dbd6a53de13fb7976d71a481013a",
+            "md5": "aed61fb0c12b25f8dcb8c80c82c6923f",
+            "size": "41280828"
+        }
+    },
+    "libcurand": {
+        "name": "CUDA cuRAND",
+        "license": "CUDA Toolkit",
+        "license_path": "libcurand/LICENSE.txt",
+        "version": "10.3.7.77",
+        "linux-x86_64": {
+            "relative_path": "libcurand/linux-x86_64/libcurand-linux-x86_64-10.3.7.77-archive.tar.xz",
+            "sha256": "981339cc86d7b8779e9a3c17e72d8c5e1a8a2d06c24db692eecabed8e746a3c7",
+            "md5": "d4b265d626d59f852a41a73b1fea9dc9",
+            "size": "81729748"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcurand/linux-sbsa/libcurand-linux-sbsa-10.3.7.77-archive.tar.xz",
+            "sha256": "a189b8456e86a5f53c73f7fd392bf158d81d72a4e94f6853d2056cd67454e858",
+            "md5": "3f815e6953516eaa3f51b47fea151537",
+            "size": "81711072"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcurand/windows-x86_64/libcurand-windows-x86_64-10.3.7.77-archive.zip",
+            "sha256": "f4554a9bbc933118ff7cde51db2664e17b23ffb5d32715157bee4564bba8bfd7",
+            "md5": "245d5b349e7b7a5deea05e032a7d62ac",
+            "size": "55075353"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcurand/linux-aarch64/libcurand-linux-aarch64-10.3.7.77-archive.tar.xz",
+            "sha256": "eab273ca1d30659f026600d15cd0492d511408ae2141349cdf2edadd3da2661d",
+            "md5": "8739d2194ad5d16db1b90d9210dd51cc",
+            "size": "83949508"
+        }
+    },
+    "libcusolver": {
+        "name": "CUDA cuSOLVER",
+        "license": "CUDA Toolkit",
+        "license_path": "libcusolver/LICENSE.txt",
+        "version": "11.7.1.2",
+        "linux-x86_64": {
+            "relative_path": "libcusolver/linux-x86_64/libcusolver-linux-x86_64-11.7.1.2-archive.tar.xz",
+            "sha256": "7cf794bf21c4947d0922e378984fa7939f0811bfc355121be1a0d44cd8695c09",
+            "md5": "0de2d9376f0ada4792dc931a1313ff60",
+            "size": "159512244"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcusolver/linux-sbsa/libcusolver-linux-sbsa-11.7.1.2-archive.tar.xz",
+            "sha256": "96bdff422ac078049e70442404a5f4027c64d58881efdfd47eb32d3bcfdd3b44",
+            "md5": "f055a72d4f87ecd4c624110713bd286f",
+            "size": "158302060"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcusolver/windows-x86_64/libcusolver-windows-x86_64-11.7.1.2-archive.zip",
+            "sha256": "9999cbbf5d3789bb766ed3336dfb8d9be02832ffc5f36b1c37b9aa099ab47604",
+            "md5": "14cccf5792c2f8ea6dc5a6accb421d3c",
+            "size": "147388290"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcusolver/linux-aarch64/libcusolver-linux-aarch64-11.7.1.2-archive.tar.xz",
+            "sha256": "d7e578143ebd90582873cb4c84f0f29ae1b3f086104a7660f5a63a28a115b9e6",
+            "md5": "9aed9bb2e94efb2aa03c8db542003adb",
+            "size": "174581012"
+        }
+    },
+    "libcusparse": {
+        "name": "CUDA cuSPARSE",
+        "license": "CUDA Toolkit",
+        "license_path": "libcusparse/LICENSE.txt",
+        "version": "12.5.4.2",
+        "linux-x86_64": {
+            "relative_path": "libcusparse/linux-x86_64/libcusparse-linux-x86_64-12.5.4.2-archive.tar.xz",
+            "sha256": "a9ad797756a7bb9a92bf8a63768dec837af38064ee8be3c32e21382e03604bd8",
+            "md5": "e7e5312dbf7d472fec153dfead67c876",
+            "size": "236134716"
+        },
+        "linux-sbsa": {
+            "relative_path": "libcusparse/linux-sbsa/libcusparse-linux-sbsa-12.5.4.2-archive.tar.xz",
+            "sha256": "27f5743ca677a8b0144a824f95f6674f39f3effdac50fdd15e050a9a87069d8b",
+            "md5": "ef319172b2adaace463a08db5a63e209",
+            "size": "235710908"
+        },
+        "windows-x86_64": {
+            "relative_path": "libcusparse/windows-x86_64/libcusparse-windows-x86_64-12.5.4.2-archive.zip",
+            "sha256": "ab409eee74ab63d5f2e78473d5901c0ce4d414161a1b30838d4e0dc857b2452f",
+            "md5": "2978fdfe0029c439441ae6e574fc1edf",
+            "size": "211361778"
+        },
+        "linux-aarch64": {
+            "relative_path": "libcusparse/linux-aarch64/libcusparse-linux-aarch64-12.5.4.2-archive.tar.xz",
+            "sha256": "fc790c3d0d194fc96212bde94c8a22016e63a07d048ac6e9e49fdc8cf2a2dfcc",
+            "md5": "4ab706313af2f1a77f0ee89796fe0f3e",
+            "size": "253390908"
+        }
+    },
+    "libnpp": {
+        "name": "CUDA NPP",
+        "license": "CUDA Toolkit",
+        "license_path": "libnpp/LICENSE.txt",
+        "version": "12.3.1.54",
+        "linux-x86_64": {
+            "relative_path": "libnpp/linux-x86_64/libnpp-linux-x86_64-12.3.1.54-archive.tar.xz",
+            "sha256": "0a7f5bb81e65e60775f831990a567394682a209694b396a4e9233a6c91db65e3",
+            "md5": "f1a61e38a71c751a7c904a66362ccfea",
+            "size": "182688996"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnpp/linux-sbsa/libnpp-linux-sbsa-12.3.1.54-archive.tar.xz",
+            "sha256": "0901bdf3abc7c3d4143acebb058ba5f95c1dfd092f25ce0c52d6b6974585a564",
+            "md5": "3fbbf44ca4a36f6040ffe3b77fa82534",
+            "size": "182191412"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnpp/windows-x86_64/libnpp-windows-x86_64-12.3.1.54-archive.zip",
+            "sha256": "9a5271ce10478945eaa730360226e0c6f408425bb5689d5cf48bb4ca8085a008",
+            "md5": "4c9546d1e16b00cd400871dcfc17a537",
+            "size": "154933759"
+        },
+        "linux-aarch64": {
+            "relative_path": "libnpp/linux-aarch64/libnpp-linux-aarch64-12.3.1.54-archive.tar.xz",
+            "sha256": "eb0473643b991be77b64b31f5e63437203e1167bbc9274d7f6a6ad5114d048fd",
+            "md5": "40c771b024287b7509ada380aad87a15",
+            "size": "200333628"
+        }
+    },
+    "libnvfatbin": {
+        "name": "NVIDIA compiler library for fatbin interaction",
+        "license": "CUDA Toolkit",
+        "license_path": "libnvfatbin/LICENSE.txt",
+        "version": "12.6.77",
+        "linux-x86_64": {
+            "relative_path": "libnvfatbin/linux-x86_64/libnvfatbin-linux-x86_64-12.6.77-archive.tar.xz",
+            "sha256": "a4046f5337656af57bb3861dd80207143dc928c3ff9a12670fb982f1e3e17ee5",
+            "md5": "b0385eef134ed932f3295ed9e13e9839",
+            "size": "909740"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvfatbin/linux-sbsa/libnvfatbin-linux-sbsa-12.6.77-archive.tar.xz",
+            "sha256": "0311c19b6e08b173d915fccfe70a9250b7cac4e456878a0e3bedfc81d878cf2f",
+            "md5": "0fa0ed520efcb7e4228b7f91b2f8fe0a",
+            "size": "818636"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnvfatbin/windows-x86_64/libnvfatbin-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "d54d37d51301f3d478e0f148e1755ab357905876d75e675aa3168c815bf2ed1d",
+            "md5": "d421dfd34e0d2f70613fc9c6b4b66e87",
+            "size": "2181182"
+        },
+        "linux-aarch64": {
+            "relative_path": "libnvfatbin/linux-aarch64/libnvfatbin-linux-aarch64-12.6.77-archive.tar.xz",
+            "sha256": "4d6c69acf31fee099d6065cb4c6fee2fe9bff9299c55e0a957c567377d1c2d64",
+            "md5": "7bd654173af88b4dd0acc38eb21d5929",
+            "size": "792100"
+        }
+    },
+    "libnvidia_nscq": {
+        "name": "NVIDIA NSCQ API",
+        "license": "NVIDIA Driver",
+        "license_path": "libnvidia_nscq/LICENSE.txt",
+        "version": "560.35.05",
+        "linux-x86_64": {
+            "relative_path": "libnvidia_nscq/linux-x86_64/libnvidia_nscq-linux-x86_64-560.35.05-archive.tar.xz",
+            "sha256": "5458c10c0d9d2236ff59aad1229eaf6532e33606225b295c339d5fe6dbcdf63d",
+            "md5": "ee7735500ff7f89d5a4045cc74e69c86",
+            "size": "356512"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvidia_nscq/linux-sbsa/libnvidia_nscq-linux-sbsa-560.35.05-archive.tar.xz",
+            "sha256": "6b567fdf2ece0ea4d1a23cfad35f2ec32a4778276e8025c4cf6c84cab703e36a",
+            "md5": "82f61331e0b8dfbef3f5ff9f783e91a3",
+            "size": "351164"
+        }
+    },
+    "libnvjitlink": {
+        "name": "NVIDIA compiler library for JIT LTO functionality",
+        "license": "CUDA Toolkit",
+        "license_path": "libnvjitlink/LICENSE.txt",
+        "version": "12.6.85",
+        "linux-x86_64": {
+            "relative_path": "libnvjitlink/linux-x86_64/libnvjitlink-linux-x86_64-12.6.85-archive.tar.xz",
+            "sha256": "1055077ce594fad6fd86d23604c60c64b673cdc8dd01fae7e0cbec633c35930d",
+            "md5": "d18300ed688cf96a1828dee9126c5b3c",
+            "size": "28960912"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvjitlink/linux-sbsa/libnvjitlink-linux-sbsa-12.6.85-archive.tar.xz",
+            "sha256": "05e5ddcadc46f17e18e22b9b782e6c19f0d8c8e8bd13c37c51d7f8288fa9810e",
+            "md5": "e3ecdefeb7568ecdb7214f7dd746613b",
+            "size": "26727900"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnvjitlink/windows-x86_64/libnvjitlink-windows-x86_64-12.6.85-archive.zip",
+            "sha256": "035445b0be5f7cf4b7ee26f0a476de9d25322857b728df270bb11f3e61d0623f",
+            "md5": "122bc2d883ddb1523e6f9407e76d2e5e",
+            "size": "153235665"
+        },
+        "linux-aarch64": {
+            "relative_path": "libnvjitlink/linux-aarch64/libnvjitlink-linux-aarch64-12.6.85-archive.tar.xz",
+            "sha256": "65497b5bf4abd81fa993bf89996e7e9678a801284d8df798ddceb00502972ed6",
+            "md5": "d3de43c454927535f637866a07c1eec7",
+            "size": "27881168"
+        }
+    },
+    "libnvjpeg": {
+        "name": "CUDA nvJPEG",
+        "license": "CUDA Toolkit",
+        "license_path": "libnvjpeg/LICENSE.txt",
+        "version": "12.3.3.54",
+        "linux-x86_64": {
+            "relative_path": "libnvjpeg/linux-x86_64/libnvjpeg-linux-x86_64-12.3.3.54-archive.tar.xz",
+            "sha256": "f74f6aee35ef4fb1619bc2a67be943c3d1a84d6746b41788c44a7d3b0d9ae3b4",
+            "md5": "e21f0dc4f94bc875ef99e1afbfd85bbe",
+            "size": "2579560"
+        },
+        "linux-sbsa": {
+            "relative_path": "libnvjpeg/linux-sbsa/libnvjpeg-linux-sbsa-12.3.3.54-archive.tar.xz",
+            "sha256": "6970db1c9757f3ae30adba21d7c1306fd5afc4cb034b0739c711691a481d3ed4",
+            "md5": "01811faaa7d3de0353169948247aeb02",
+            "size": "2418632"
+        },
+        "windows-x86_64": {
+            "relative_path": "libnvjpeg/windows-x86_64/libnvjpeg-windows-x86_64-12.3.3.54-archive.zip",
+            "sha256": "15c1b28e623598eb75f48d02bfd34efa83b35e3f8d1d5241c93a385d0bea9d18",
+            "md5": "63f0c5626a07b2850e6eadb704685d69",
+            "size": "2829340"
+        },
+        "linux-aarch64": {
+            "relative_path": "libnvjpeg/linux-aarch64/libnvjpeg-linux-aarch64-12.3.3.54-archive.tar.xz",
+            "sha256": "e81f56682cb4d6e837d5527aaf1acd26ab8eace470b5e7a32f9a8d685e7ef2bc",
+            "md5": "6e90b73e124be49f09b9fe517dff5bb6",
+            "size": "2562184"
+        }
+    },
+    "libnvsdm": {
+        "name": "LIBNVSDM",
+        "license": "NVIDIA",
+        "license_path": "libnvsdm/LICENSE.txt",
+        "version": "560.35.05",
+        "linux-x86_64": {
+            "relative_path": "libnvsdm/linux-x86_64/libnvsdm-linux-x86_64-560.35.05-archive.tar.xz",
+            "sha256": "e122bd02de900b86f86b4725f713e8a040dae4f5f07e4b4fb6de7a7a1adcb088",
+            "md5": "85eebfb90260150f28a9e643a3c1ae61",
+            "size": "549728"
+        }
+    },
+    "nsight_compute": {
+        "name": "Nsight Compute",
+        "license": "NVIDIA SLA",
+        "license_path": "nsight_compute/LICENSE.txt",
+        "version": "2024.3.2.3",
+        "linux-x86_64": {
+            "relative_path": "nsight_compute/linux-x86_64/nsight_compute-linux-x86_64-2024.3.2.3-archive.tar.xz",
+            "sha256": "c37b4e45582a5eef39f5f3b4aee89e8805eac5ce236c960d7a42b97106ceb4d9",
+            "md5": "a14bdec76126b4a642aa636eca3e3f76",
+            "size": "429295908"
+        },
+        "linux-sbsa": {
+            "relative_path": "nsight_compute/linux-sbsa/nsight_compute-linux-sbsa-2024.3.2.3-archive.tar.xz",
+            "sha256": "213e080e2b7ccbbc11ae55dffd316cf24d6e46811b23a2b3596190b4cd12f919",
+            "md5": "9c9abcc88a967d7fab4e9503bf6953b0",
+            "size": "218632392"
+        },
+        "windows-x86_64": {
+            "relative_path": "nsight_compute/windows-x86_64/nsight_compute-windows-x86_64-2024.3.2.3-archive.zip",
+            "sha256": "7a7d8b33aa928f5e1fe130e239ca869ff019e4e0e2103d6f0b8bbdecfa642987",
+            "md5": "2500473f4975306dd0f7ee06ab8e49b4",
+            "size": "462207543"
+        },
+        "linux-aarch64": {
+            "relative_path": "nsight_compute/linux-aarch64/nsight_compute-linux-aarch64-2024.3.2.3-archive.tar.xz",
+            "sha256": "ae5d005c398a97f410b57ddc9eb12b5bf74502e861678b9067959bf2d98cfcff",
+            "md5": "94c85a947f3f8c00b95c34766297ae9c",
+            "size": "429331864"
+        }
+    },
+    "nsight_systems": {
+        "name": "Nsight Systems",
+        "license": "NVIDIA SLA",
+        "license_path": "nsight_systems/LICENSE.txt",
+        "version": "2024.5.1.113",
+        "linux-x86_64": {
+            "relative_path": "nsight_systems/linux-x86_64/nsight_systems-linux-x86_64-2024.5.1.113-archive.tar.xz",
+            "sha256": "b34b829866bcd2c38432ea9c3f4f2feaca52dead50391e3f3bcce654fafdcc2b",
+            "md5": "3579478a0393dbfdc4d0b854f4a55212",
+            "size": "254397476"
+        },
+        "linux-sbsa": {
+            "relative_path": "nsight_systems/linux-sbsa/nsight_systems-linux-sbsa-2024.5.1.113-archive.tar.xz",
+            "sha256": "c19dc46fc7846abd8dfb4058bb9877232937238682c5d212f61adb39ca2eaadc",
+            "md5": "a800f94276f04817cdce5c7fbeafa61a",
+            "size": "215840944"
+        },
+        "windows-x86_64": {
+            "relative_path": "nsight_systems/windows-x86_64/nsight_systems-windows-x86_64-2024.5.1.113-archive.zip",
+            "sha256": "5bc27dba701c9dadc0659f7a471866d6d7af717db0c741bba87fb9ec18bd130e",
+            "md5": "ab5730ccd853fbfe0bca3ab0d3cbed52",
+            "size": "350421706"
+        }
+    },
+    "nsight_vse": {
+        "name": "Nsight Visual Studio Edition (VSE)",
+        "license": "NVIDIA SLA",
+        "license_path": "nsight_vse/LICENSE.txt",
+        "version": "2024.3.0.24164",
+        "windows-x86_64": {
+            "relative_path": "nsight_vse/windows-x86_64/nsight_vse-windows-x86_64-2024.3.0.24164-archive.zip",
+            "sha256": "f06b1b9d9e4bcdf6cb44a85c506ecbf55482c4557df02c1906c1d469986b371a",
+            "md5": "e86b066ca8aa0922c2db274757e40dad",
+            "size": "471792358"
+        }
+    },
+    "nvidia_driver": {
+        "name": "NVIDIA Linux Driver",
+        "license": "NVIDIA Driver",
+        "license_path": "nvidia_driver/LICENSE.txt",
+        "version": "560.35.05",
+        "linux-x86_64": {
+            "relative_path": "nvidia_driver/linux-x86_64/nvidia_driver-linux-x86_64-560.35.05-archive.tar.xz",
+            "sha256": "665d0189535e06f79e5791d1971e6892492593964d4013cb6497461254cebdfe",
+            "md5": "19b49dd51599aab329e5ba3958f3965e",
+            "size": "375248208"
+        },
+        "linux-sbsa": {
+            "relative_path": "nvidia_driver/linux-sbsa/nvidia_driver-linux-sbsa-560.35.05-archive.tar.xz",
+            "sha256": "766b61e7a006015867a7bf62a802c585e30eb54d70f2e5b10902866c12550da9",
+            "md5": "149d3a974cccdc95e2d7d811218f47c5",
+            "size": "287682956"
+        }
+    },
+    "nvidia_fs": {
+        "name": "NVIDIA filesystem",
+        "license": "CUDA Toolkit",
+        "license_path": "nvidia_fs/LICENSE.txt",
+        "version": "2.22.3",
+        "linux-x86_64": {
+            "relative_path": "nvidia_fs/linux-x86_64/nvidia_fs-linux-x86_64-2.22.3-archive.tar.xz",
+            "sha256": "67ac2e05a6388db2824c454e0bdd808d662aa1fe63ad3292471b144fb0c7fad1",
+            "md5": "605ff67650a8ae1f72a9bd8540ed0ee0",
+            "size": "59284"
+        },
+        "linux-sbsa": {
+            "relative_path": "nvidia_fs/linux-sbsa/nvidia_fs-linux-sbsa-2.22.3-archive.tar.xz",
+            "sha256": "1c73cfb016ce4c6b0c99d46084a678a5e062875e1180b556bda624f7648653f6",
+            "md5": "8debe062baaa33cd4283237d112633c4",
+            "size": "59284"
+        },
+        "linux-aarch64": {
+            "relative_path": "nvidia_fs/linux-aarch64/nvidia_fs-linux-aarch64-2.22.3-archive.tar.xz",
+            "sha256": "7d8db9cf65b6c29198a6c29749ffb5aea3367c1adee71c6bd10169fcaca488db",
+            "md5": "076dbd175b9dbacd9a199f29069161e5",
+            "size": "59288"
+        }
+    },
+    "visual_studio_integration": {
+        "name": "CUDA Visual Studio Integration",
+        "license": "CUDA Toolkit",
+        "license_path": "visual_studio_integration/LICENSE.txt",
+        "version": "12.6.77",
+        "windows-x86_64": {
+            "relative_path": "visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-12.6.77-archive.zip",
+            "sha256": "79345a5f54a2dcd72b8324586a22a3545d948567fa3fd144038a6261866818a3",
+            "md5": "f59a994431512c0040cd381a66287086",
+            "size": "533182"
+        }
+    }
+}

pkgs/development/cuda-modules/cuda/overrides.nix

···
         prevAttrs.buildInputs
         # x86_64 only needs gmp from 12.0 and on
         ++ lib.lists.optionals (cudaAtLeast "12.0") [ gmp ]
-        # Additional dependencies for CUDA 12.6 and later, which
+        # Additional dependencies for CUDA 12.5 and later, which
         # support multiple Python versions.
-        ++ lib.lists.optionals (cudaAtLeast "12.6") [
+        ++ lib.lists.optionals (cudaAtLeast "12.5") [
           libxcrypt-legacy
           ncurses6
           python39
···
         prevAttrs.installPhase
         # Python 3.8 is not in nixpkgs anymore, delete Python 3.8 cuda-gdb support
         # to avoid autopatchelf failing to find libpython3.8.so.
-        + lib.optionalString (cudaAtLeast "12.6") ''
+        + lib.optionalString (cudaAtLeast "12.5") ''
           find $bin -name '*python3.8*' -delete
         '';
     };
···
 
       postPatch =
         let
-          nvvmReplace = lib.optionalString (cudaOlder "12.6") ''
+          nvvmReplace = lib.optionalString (cudaOlder "12.5") ''
             --replace-fail \
               '$(TOP)/$(_NVVM_BRANCH_)' \
               "''${!outputBin}/nvvm" \

pkgs/development/cuda-modules/cudatoolkit/releases.nix

···
   };
 
   "12.3" = {
-    version = "12.3.0";
-    url = "https://developer.download.nvidia.com/compute/cuda/12.3.0/local_installers/cuda_12.3.0_545.23.06_linux.run";
-    sha256 = "sha256-fBP6zjr2TW4WSNbjEB0xyBEedHFDrLAHfZc8FpCCBCI=";
+    version = "12.3.2";
+    url = "https://developer.download.nvidia.com/compute/cuda/12.3.2/local_installers/cuda_12.3.2_545.23.08_linux.run";
+    sha256 = "sha256-JLKvyfdw2M9D1vp63C6/1HxAhNsBvdoc484KTUk7pls=";
   };
 
   "12.4" = {
···
     sha256 = "sha256-5qhC9OypSQV1zbaLaxu3jUe5Wol95I3uKSxDGJLlfRc=";
   };
 
+  "12.5" = {
+    version = "12.5.1";
+    url = "https://developer.download.nvidia.com/compute/cuda/12.5.1/local_installers/cuda_12.5.1_555.42.06_linux.run";
+    sha256 = "sha256-teCneeCJyGYQBRFBxM9Ji+70MYWOxjOYEHORcn7L2wQ=";
+  };
+
   "12.6" = {
-    version = "12.6.0";
-    url = "https://developer.download.nvidia.com/compute/cuda/12.6.0/local_installers/cuda_12.6.0_560.28.03_linux.run";
-    sha256 = "sha256-MasEOU5psU3YZW4rRMKHfbGg6Jjf+KdUakxihDgQG5Q=";
+    version = "12.6.3";
+    url = "https://developer.download.nvidia.com/compute/cuda/12.6.3/local_installers/cuda_12.6.3_560.35.05_linux.run";
+    sha256 = "sha256-gdYOSARHlteIOqigSa/mUBuEPyxFY5s3A7I3jeMNVdM=";
   };
 
   "12.8" = {

pkgs/development/cuda-modules/nvcc-compatibilities.nix

···
       gccMaxMajorVersion = "13";
     };
 
+    # No changes from 12.4 to 12.5
+    "12.5" = attrs."12.4";
+
     # Added support for Clang 18
     # https://docs.nvidia.com/cuda/archive/12.6.0/cuda-installation-guide-linux/index.html#host-compiler-support-policy
     "12.6" = attrs."12.4" // {

pkgs/development/python-modules/google-cloud-network-connectivity/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-network-connectivity";
-  version = "2.7.0";
+  version = "2.7.1";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
   src = fetchPypi {
     inherit version;
     pname = "google_cloud_network_connectivity";
-    hash = "sha256-RzYM+qqALaTtxyOJQz7G6xqUUznSg+7uVN/ZUOjSg90=";
+    hash = "sha256-caOyIo4FKGQgpa0x7lKzrsaL5nrqqg8Q1iGITY3foME=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/nixpkgs-updaters-library/default.nix

···
 }:
 buildPythonPackage rec {
   pname = "nixpkgs-updaters-library";
-  version = "1.1.0";
+  version = "1.2.0";
   pyproject = true;
 
   disabled = pythonOlder "3.12";
···
     owner = "PerchunPak";
     repo = "nixpkgs-updaters-library";
     tag = "v${version}";
-    hash = "sha256-gg+y3w0d2GKJ56XZ4Xw9OYTJ5GwqGkTZ/fRXwDhTEDE=";
+    hash = "sha256-MCMqqAGl6OTOapC3K0DNTOmg2Lv2KqXenEgB5sIZR5U=";
   };
 
   postPatch = ''

pkgs/development/python-modules/py-sonic/default.nix

···
 
 buildPythonPackage rec {
   pname = "py-sonic";
-  version = "1.0.1";
+  version = "1.0.2";
   format = "setuptools";
   disabled = isPy27;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-DU1T86T0jQ6ptkWdjuV70VC8MFx/rK5aQFYjbK6F2Hk=";
+    hash = "sha256-GNjF7sW/5Mtbh0atpEVFt+M8XddNfedDVmxxOpDdIW4=";
   };
 
   # package has no tests

pkgs/development/python-modules/pyrail/default.nix

···
 
 buildPythonPackage rec {
   pname = "pyrail";
-  version = "0.4.0";
+  version = "0.4.1";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "tjorim";
     repo = "pyrail";
     tag = "v${version}";
-    hash = "sha256-6CE8FrBCVcO88kGwqAMBx9dp5b27oeCm/w1PrEf6a0E=";
+    hash = "sha256-MFsFtspL9cmhwu2oo8wx0Sjx2VpQe92JP9e0M7U8CL8=";
   };
 
   build-system = [ poetry-core ];

pkgs/development/python-modules/pytensor/default.nix

···
 
 buildPythonPackage rec {
   pname = "pytensor";
-  version = "2.28.0";
+  version = "2.28.1";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "pymc-devs";
     repo = "pytensor";
     tag = "rel-${version}";
-    hash = "sha256-jwx7fcMiFNvnwP746nM2rqo2BD6PEbKkfEwIz8MenN4=";
+    hash = "sha256-vDgGcTDvtAxkEln4x43wZnMvn24mFzGfbxHd8Ny2/VQ=";
   };
 
   pythonRelaxDeps = [

pkgs/development/python-modules/sgp4/default.nix

···
 
 buildPythonPackage rec {
   pname = "sgp4";
-  version = "2.23";
+  version = "2.24";
   format = "setuptools";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-2K3cU6L7n4je5r/UAdKGWwFMwLV78s7mm97o2WhdVCk=";
+    hash = "sha256-VlUknyduoj+9rp6IGrAdgkIChbRdx20NpPQk42R/g1I=";
   };
 
   nativeCheckInputs = [ numpy ];

pkgs/development/python-modules/trimesh/default.nix

···
 
 buildPythonPackage rec {
   pname = "trimesh";
-  version = "4.6.2";
+  version = "4.6.3";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "mikedh";
     repo = "trimesh";
     tag = version;
-    hash = "sha256-ttOawg1mdGkV1Pi0CmFR4VtmZ9MUxPed0KoXLwlbUPE=";
+    hash = "sha256-QKV0qb36BfJWbmbqTXzPFY2X6SD+B3FxWSoDltDP8fM=";
   };
 
   build-system = [ setuptools ];
···
   meta = {
     description = "Python library for loading and using triangular meshes";
     homepage = "https://trimesh.org/";
-    changelog = "https://github.com/mikedh/trimesh/releases/tag/${version}";
+    changelog = "https://github.com/mikedh/trimesh/releases/tag/${src.tag}";
     license = lib.licenses.mit;
     mainProgram = "trimesh";
     maintainers = with lib.maintainers; [

pkgs/development/python-modules/yte/default.nix

···
 
 buildPythonPackage rec {
   pname = "yte";
-  version = "1.5.7";
+  version = "1.7.0";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
     owner = "koesterlab";
     repo = "yte";
     tag = "v${version}";
-    hash = "sha256-mcg002lMUjrU/AAhioSBiB+vBIU9fAUBIKLoLS/9OVI=";
+    hash = "sha256-W9t2BlBp947Rwnq+IKbL5aJqauZmYQOzuBIstw6hHQY=";
   };
 
   build-system = [ poetry-core ];
···
   meta = with lib; {
     description = "YAML template engine with Python expressions";
     homepage = "https://github.com/koesterlab/yte";
-    changelog = "https://github.com/yte-template-engine/yte/blob/v${version}/CHANGELOG.md";
+    changelog = "https://github.com/yte-template-engine/yte/blob/${src.tag}/CHANGELOG.md";
     license = licenses.mit;
     maintainers = with maintainers; [ fab ];
     mainProgram = "yte";

pkgs/servers/home-assistant/custom-components/solax_modbus/package.nix

···
 buildHomeAssistantComponent rec {
   owner = "wills106";
   domain = "solax_modbus";
-  version = "2025.01.9";
+  version = "2025.02.1";
 
   src = fetchFromGitHub {
     owner = "wills106";
     repo = "homeassistant-solax-modbus";
     tag = version;
-    hash = "sha256-x9dlqc2kckrd0C5W7VfNQGhuSODxopzwO4gOSeSOl1E=";
+    hash = "sha256-xOW/jjBXw6N00yo1jE8ibU5XJ9drabBypVAL9UmNMVM=";
   };
 
   dependencies = [ pymodbus ];

pkgs/servers/monitoring/nagios-plugins/check_ssl_cert/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "check_ssl_cert";
-  version = "2.86.0";
+  version = "2.86.1";
 
   src = fetchFromGitHub {
     owner = "matteocorti";
     repo = "check_ssl_cert";
     tag = "v${version}";
-    hash = "sha256-IXwy6iRjrXVxpZiAYLMVmAgwm7Z8Ck/B0Mwi1UlRcSs=";
+    hash = "sha256-CCE6TsgljeTmmBPaLqtrYFaaUBnYvVnJcz7KQ4gxec8=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/servers/monitoring/prometheus/domain-exporter.nix

···
 
 buildGoModule rec {
   pname = "domain-exporter";
-  version = "1.24.0";
+  version = "1.24.1";
 
   src = fetchFromGitHub {
     owner = "caarlos0";
     repo = "domain_exporter";
     rev = "v${version}";
-    hash = "sha256-ExMCdrel9uRCn31cKsZkrb3yojvO0UvJYytAn1eptyo=";
+    hash = "sha256-qk/shaWY7M2JDx6W4e7z8Nv7yWUZKZNGZE/mj4zCZHw=";
   };
 
-  vendorHash = "sha256-NfwxwfUpVNSARcVqOQgM++PkyLmTvXuN9nYBEPX2peY=";
+  vendorHash = "sha256-1j5alRdCbO/ZJhuvVuiSsNBMRm7RqMOY/ex6US7qaxU=";
 
   doCheck = false; # needs internet connection
 

pkgs/shells/fish/plugins/nvm.nix

···
 }:
 buildFishPlugin rec {
   pname = "nvm";
-  version = "2.2.16";
+  version = "2.2.17";
   src = fetchFromGitHub {
     owner = "jorgebucaran";
     repo = "nvm.fish";
     tag = version;
-    hash = "sha256-GTEkCm+OtxMS3zJI5gnFvvObkrpepq1349/LcEPQRDo=";
+    hash = "sha256-BNnoP9gLQuZQt/0SOOsZaYOexNN2K7PKWT/paS0BJJY=";
   };
 
   meta = {

pkgs/tools/misc/minicom/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "minicom";
-  version = "2.9";
+  version = "2.10";
 
   src = fetchFromGitLab {
     domain = "salsa.debian.org";
     owner = "minicom-team";
     repo = pname;
     rev = version;
-    sha256 = "sha256-+fKvHrApDXm94LItXv+xSDIE5zD7rTY5IeNSuzQglpg=";
+    sha256 = "sha256-wC6VlMRwuhV1zQ26wNx7gijuze8E2CvnzpqOSIPzq2s=";
   };
 
   buildInputs =

pkgs/top-level/aliases.nix

···
   ring-daemon = throw "'ring-daemon' has been renamed to/replaced by 'jami-daemon'"; # Converted to throw 2024-10-17
   rippled = throw "rippled has been removed as it was broken and had not been updated since 2022"; # Added 2024-11-25
   rippled-validator-keys-tool = throw "rippled-validator-keys-tool has been removed as it was broken and had not been updated since 2022"; # Added 2024-11-25
+  rke2_testing = throw "'rke2_testing' has been removed from nixpkgs as the RKE2 testing channel no longer serves releases"; # Added 2025-06-02
   rockbox_utility = rockbox-utility; # Added 2022-03-17
   rnix-hashes = throw "'rnix-hashes' has been removed due to lack of upstream maintenance"; # Added 2025-01-25
   rpiboot-unstable = throw "'rpiboot-unstable' has been renamed to/replaced by 'rpiboot'"; # Converted to throw 2024-10-17

pkgs/top-level/all-packages.nix

···
   cudaPackages_12_2 = callPackage ./cuda-packages.nix { cudaVersion = "12.2"; };
   cudaPackages_12_3 = callPackage ./cuda-packages.nix { cudaVersion = "12.3"; };
   cudaPackages_12_4 = callPackage ./cuda-packages.nix { cudaVersion = "12.4"; };
+  cudaPackages_12_5 = callPackage ./cuda-packages.nix { cudaVersion = "12.5"; };
   cudaPackages_12_6 = callPackage ./cuda-packages.nix { cudaVersion = "12.6"; };
   cudaPackages_12_8 = callPackage ./cuda-packages.nix { cudaVersion = "12.8"; };
   cudaPackages_12 = cudaPackages_12_4; # Latest supported by cudnn
···
   else
     callPackage ../applications/networking/instant-messengers/ripcord/darwin.nix { };
 
-  inherit (callPackage ../applications/networking/cluster/rke2 { }) rke2_stable rke2_latest rke2_testing;
+  inherit (callPackage ../applications/networking/cluster/rke2 { })
+    rke2_1_29
+    rke2_1_30
+    rke2_1_31
+    rke2_1_32
+    rke2_stable
+    rke2_latest
+    ;
   rke2 = rke2_stable;
 
   rofi-unwrapped = callPackage ../applications/misc/rofi { };