README.md

---
license: other
license_name: nvidia-cuda-cudnn-redistributable
license_link: https://docs.nvidia.com/cuda/eula/index.html
pretty_name: MBFS CUDA + TensorRT Runtime Bundle (cuda_v12 + cuda_v11 + trt_v12)
tags:
  - cuda
  - cudnn
  - tensorrt
  - onnxruntime
  - runtime-libraries
  - windows
---

# MBFS CUDA Runtime Bundle

Self-contained, **ABI-matched** CUDA execution stacks for running
[ONNX Runtime](https://onnxruntime.ai/) on Windows with the CUDA / TensorRT
execution providers. One folder per CUDA major version:

| Stack | Folder | CUDA | cuDNN | ONNX Runtime EP | When to use |
|---|---|---|---|---|---|
| **cu12** | [`cuda_v12/`](./cuda_v12) | 12.x | 9 | CUDA + TensorRT 10 | sm_75+ GPU on driver **R527+** (CUDA 12) |
| **cu11** | [`cuda_v11/`](./cuda_v11) | 11.x | 8 | CUDA + TensorRT 8.6 | Pascal/Volta (sm_60–sm_70), or any GPU on a driver capped at CUDA 11.x |

Pick the stack matching your GPU **and** driver: a newer GPU on an older driver
must still use `cu11` (loading `cu12` binaries fails with
`cudaErrorNoKernelImageForDevice`). The MBFS Sentinel build auto-detects this —
`scripts/build_windows.py` clamps the stack to the lower of the GPU and driver
ceilings (override with `--gpu-stack`).

**TensorRT engine-build libraries** live in a *companion* folder,
[`trt_v12/`](./trt_v12) (for the `cu12` stack). These are the TensorRT 10
runtime + parser (`nvinfer*`, `nvonnxparser`) and the per-SM **builder
resources** used when TensorRT compiles an engine. It is **not** a standalone
CUDA stack — pair it with `cuda_v12/` (whose `onnxruntime_providers_tensorrt.dll`
is only the small ONNX Runtime ↔ TensorRT bridge). Unlike the CUDA folders,
`trt_v12/` is fetched **selectively**: a build downloads only the one builder
resource matching the target GPU's compute capability (plus the always-included
PTX fallback), not the whole ~2.8 GiB set. See
**[Contents (`trt_v12/`)](#contents-trt_v12)**.

> ⚠️ These are **runtime redistributable libraries**, not source. The CUDA,
> cuDNN, and TensorRT DLLs are © NVIDIA Corporation and remain under NVIDIA's
> licenses — see **[License & redistribution](#license--redistribution)** below.

## Contents (`cuda_v12/`)

| File | Component | Approx. size |
|---|---|---|
| `onnxruntime.dll` | ONNX Runtime 1.23.2 (combined CUDA + DirectML + TensorRT + CPU build) | 15 MB |
| `onnxruntime_providers_cuda.dll` | ONNX Runtime CUDA execution provider | 361 MB |
| `onnxruntime_providers_tensorrt.dll` | ONNX Runtime TensorRT execution provider | <1 MB |
| `onnxruntime_providers_shared.dll` | ONNX Runtime shared provider interface | <1 MB |
| `cublas64_12.dll`, `cublasLt64_12.dll` | CUDA 12 cuBLAS | 96 / 451 MB |
| `cudart64_12.dll` | CUDA 12 runtime | <1 MB |
| `cufft64_11.dll` | CUDA 12 cuFFT | 279 MB |
| `curand64_10.dll`, `cusparse64_12.dll` | CUDA 12 cuRAND / cuSPARSE | 62 / 264 MB |
| `cudnn64_9.dll` + `cudnn_*64_9.dll` (7 files) | cuDNN 9 | ~1.4 GB |

**Total ≈ 2.3 GiB.**

## Contents (`cuda_v11/`)

| File | Component | Approx. size |
|---|---|---|
| `onnxruntime.dll` | ONNX Runtime (CUDA + TensorRT + CPU build) | 13 MB |
| `onnxruntime_providers_cuda.dll` | ONNX Runtime CUDA execution provider | 223 MB |
| `onnxruntime_providers_tensorrt.dll` | ONNX Runtime TensorRT execution provider | <1 MB |
| `onnxruntime_providers_shared.dll` | ONNX Runtime shared provider interface | <1 MB |
| `cublas64_11.dll`, `cublasLt64_11.dll` | CUDA 11 cuBLAS | 85 / 519 MB |
| `cudart64_110.dll` | CUDA 11 runtime | <1 MB |
| `cufft64_10.dll` | CUDA 11 cuFFT | 267 MB |
| `curand64_10.dll`, `cusparse64_11.dll` | CUDA 11 cuRAND / cuSPARSE | 62 / 265 MB |
| `cudnn64_8.dll` + `cudnn_{adv,cnn,ops}_{infer,train}64_8.dll` (6 files) | cuDNN 8 | ~1.0 GB |

**Total ≈ 2.4 GiB.** cuDNN 8 keeps inference and training libraries split
(`*_infer` / `*_train`), unlike cuDNN 9.

> All DLLs in a folder come from a single matched build — the ONNX Runtime
> provider DLLs are ABI-locked to that folder's `onnxruntime.dll`, so each set
> must be used together (never mix DLLs across folders or with another ONNX
> Runtime release, or the CUDA EP fails to load).

## Contents (`trt_v12/`)

TensorRT 10 for the `cu12` stack, split into **core** (always needed) and
**per-SM builder resources** (one per GPU architecture). A build pulls the core
plus **only** the resource matching the target GPU's compute capability, plus
the PTX fallback — typically ≈ 1.0–1.7 GiB instead of the full ≈ 2.8 GiB.

**Core — always downloaded:**

| File | Component | Approx. size |
|---|---|---|
| `nvinfer_10.dll` | TensorRT 10 core inference runtime + builder | 432 MB |
| `nvinfer_plugin_10.dll` | TensorRT 10 standard plugins | 53 MB |
| `nvonnxparser_10.dll` | ONNX → TensorRT network parser | 3 MB |
| `nvrtc64_120_0.dll` | NVRTC runtime compiler (CUDA 12) | 44 MB |

**Per-SM builder resources — download only the one matching your GPU:**

| File | Architecture | Example GPUs | Approx. size |
|---|---|---|---|
| `nvinfer_builder_resource_ptx_10.dll` | **PTX JIT fallback — always included** | (any, forward-compat) | 488 MB |
| `nvinfer_builder_resource_sm75_10.dll` | Turing | T4, RTX 20xx | 157 MB |
| `nvinfer_builder_resource_sm80_10.dll` | Ampere | A100, A30 | 256 MB |
| `nvinfer_builder_resource_sm86_10.dll` | Ampere | A40, RTX 30xx | 241 MB |
| `nvinfer_builder_resource_sm89_10.dll` | Ada | L4, L40, RTX 40xx | 254 MB |
| `nvinfer_builder_resource_sm90_10.dll` | Hopper | H100, H200 | 661 MB |
| `nvinfer_builder_resource_sm120_10.dll` | Blackwell | B100/B200, RTX 50xx | 377 MB |

**Full set ≈ 2.8 GiB** (4 core + 7 resources). Example single-SM footprint —
Ampere A30 (sm80): core (532 MB) + PTX (488 MB) + `sm80` (256 MB) ≈ **1.2 GiB**.

> The builder resources are only needed when TensorRT **compiles** an engine
> (the first run for a given model/GPU). `nvinfer_10.dll` loads the matching
> `nvinfer_builder_resource_sm<cc>_10.dll` from the DLL search path at
> engine-build time; the MBFS Sentinel build stages them under
> `dist/lib/trt_v12/` and adds that directory to the process `PATH`. Once an
> engine cache (`.engine`/`.trt`) exists, the resource for that SM is no longer
> read.

## Requirements

- **OS:** Windows x64
- **NVIDIA driver:** `cu12` needs **R527+** (CUDA 12.x); `cu11` needs **R452+**
  (CUDA 11.x). The CUDA *Toolkit* does **not** need to be installed — these
  bundles ship the runtime.
- **GPU:** see the support notes below.

## GPU support

### `cu12`

`cuda_v12/onnxruntime_providers_cuda.dll` is compiled with cubins for the
following architectures (no PTX is embedded, so there is **no JIT
forward-compatibility** to newer archs):

| Compute capability | Architecture | Example GPUs | Native CUDA |
|---|---|---|---|
| 5.2 | Maxwell | GTX 9xx | ✅ |
| 6.0 | Pascal | Tesla P100 | ✅ |
| 7.0 | Volta | V100 | ✅ |
| 7.5 | Turing | T4, RTX 20xx | ✅ |
| 8.0 | Ampere | A100, A30 | ✅ |
| 8.6 | Ampere | A40, RTX 30xx | ✅ |
| 8.9 | Ada | L4, L40, RTX 40xx | ✅ |
| 9.0a | Hopper | H100, H200 | ✅ |
| 10.x / 12.x | **Blackwell** | B100/B200, RTX 50xx | ❌ not native |

For the **TensorRT** path the per-SM builder resources in `trt_v12/` cover
`sm75 / sm80 / sm86 / sm89 / sm90 / sm120`; older archs (sm_52/60/70) fall back
to the PTX builder resource (JIT). Pick the resource by compute capability:
`sm = major*10 + minor` (e.g. 8.0 → `sm80`, 12.0 → `sm120`).

### `cu11`

The `cu11` stack is the fallback for machines that predate CUDA 12: NVIDIA
**Pascal (sm_60) → Volta (sm_70)**, and any otherwise-cu12-capable GPU running
on a driver that only supports CUDA 11.x. Use it when `nvidia-smi` reports a
CUDA version below 12.0, or for Pascal/Volta silicon. For newer GPUs on a
current driver, prefer `cu12`.

On a GPU outside the supported range, or with a too-old driver, the host
application should fall back to DirectML (`DmlExecutionProvider`, requires
`DirectML.dll` — **not** included here) or CPU. These bundles cover the native
CUDA path only.

## Usage

The MBFS Sentinel build pulls the right stack automatically
(`build_windows.py --gpu-stack {cu12|cu11} --cuda-source hf`), including the
matching TensorRT builder resource (`--tensorrt-source hf`, default). To fetch a
stack manually:

```bash
# cu12 into ./dist/lib (lands at ./dist/lib/cuda_v12/)
hf download MBFSAITeam/cuda-runtime-bundle --repo-type dataset \
  --include "cuda_v12/*" --local-dir ./dist/lib

# cu11 into ./dist/lib (lands at ./dist/lib/cuda_v11/)
hf download MBFSAITeam/cuda-runtime-bundle --repo-type dataset \
  --include "cuda_v11/*" --local-dir ./dist/lib
```

For TensorRT, fetch the **core + PTX + only your GPU's SM** instead of the whole
folder (example for an Ampere A30, sm80):

```bash
hf download MBFSAITeam/cuda-runtime-bundle --repo-type dataset \
  --include "trt_v12/nvinfer_10.dll" \
  --include "trt_v12/nvinfer_plugin_10.dll" \
  --include "trt_v12/nvonnxparser_10.dll" \
  --include "trt_v12/nvrtc64_120_0.dll" \
  --include "trt_v12/nvinfer_builder_resource_ptx_10.dll" \
  --include "trt_v12/nvinfer_builder_resource_sm80_10.dll" \
  --local-dir ./dist/lib
```

For reproducible builds, pin a commit revision with `--revision <sha>` instead of
`main`.

## License & redistribution

This repository bundles components under **different licenses**:

- **ONNX Runtime** (`onnxruntime*.dll`) — MIT License, © Microsoft.
- **CUDA runtime** (`cudart`, `cublas`, `cublasLt`, `cufft`, `curand`, `cusparse`,
  `nvrtc`) — © NVIDIA Corporation, redistributed under the
  [NVIDIA CUDA Toolkit EULA](https://docs.nvidia.com/cuda/eula/index.html).
- **cuDNN** (`cudnn*.dll`, both v8 and v9) — © NVIDIA Corporation, redistributed
  under the [NVIDIA cuDNN Software License Agreement](https://docs.nvidia.com/deeplearning/cudnn/sla/index.html).
- **TensorRT** (`nvinfer*.dll`, `nvonnxparser*.dll`, and the
  `nvinfer_builder_resource_*` builder resources) — © NVIDIA Corporation,
  redistributed under the
  [NVIDIA TensorRT Software License Agreement](https://docs.nvidia.com/deeplearning/tensorrt/sla/index.html).

The NVIDIA libraries are redistributed **unmodified** as runtime dependencies, as
permitted by the above agreements. NVIDIA, CUDA, cuDNN, and TensorRT are trademarks
of NVIDIA Corporation. This repository is not affiliated with or endorsed by NVIDIA.
By using these files you agree to the respective NVIDIA license terms.