> For the complete documentation index, see [llms.txt](https://nx.docs.scailable.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://nx.docs.scailable.net/ai-manager-v6.1.4/ai-accelerators-support/nvidia-support.md).

# NVIDIA Support

Supported NVIDIA GPU and Jetson hardware, the drivers and CUDA toolkit required, and how to enable and tune the NVIDIA runtime.

| AI Accelerator | Support Level | CPU Architecture | Operating System       | API/driver version              |
| -------------- | ------------- | ---------------- | ---------------------- | ------------------------------- |
| NVIDIA dGPU    | Full support  | x86\_64          | Ubuntu 20+ and Windows | CUDA 11, CUDA 12, CUDA 13       |
| NVIDIA dGPU    | Full support  | aarch64          | Ubuntu 24.04           | CUDA 13                         |
| NVIDIA Jetson  | Full support  | aarch64          | Ubuntu 20+             | JetPack 5, JetPack 6, JetPack 7 |

AI models inference is available on a wide-range of NVIDIA GPUs whether it is consumer-grade like GeForce RTX 3060, data center-grade like A100 and DGX Spark, or embedded devices (Jetson platform).

The NVIDIA runtime runs your models with ONNX Runtime and its CUDA execution provider. The AI Manager downloads the runtime for you when you select it, and the AI Manager Cloud converts the models, so you only prepare the machine: install the NVIDIA driver and the CUDA toolkit, then select the runtime.

{% hint style="warning" %}
The CUDA toolkit must match the machine: the AI Manager downloads the runtime build for the CUDA major version it finds (11, 12 or 13). CUDA 13 builds need Ubuntu 22.04 or newer.
{% endhint %}

## Quick Start

1. Check that your GPU is supported: [Hardware Requirements](#hardware-requirements).
2. Install an NVIDIA driver and a CUDA toolkit that are compatible with each other: [Software Requirements](#software-requirements).
3. Follow the steps for your platform: [x86\_64 Ubuntu](#x86_64-ubuntu), [x86\_64 Windows](#x86_64-windows), [aarch64 Server](#aarch64-server) or [NVIDIA Jetson](#nvidia-jetson).
4. Restart the Mediaserver, then [select the NVIDIA runtime](#select-the-nvidia-runtime): the AI Manager downloads it.
5. Optional: [configure the runtime](#configure-the-runtime).

## Hardware Requirements

An NVIDIA GPU with [compute capability](https://developer.nvidia.com/cuda-gpus) 5.2 or newer for CUDA 11 and 12, or 7.5 or newer for CUDA 13.

The shipped runtime contains GPU kernels only for these architectures, so older GPUs (Kepler, and Maxwell with compute capability 5.0 or 5.1) are not supported. The AI Manager checks the pairing of GPU and toolkit using the compute capability of the GPU:

| GPU generation                         | Compute capability | CUDA toolkit             |
| -------------------------------------- | ------------------ | ------------------------ |
| Maxwell (5.2 and newer), Pascal, Volta | 5.2 - 7.2          | 11 or 12                 |
| Turing, Ampere, Ada, Hopper            | 7.5 - 9.0          | 11, 12 or 13             |
| Blackwell                              | 10.0 - 12.1        | 12 (12.8 or newer) or 13 |

{% hint style="warning" %}
The AI Manager also lists the NVIDIA runtime for Kepler (3.5 - 3.7) and Maxwell 5.0 - 5.1 GPUs, because its check only looks at the toolkit support window. Inference then fails on these GPUs: do not use them.
{% endhint %}

Find the compute capability of your GPU with:

```bash
nvidia-smi --query-gpu=compute_cap --format=csv,noheader
```

| Case                                                          | Details                                                                                                                                                                                                                                                                                                                                                                                                  |
| ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| CUDA 13 runtime, x86\_64                                      | No fallback for other architectures: it contains kernels for compute capability 7.5, 8.0, 8.6, 8.7, 8.9, 9.0, 10.0, 10.3, 11.0 and 12.0 only                                                                                                                                                                                                                                                             |
| Several GPUs                                                  | The runtime always uses CUDA device 0, and the compute capability check looks at the first GPU in the `nvidia-smi` list (PCI bus order). CUDA orders the devices by speed by default, so on a machine with different GPUs these can be two different GPUs. Start the Mediaserver with the `CUDA_DEVICE_ORDER=PCI_BUS_ID` environment variable to make both the same one (not tested with the AI Manager) |
| GPU memory                                                    | It depends on the model. The runtime grows its CUDA memory pool on demand; cap it with `gpu_mem_limit` (see [Configure the Runtime](#configure-the-runtime))                                                                                                                                                                                                                                             |
| Jetson                                                        | JetPack 5 provides CUDA 11, JetPack 6 CUDA 12 and JetPack 7 CUDA 13, together with cuDNN. The GPU compute capability is not checked. The Jetson runtime contains kernels for compute capability 6.2, 7.2 and 8.7 (CUDA 11 and 12), and 8.7, 11.0 and 12.0 (CUDA 13)                                                                                                                                      |
| aarch64 servers (DGX Spark and other Grace Blackwell systems) | Only Blackwell server GPUs with compute capability 10.0, 12.0 or 12.1                                                                                                                                                                                                                                                                                                                                    |

## Software Requirements

**Install GPU drivers and CUDA toolkit&#x20;*****versions*****&#x20;that are compatible with each other.**

| Requirement      | Details                                                                                                                                                                                                                                                                                       |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| NVIDIA driver    | Its `nvidia-smi` CUDA version (top right corner of the output) must be at least the version of the installed toolkit: the AI Manager compares both at major.minor level. See the minimum driver versions below                                                                                |
| CUDA toolkit     | Version 11, 12 or 13, not newer than what the driver supports (the top right corner of the `nvidia-smi` output shows the maximum). Check the [CUDA toolkit release notes](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#id6) for the driver that goes with each toolkit. |
| cuDNN            | Bundled with the runtime. On Jetson the runtime uses the cuDNN of JetPack.                                                                                                                                                                                                                    |
| Operating system | Ubuntu 20+ for CUDA 11 and 12, Ubuntu 22+ for CUDA 13, or Windows 10 and 11. Debian 11, 12 and 13 count as Ubuntu 20.04, 22.04 and 24.04. aarch64 servers need Ubuntu 24.04.                                                                                                                  |

NVIDIA's Linux minimum drivers per CUDA major version, see [NVIDIA's compatibility table](https://docs.nvidia.com/deploy/cuda-compatibility/):

| CUDA major version | Minimum Linux driver |
| ------------------ | -------------------- |
| 11                 | 450.80               |
| 12                 | 525.60               |
| 13                 | 580                  |

They are not always enough: a 525.60 driver reports CUDA 12.0, so a CUDA 12.4 toolkit is flagged as too new. The numbers are for Linux; for Windows see the same table.

<details>

<summary>How the AI Manager decides that the NVIDIA runtime can be offered</summary>

In order (Linux; on Jetson see the notes below):

1. It finds an NVIDIA display device.
2. `nvidia-smi` runs and reports the driver's maximum CUDA version.
3. It finds the CUDA toolkit in `/usr/local/cuda/version.json`.
4. The toolkit is not newer than the driver supports.
5. The GPU's compute capability is supported by the toolkit (table above).

* **Windows:** the order differs. After the display device and `nvidia-smi`, the AI Manager reads `CUDA_PATH`, which must also be part of `PATH`, and takes the CUDA version from the folder name (`...\CUDA\v13.0`). Only then does it compare the driver's CUDA version and the compute capability. A `CUDA_PATH` folder that does not start with `v11`, `v12` or `v13` (for example a renamed folder) makes the runtime disappear without any message.
* **Jetson:** the machine is detected through JetPack, and `nvidia-smi` does not have to work. If it does, the driver comparison is made too.

</details>

If a step fails, the runtime is not listed and the AI Manager panel shows what is missing, see [Troubleshooting](#troubleshooting).

## Install the Drivers and the CUDA Toolkit

Follow the section of your platform.

### x86\_64 Ubuntu

1. Install the GPU drivers, then reboot the machine:

   ```bash
   sudo ubuntu-drivers autoinstall
   ```
2. Go to the [CUDA Toolkit archive](https://developer.nvidia.com/cuda-toolkit-archive) and install the CUDA version compatible with your installed GPU drivers.\
   (To find the recommended CUDA toolkit, run `nvidia-smi` in a terminal window. The version appears in the top right corner of the output.)
3. Check that the toolkit is where the AI Manager looks for it:

   ```bash
   cat /usr/local/cuda/version.json
   ```

   If the file is missing, `/usr/local/cuda` does not point to the toolkit you installed. Point it there, for example `sudo ln -s /usr/local/cuda-13.0 /usr/local/cuda`.
4. Install the OpenMP library the runtime needs (it is missing on minimal installations):

   ```bash
   sudo apt install libgomp1
   ```
5. Restart the Mediaserver, then [select the runtime](#select-the-nvidia-runtime).

### x86\_64 Windows

1. Go to the [NVIDIA driver download page](https://www.nvidia.com/en-us/drivers/), and select your GPU model and OS. Then, download the driver installer, and run it.
2. Go to the [CUDA Toolkit archive](https://developer.nvidia.com/cuda-toolkit-archive) and choose the CUDA version compatible with your installed GPU drivers.\
   (To find the recommended CUDA toolkit, run `nvidia-smi` on PowerShell. The version appears in the top right corner of the output.)\
   After a successful installation, the CUDA toolkit should be available at: `C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\`
3. Check that the `CUDA_PATH` system environment variable points to the toolkit folder (for example `...\CUDA\v13.0`) and that this folder is part of `PATH`. The AI Manager reads the CUDA version from the `CUDA_PATH` folder name, so keep the folder name the installer gave it (`v11.x`, `v12.x` or `v13.x`): with another name the runtime is not offered, with no message. The CUDA installer sets both variables.
4. Restart the Mediaserver service, then [select the runtime](#select-the-nvidia-runtime).

### aarch64 Server

For NVIDIA DGX Spark and other Grace Blackwell systems:

1. Use Ubuntu 24.04.
2. Install the NVIDIA driver so that `nvidia-smi` works and reports a compute capability of 10.0, 12.0 or 12.1.
3. Install CUDA toolkit 13.1 or newer and check `/usr/local/cuda/version.json` as for x86\_64 Ubuntu.
4. Restart the Mediaserver, then [select the runtime](#select-the-nvidia-runtime).

### NVIDIA Jetson

1. Install JetPack 5, 6 or 7 (the Jetson is detected through its `nvidia-l4t-core` package). It provides the driver, CUDA, cuDNN and TensorRT.
2. Check that `/usr/local/cuda/version.json` exists, as for x86\_64 Ubuntu.
3. On recent JetPack installations, make sure the `<server-user>` user is in the `render` group, see [Add the Server User to the render Group](#add-the-server-user-to-the-render-group-jetson).
4. Restart the Mediaserver, then [select the runtime](#select-the-nvidia-runtime).

## Select the NVIDIA Runtime

After installing the drivers and CUDA toolkit and restarting the Mediaserver, the NVIDIA runtime appears in the plugin's runtime selection list. Open any camera's settings, go to the **Integrations** tab, click **AI Manager**, and confirm that the NVIDIA runtime is listed. Select it: the AI Manager downloads the runtime package and starts using it.

<figure><img src="https://2982163321-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FKGfC0TFSmuMDjbpLErO3%2Fuploads%2Fgit-blob-9a300178c7460cac956e390f52b793980b4d183b%2Fclient-ai-manager-runtime-install-tooltip.png?alt=media" alt="AI Manager panel with Generic CPU and NVIDIA runtime buttons, and a tooltip on the NVIDIA button reading Install this acceleration library on your server"><figcaption><p>The NVIDIA runtime appears in the list once drivers and CUDA are installed and the server has been restarted</p></figcaption></figure>

Once the NVIDIA runtime has been selected, it is hidden from the list until the Mediaserver is restarted: to reselect it, or to change `runtime_args.json`, restart the Mediaserver first.

## Convert a Model

Use the models from the AI Manager Cloud as usual: the default ONNX conversion runs on the NVIDIA runtime, no separate conversion is needed. The first frames after a start are slower while CUDA and cuDNN warm up, then the speed settles.

## Configure the Runtime

By default, the runtime uses the GPU with sensible settings and needs no configuration. To change them, add a `runtime_args.json` file to the inference engine folder.

{% tabs %}
{% tab title="Linux" %}

```
<server-install-dir>/mediaserver/var/nx_ai_manager/inference_engine/runtime_args.json
```

{% endtab %}

{% tab title="Windows" %}

```
C:\Windows\System32\config\systemprofile\AppData\Local\<company-name>\<server-app-name>\nx_ai_manager\inference_engine\runtime_args.json
```

{% endtab %}
{% endtabs %}

Create the file if it doesn't exist. **Every value must be a JSON string**, even numbers; entries that are not strings are skipped, and keys the runtime does not know are ignored with a warning in the runtime log. For example:

```json
{
  "perf_mode": "eco",
  "gpu_mem_limit": "2147483648"
}
```

| Key                | Values (default in bold)                                                          | Meaning                                                                                                                                                               |
| ------------------ | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `perf_mode`        | `power`, `eco`, **unset**                                                         | Picks defaults from the hardware. `power`: as many threads as CPU cores, no GPU memory cap. `eco`: half the cores and half the GPU memory. The keys below override it |
| `num_threads`      | `1` - `512`, **`4`**                                                              | CPU threads ONNX Runtime uses inside an operator                                                                                                                      |
| `inter_op_threads` | `0` - `512`, **`0`** (ONNX Runtime default)                                       | CPU threads ONNX Runtime uses to run operators in parallel                                                                                                            |
| `gpu_mem_limit`    | bytes, **unlimited**                                                              | Upper limit of the GPU memory the runtime may allocate                                                                                                                |
| `log_level`        | `0` trace, `1` debug, **`2`** info, `3` warning, `4` error, `5` critical, `6` off | Verbosity of the runtime log. Use `1` while troubleshooting                                                                                                           |

* **Not configurable:** the GPU (always device 0), the numeric precision and the graph optimizations.
* **Another GPU than the first:** start the Mediaserver with the `CUDA_VISIBLE_DEVICES` environment variable set (for example `1`). This has not been tested with the AI Manager. Note that the compute capability check always reads the first GPU of `nvidia-smi`, whatever you choose here.

{% hint style="warning" %}
On Linux, reselecting a runtime in the AI Manager plugin, or clearing its cache, deletes `runtime_args.json`. Select the NVIDIA runtime first, then create the file, and only then restart the Mediaserver. A file written before the runtime was selected is removed again.
{% endhint %}

After making the changes, restart the Mediaserver, see [Restarting the Server](https://nx.docs.scailable.net/ai-manager-v6.1.4/support-and-troubleshooting/troubleshooting/controlling-the-server-and-the-plugin.md#restarting-the-server).

## TensorRT Runtime (Advanced)

A second NVIDIA runtime based on TensorRT is available for the best inference speed. It is off by default; enable it with the [`enableNvidiaTRTIntegration`](https://nx.docs.scailable.net/ai-manager-v6.1.4/ai-manager-plugin/advanced-configuration/ini-file-contents.md) option of the plugin. It then appears in the AI Manager panel as a separate **NVIDIA TensorRT** button.

<details>

<summary>TensorRT runtime requirements and limits</summary>

It also needs:

| Requirement        | Details                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| CUDA and OS        | CUDA 12 or 13 (not CUDA 11), on Ubuntu 22.04 for x86\_64 or Ubuntu 24.04 for aarch64 servers. It is not available on Windows                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Jetson             | JetPack 6 (CUDA 12) only. No TensorRT runtime is published for the CUDA 13 of JetPack 7                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Package            | The `libnvinfer-bin` package installed (`sudo apt install libnvinfer-bin`): its major version selects the TensorRT 10 or 11 runtime                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Compute capability | A working `nvidia-smi --query-gpu=compute_cap --format=csv,noheader`: the AI Manager reads the GPU compute capability with it, and without a value the TensorRT runtime is not offered. On a Jetson `nvidia-smi` can be limited or absent, in which case this runtime is not available                                                                                                                                                                                                                                                                   |
| Model              | A model built as a TensorRT engine for your GPU. An engine only runs on the GPU architecture, CPU platform and TensorRT version it was built for. The runtime only accepts models of the type `application/x-tensorrt; arch=<cpu architecture>; sm=<compute capability without the dot>; trt=<TensorRT major version>`. It is not confirmed that the AI Manager Cloud produces such models, so ask the [support team](https://nx.docs.scailable.net/ai-manager-v6.1.4/support-and-troubleshooting/how-to-get-support.md) before you rely on this runtime |

Models whose output size depends on the data, typically a `NonMaxSuppression` operator inside the model, cannot be loaded by TensorRT: use the default NVIDIA runtime for them. The TensorRT runtime also reads `perf_mode` and `max_concurrent` (`1` - `32`, default `1`: parallel inference slots per model, using more GPU memory) from `runtime_args.json`.

</details>

## Monitor

| Hardware                | Command           | Notes                                                                |
| ----------------------- | ----------------- | -------------------------------------------------------------------- |
| GPU on Ubuntu / Windows | `nvidia-smi`      | Shows GPU load and memory. `nvidia-smi -l 1` refreshes every second. |
| Jetson                  | `sudo tegrastats` | Comes with JetPack.                                                  |

## Troubleshooting

Messages about the NVIDIA setup appear in the AI Manager panel. For the details, read the plugin log and the runtime log (see [Check the Plugin Logs](https://nx.docs.scailable.net/ai-manager-v6.1.4/support-and-troubleshooting/troubleshooting/plugin-checks.md)).

### The Runtime Is Not Offered or the Panel Shows a Message

| Message or symptom                                                                      | Cause and fix                                                                                                                                                                                                                                                                                              |
| --------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The NVIDIA runtime is not listed, with no message                                       | The AI Manager found no NVIDIA display device, or the machine is neither x86\_64 nor aarch64. On a Jetson, JetPack is not installed (`dpkg -l nvidia-l4t-core` must list it) or `/usr/local/cuda/version.json` is missing. On Windows, the `CUDA_PATH` folder is not named `v11...`, `v12...` or `v13...`. |
| "AVX2 is not supported on this machine. As a result, no runtime is compatible..."       | x86\_64 only: the CPU has no AVX2, so no AI runtime, NVIDIA included, can be offered. Use a CPU with AVX2.                                                                                                                                                                                                 |
| "libgomp is not installed on this machine. Please install it and restart the server..." | Linux only: install the OpenMP library with `sudo apt install libgomp1` and restart the Mediaserver. No runtime, NVIDIA included, is offered without it. The plugin log shows `Cannot load libgomp.so.1: ...`.                                                                                             |
| "NVIDIA GPU acceleration is unavailable on this machine"                                | The driver is missing or `nvidia-smi` fails, the CUDA toolkit was not found (Linux: `/usr/local/cuda/version.json`; Windows: the `CUDA_PATH` variable), or the GPU count could not be read. Follow the installation steps above, then restart the Mediaserver.                                             |
| "Your installed CUDA Toolkit ... is newer than what your NVIDIA driver supports"        | Update the NVIDIA driver, or install a toolkit version the driver supports.                                                                                                                                                                                                                                |
| "Your GPU's compute capability is not compatible with the installed CUDA Toolkit"       | Install a toolkit version that supports your GPU, see the table under [Hardware Requirements](#hardware-requirements). If no toolkit does (GPU older than compute capability 5.2), the GPU cannot be used.                                                                                                 |
| "The CUDA Toolkit path is not in the PATH environment variable" (Windows)               | Add the `bin` folder of the toolkit to `PATH`, then restart the Mediaserver.                                                                                                                                                                                                                               |
| "NVIDIA GPU acceleration on aarch64 servers requires Ubuntu 24.04"                      | Upgrade to Ubuntu 24.04.                                                                                                                                                                                                                                                                                   |
| "Your NVIDIA GPU is not supported for aarch64 server acceleration"                      | Only Blackwell server GPUs (compute capability 10.0, 12.0, 12.1) are supported there.                                                                                                                                                                                                                      |
| "CUDA 13.x is required for NVIDIA aarch64 server acceleration"                          | Install CUDA 13.1 or newer and restart the Mediaserver.                                                                                                                                                                                                                                                    |
| "The NVIDIA runtime can't be selected again until the mediaserver is restarted"         | Restart the Mediaserver.                                                                                                                                                                                                                                                                                   |

### The Runtime Fails to Start or to Run

| Message or symptom                                                                                                                                                                  | Cause and fix                                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `nvidia-smi` prints `Driver/library version mismatch`                                                                                                                               | The driver was updated but the old one is still loaded. Reboot the machine.                                                                                                                                                                                                                                                                                               |
| The runtime is offered but inference fails on an older GPU (Kepler, or Maxwell 5.0 and 5.1), typically with `no kernel image is available for execution on the device`              | The shipped runtime has no kernels for this GPU, see [Hardware Requirements](#hardware-requirements). Use a GPU with compute capability 5.2 or newer (7.5 or newer for CUDA 13).                                                                                                                                                                                          |
| "Failed to initialize the AI runtime" with `lib<name>.so.<N>: cannot open shared object file` in the message or runtime log (`libcudart`, `libcublas`, `libcublasLt` or `libcufft`) | The CUDA libraries of the toolkit version in use are not found by the system. The first library named depends on the CUDA version (for example `libcublasLt.so.12` on CUDA 12, `libcublas.so.13` on CUDA 13). Check it with `ldconfig -p \| grep <name>` and make the toolkit's `lib64` folder known to the linker. For `libcudnn`, see the row below.                    |
| `libgomp.so.1: cannot open shared object file` in the logs                                                                                                                          | Install the OpenMP library: `sudo apt install libgomp1`, then restart the Mediaserver.                                                                                                                                                                                                                                                                                    |
| `CUDA driver version is insufficient for CUDA runtime version`                                                                                                                      | The driver is older than the toolkit's CUDA version needs, see the driver versions under [Software Requirements](#software-requirements).                                                                                                                                                                                                                                 |
| `no CUDA-capable device is detected` or `No CUDA driver or GPU detected`                                                                                                            | The Mediaserver cannot see the GPU: the driver is not loaded, `CUDA_VISIBLE_DEVICES` is empty, or the Mediaserver runs in a container started without GPU access. Check `nvidia-smi` in the same environment.                                                                                                                                                             |
| Another `libcudnn... cannot open shared object file`                                                                                                                                | A cuDNN file is missing or damaged. On Jetson, check that JetPack provides cuDNN. Otherwise reselect the runtime (restart the Mediaserver first) to download it again, which only helps for a corrupted download; if it persists, send the logs to the [support team](https://nx.docs.scailable.net/ai-manager-v6.1.4/support-and-troubleshooting/how-to-get-support.md). |
| The model produces no detections and the runtime log shows `Inference error`                                                                                                        | The runtime rejected a request, for example for a wrong input type or size. Set `log_level` to `1` and send the log to the [support team](https://nx.docs.scailable.net/ai-manager-v6.1.4/support-and-troubleshooting/how-to-get-support.md).                                                                                                                             |

### Add the Server User to the render Group (Jetson)

On systems using NVIDIA's JetPack SDK, especially recent installations, the `<server-user>` user might not be automatically added to the `render` group, which is a known requirement for the AI Manager plugin to use NVIDIA GPU acceleration on these systems. Add the user manually with the following steps:

1. Verify whether the `render` group exists:

   ```bash
   getent group render
   ```

   If it prints a line like `render:x:104:username`, the group exists and lists its users. If there's **no output**, the group does not exist on your system and there is nothing more to do.
2. Add `<server-user>` to the `render` group:

   ```bash
   sudo usermod -aG render <server-user>
   ```
3. Confirm the membership. The output must list `render`:

   ```bash
   groups <server-user>
   ```
4. Restart the Mediaserver service so that it picks up the new group:

   ```bash
   sudo systemctl restart <service-name>.service
   ```

If the AI Manager does not work even when the conditions above are met, see the [general troubleshooting section](https://nx.docs.scailable.net/ai-manager-v6.1.4/support-and-troubleshooting/how-to-get-support.md).
