Installation guide

A working DENKflow installation has two layers:

1. The vendor runtime stack on the machine, such as CUDA, TensorRT, or OpenVINO.
2. The DENKflow package on top of that stack.

If an execution provider is missing at runtime, the cause is usually in the first layer.

Supported languages

• Python: wheel installable via pip (Python 3.10, 3.11, 3.12, 3.13).
• C/C++: shared library plus the denkflow.h header.

Choose your runtime

Decide which execution provider you will install before installing the package, and pick by your hardware:

• CPU: Works on all platforms. Easiest path for first bring-up and debugging.
• CUDA: NVIDIA GPU only (Linux x86_64, Windows x86_64, Jetson). Requires a driver new enough for the CUDA major version you install, then the CUDA toolkit and cuDNN that match your ONNX Runtime build.
• TensorRT: NVIDIA GPU only; requires a working CUDA setup first, and TensorRT must match that CUDA stack. On Jetson, stay on JetPack (do not layer desktop CUDA/TensorRT packages on top). First run can be slow while an optimized build is prepared and cached.
• OpenVINO: Linux and Windows x86_64 only. Intel CPU is the most straightforward path; Intel GPU/NPU also need the correct Intel drivers/runtime on the host.
• DirectML: Windows x86_64 only; for GPU inference when you are not using the NVIDIA CUDA stack.

Compatibility matrix

OS / Architecture	CPU	CUDA	TensorRT	DirectML	OpenVINO
Linux x86_64	yes	yes	yes	no	yes
Windows x86_64	yes	yes	advanced setup	yes	yes
Linux ARM64 / Jetson	yes	yes	Orin class devices	no	no

Vendor download pages

• NVIDIA CUDA Toolkit: developer.nvidia.com/cuda-downloads
• NVIDIA cuDNN: developer.nvidia.com/cudnn-downloads
• NVIDIA TensorRT: developer.nvidia.com/tensorrt/download
• Intel OpenVINO: docs.openvino.ai
• NVIDIA JetPack / SDK Manager: developer.nvidia.com/embedded/jetpack

Private package registry

All Python install commands below use the DENKweit private package registry as the index URL:

--extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple

The token in this URL is a public read-only token for the DENKweit GitLab package registry.

Python package variants

Target environment	Recommended package install
CPU only (x86-64)	pip install denkflow
CPU only (ARM64)	pip install denkflow[cpu]
NVIDIA CUDA	pip install denkflow[gpu]
NVIDIA TensorRT	pip install denkflow[gpu] plus system TensorRT
Windows DirectML	pip install denkflow[directml]
Intel OpenVINO	pip install denkflow[openvino]

C/C++ release packages

The C-API is delivered as a shared library plus the denkflow.h header. Download the platform package from:

DENKflow-C-API Releases

A release contains:

• denkflow.h
• Linux: libdenkflow.so
• Windows: libdenkflow.dll and libdenkflow.dll.lib
• additional runtime dependencies required for the selected accelerator path

The platform prerequisites in Choose your runtime still apply for native deployments.

Linux x86_64

Python

Use a clean virtual environment for every runtime variant:

python -m venv .venv
source .venv/bin/activate
pip install --upgrade pip

CPU only

pip install denkflow --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple

OpenVINO

What to install on the machine:

1. Ensure Python and venv support are installed.
2. For Intel GPU or NPU execution, install the current Intel graphics or NPU driver for the host OS first.
3. For Intel GPU: install the OpenCL ICD loader and the Intel compute-runtime so OpenVINO can access the GPU.
4. Install the Python environment and DENKflow.
5. Optionally install Intel's openvino Python package if you want to inspect devices with openvino.Core() directly.

Intel GPU system dependencies (Ubuntu / Debian):

sudo apt install ocl-icd-libopencl1 intel-opencl-icd

Intel GPU system dependencies (Fedora / RHEL):

sudo dnf install ocl-icd intel-opencl

Verify GPU visibility (optional):

sudo apt install clinfo   # or dnf install clinfo
clinfo -l
# Should list an Intel GPU device

Install DENKflow:

pip install denkflow[openvino] --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple
python -c "import onnxruntime as ort; print(ort.get_available_providers())"

Expected provider list should contain OpenVINOExecutionProvider.

Optional device inspection:

python -m pip install openvino
python - <<'PY'
import openvino as ov
core = ov.Core()
print(core.available_devices)
PY

If GPU does not appear in the device list but you have an Intel integrated or discrete GPU, the OpenCL ICD loader or Intel compute-runtime is missing. See Troubleshooting > OpenVINO Fails With "Failed to load shared library".

CUDA

What to install on the machine:

1. Install the NVIDIA GPU driver and reboot if required.
2. Verify the driver with nvidia-smi.
3. Install CUDA 12.x from the NVIDIA repository or runfile that matches your distribution.
4. Install cuDNN 9.x that matches the CUDA major version you selected.
5. Open a new shell and verify both the driver and toolkit before installing DENKflow.

Suggested verification before pip install:

nvidia-smi
nvcc --version
python - <<'PY'
import os
print("CUDA_PATH =", os.environ.get("CUDA_PATH"))
PY

If nvcc is not on PATH, the toolkit is either not installed or the shell environment was not refreshed after installation.

pip install denkflow[gpu] --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple
python -c "import onnxruntime as ort; print(ort.get_available_providers())"

Expected provider list should contain CUDAExecutionProvider.

TensorRT

Install TensorRT only after plain CUDA works.

What to install on the machine:

1. Complete the full CUDA setup first.
2. Download TensorRT 10.x that explicitly matches your CUDA stack.
3. Install it from the NVIDIA repository, local package, or tar archive for your Linux distribution.
4. Ensure the directory containing libnvinfer.so and related TensorRT libraries is visible to the dynamic loader.
5. Verify the library discovery before starting Python.

Suggested verification before pip install:

ldconfig -p | grep nvinfer

If the TensorRT libraries live in a custom directory, export LD_LIBRARY_PATH before starting the shell or application:

export LD_LIBRARY_PATH=/path/to/tensorrt/lib:$LD_LIBRARY_PATH

Persist DENKFLOW_DATA_DIRECTORY so engine caches survive restarts:

export DENKFLOW_DATA_DIRECTORY=$HOME/.config/denkflow
mkdir -p "$DENKFLOW_DATA_DIRECTORY"
pip install denkflow[gpu] --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple
python -c "import onnxruntime as ort; print(ort.get_available_providers())"

After installation, the provider list should contain TensorrtExecutionProvider. The first real inference is expected to be slower because TensorRT builds an optimized engine.

C / C++

1. Download the Linux C-API package from DENKflow-C-API Releases.
2. Place denkflow.h in your include path.
3. Place libdenkflow.so and any dependent shared libraries in your runtime library path.
4. Link against libdenkflow.so.

Example compile command:

g++ main.cpp -I./include -L./lib -ldenkflow -Wl,-rpath,'$ORIGIN/lib' -o app

Example runtime setup:

export LD_LIBRARY_PATH=$PWD/lib:$LD_LIBRARY_PATH
export DENKFLOW_DATA_DIRECTORY=$HOME/.config/denkflow
./app

Accelerator notes:

• CUDA / TensorRT: install the matching NVIDIA runtime libraries on the target host (driver + CUDA + cuDNN, plus TensorRT for the TensorRT path). The Python prerequisites in the Python tab apply identically.
• OpenVINO: install the matching Intel runtime stack and any required Intel device drivers. For Intel GPU execution on Linux, the OpenCL ICD loader (libOpenCL.so.1) and the Intel compute-runtime (intel-opencl-icd) must be installed.
• ONNX Runtime provider libraries: libonnxruntime_providers_shared.so and libonnxruntime_providers_openvino.so are loaded via dlopen at runtime. Ensure the directory containing them is on LD_LIBRARY_PATH or place them next to the application binary.

Windows x86_64

Python

Use a clean virtual environment for every runtime variant:

py -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install --upgrade pip

CPU only

pip install denkflow --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple

NVIDIA GPU stack: CUDA, cuDNN, and TensorRT (Windows)

denkflow[gpu] pulls onnxruntime-gpu 1.22.x, which is built for CUDA 12.x and cuDNN 9.x. Your driver must be new enough for the CUDA toolkit you install (check the driver’s “CUDA Version” line in nvidia-smi against NVIDIA CUDA compatibility).

Install in order: driver → CUDA Toolkit → cuDNN → (optional) TensorRT → new terminal → pip install denkflow[gpu].

1) NVIDIA graphics driver (host)

1. Open NVIDIA Driver Downloads.

2. Select product type (e.g. GeForce / RTX / Quadro), product series, product, Operating System: Windows 10 / Windows 11, and Download Type: Standard (or DCH if that is what your OEM uses).

3. Download the installer and run it.

4. Prefer Express installation unless IT requires Custom (e.g. to skip GeForce Experience). Accept the license and complete the wizard.

5. Reboot if the installer requests it.

6. Open PowerShell and run:

   nvidia-smi

   Confirm your GPU is listed and note the CUDA Version reported there (this is the maximum CUDA toolkit generation your driver supports).

2) CUDA Toolkit 12.x

1. Open CUDA Toolkit downloads.

2. Set Operating System → Windows, Architecture → x86_64, Version → your Windows release, Installer Type:

   • exe (network) — smaller download, pulls packages during install; needs internet.
   • exe (local) — full offline installer; larger download.

3. Download and Run as administrator (right‑click the installer → Run as administrator).

4. When the installer starts:

   • If you see a choice between Express and Custom, choose Express for the least friction (full toolkit, samples, and integration). This is the usual choice for DenkFlow unless you need a minimal footprint.
   • If you choose Custom, expand CUDA and ensure at least:
     • CUDA Runtime / runtime libraries
     • Development components so nvcc is installed (useful for troubleshooting)
   • CUDA Visual Studio Integration is only needed if you compile CUDA C++ in Visual Studio; DenkFlow Python users can clear it under Custom to save space.

5. Complete the wizard. Allow the installer to set environment variables (CUDA_PATH, PATH) when offered.

6. Close all PowerShell windows and open a new one so PATH updates apply.

7. Verify:

   nvcc --version
   where.exe nvcc

   If nvcc is not found, open Settings → System → About → Advanced system settings → Environment Variables and check CUDA_PATH points to something like C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.x, and that ...\CUDA\v12.x\bin appears in Path for your user or system.

3) cuDNN 9.x (for CUDA 12.x)

cuDNN is distributed as a zip (not a single “Next, Next” MSI). You need a free NVIDIA Developer account.

1. Open cuDNN downloads and sign in.
2. Accept the license if prompted.
3. Pick a cuDNN for CUDA 12.x package whose major cuDNN line is 9.x (match the download matrix to CUDA 12).
4. Download the Windows archive (often named like cudnn-windows-x86_64-*_cuda12-archive.zip).
5. Extract the zip (e.g. with File Explorer). Inside you should see folders such as bin, include, and lib (sometimes under a versioned root folder — open until you see those three).
6. Merge those folders into your CUDA Toolkit tree (adjust v12.x to your installed version), overwriting when asked:
   • Copy everything under bin → C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.x\bin
   • Copy everything under include → C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.x\include
   • Copy everything under lib\x64 (or lib) → C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.x\lib\x64
7. Administrator privilege: if copy is denied, copy to a staging folder first, then copy/paste in Explorer with administrator confirmation, or run Explorer elevated once for this step.
8. Confirm cudnn64_9.dll (name may vary slightly by build) exists under CUDA\v12.x\bin.

Alternative (sometimes simpler): ONNX Runtime can load CUDA/cuDNN DLLs shipped as Python wheels (nvidia-cuda-*, nvidia-cudnn-*). That path is documented in the ONNX Runtime CUDA EP notes. DenkFlow still assumes a coherent CUDA 12.x + cuDNN 9.x layout on the machine; use one strategy (system CUDA + merged cuDNN, or NVIDIA pip metapackages) consistently so DLL versions are not mixed accidentally.

4) TensorRT 10.x (optional; for TensorrtExecutionProvider)

Do this only after CUDAExecutionProvider works. TensorRT must match your CUDA 12.x line.

1. Open TensorRT download and sign in.
2. Select TensorRT 10.x and a package explicitly built for CUDA 12.x / Windows x86_64 (the site shows a matrix — choose the row that matches CUDA 12, not CUDA 11).
3. Download the ZIP for Windows (not Linux .tar).
4. Extract to a fixed path, e.g. C:\TensorRT (you might get C:\TensorRT\TensorRT-10.x.x.x — note the inner folder that contains bin, lib, include).
5. Add TensorRT’s DLL directory to your user or system Path:
   • Typical layout: ...\lib contains nvinfer.dll, nvinfer_plugin.dll, nvonnxparser.dll, etc.
   • Settings → Environment Variables → Path → New → add that lib folder (not individual DLLs).
6. TensorRT depends on CUDA libraries already on PATH from step 2; if you see load errors, verify CUDA’s bin is still on PATH.
7. Open a new PowerShell window after editing Path.

Quick DLL check (optional — adjust the base path if you extracted elsewhere):

dir "C:\TensorRT\*\lib\nvinfer.dll" -Recurse -ErrorAction SilentlyContinue

5) Install DenkFlow and verify providers

Use a new shell after CUDA/cuDNN/TensorRT and Path changes.

Optionally set a persistent SDK data directory first (recommended when using TensorRT so engine caches survive restarts):

$env:DENKFLOW_DATA_DIRECTORY = "$env:USERPROFILE\.denkflow"
New-Item -ItemType Directory -Force -Path $env:DENKFLOW_DATA_DIRECTORY | Out-Null

Install and check ONNX Runtime providers:

pip install denkflow[gpu] --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple
python -c "import onnxruntime as ort; print(ort.get_available_providers())"

• You should see CUDAExecutionProvider after CUDA + cuDNN are correctly visible.
• If you completed the TensorRT step, you should also see TensorrtExecutionProvider. If it is missing but CUDA works, TensorRT DLLs are usually not on PATH or the TensorRT build does not match CUDA 12.x.

DirectML

pip install denkflow[directml] --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple
python -c "import onnxruntime as ort; print(ort.get_available_providers())"

OpenVINO

What to install on the machine:

1. Install the latest Intel graphics driver or Intel NPU driver if you want acceleration beyond CPU. The Intel GPU driver on Windows includes OpenCL support, so no extra OpenCL packages are needed.
2. Create a clean Python environment.
3. Install denkflow[openvino].
4. Optionally install Intel's openvino package for device introspection and OpenVINO-specific tooling.

pip install denkflow[openvino] --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple
python -c "import onnxruntime as ort; print(ort.get_available_providers())"

Optional device inspection:

pip install openvino
python -c "import openvino as ov; print(ov.Core().available_devices)"

Expected provider list should contain OpenVINOExecutionProvider.

C / C++

1. Download the Windows C-API package from DENKflow-C-API Releases.
2. Add denkflow.h to your include directories.
3. Link against libdenkflow.dll.lib.
4. Ensure libdenkflow.dll and all required runtime DLLs are next to your executable or on PATH.

Accelerator notes:

• CUDA / TensorRT: install the matching NVIDIA runtime libraries on the target host. For TensorRT, the DLL directory (e.g. C:\TensorRT\10.x\lib) must be on PATH.
• DirectML: native C/C++ deployments should verify runtime packaging carefully; the Python wheel is the primarily exercised path.
• OpenVINO: the Intel GPU driver on Windows already provides OpenCL support, so no extra OpenCL packages are required.

Linux ARM64 / Jetson

Jetson setup is different from desktop Linux. Use JetPack as the source of truth for the system stack.

What to install on the machine:

1. Flash or provision the device with a JetPack release supported by your Jetson hardware.
2. Let JetPack install the NVIDIA driver, CUDA, cuDNN, and TensorRT as one aligned stack.
3. Do not replace JetPack packages with random desktop NVIDIA packages unless you are intentionally doing advanced recovery or custom image work.
4. Install Python build essentials such as python3-venv if your image does not already contain them.
5. Verify the JetPack stack before creating the DENKflow environment.

Suggested verification:

cat /etc/nv_tegra_release
dpkg -l | grep -E 'nvinfer|cudnn|cuda'
python3 - <<'PY'
import platform
print(platform.machine())
PY

Recommended runtime choices:

• Jetson Orin: preferred target for TensorRT exports.
• Jetson Xavier: use CPU or CUDA; TensorRT is not the recommended path for current exports.
• Keep DENKFLOW_DATA_DIRECTORY persistent so TensorRT engines do not rebuild every run.

Python

CPU fallback

python -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install denkflow[cpu] --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple

CUDA / TensorRT on Jetson

sudo apt update
sudo apt install -y python3-venv python3-pip
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install denkflow[gpu] --extra-index-url https://__token__:gldt-JCgXB7jPAo_b6JXAckFV@gitlab.com/api/v4/projects/69262737/packages/pypi/simple
python -c "import onnxruntime as ort; print(ort.get_available_providers())"

If CUDAExecutionProvider is available but TensorrtExecutionProvider is not, the JetPack image usually lacks the TensorRT user-space libraries that the process expects, or the library path is incomplete.

C / C++

1. Download the ARM64 C-API package from DENKflow-C-API Releases.
2. Put denkflow.h and libdenkflow.so in your project.
3. Ensure ONNX Runtime libraries are present.
4. If auto-discovery is not sufficient, set ORT_DYLIB_PATH to libonnxruntime.so.

export ORT_DYLIB_PATH=/path/to/libonnxruntime.so
export LD_LIBRARY_PATH=/path/to/libs:$LD_LIBRARY_PATH

Native deployments on Jetson should use the libraries that ship with JetPack rather than mixing in desktop NVIDIA packages.

Verify the installation

Python

python - <<'PY'
import onnxruntime as ort
print("available providers:", ort.get_available_providers())
PY

Common expected provider names:

• CPU: CPUExecutionProvider
• CUDA: CUDAExecutionProvider
• TensorRT: TensorrtExecutionProvider
• OpenVINO: OpenVINOExecutionProvider
• DirectML: DmlExecutionProvider

If the provider you expect is missing, return to the platform section above and re-check driver installation, library paths, and version matching.

C / C++

Build and run a minimal program that includes denkflow.h, creates a DenkflowHubLicenseSource, and loads a .denkflow file as shown in Quick Start. If the binary starts but fails to find shared libraries, fix your runtime DLL or SO search path first.