# Runtime Library Installation

This section explains how to install the Mobilint NPU **qb Runtime** which is required to run inference on Mobilint NPUs using precompiled or custom models.

```{attention}
- For ARIES devices, complete driver installation before proceeding. Please check ARIES manual {external+aries:doc}`driver installation <driver-installation>` documentation. REGULUS ships with the driver and runtime pre-installed.
- Check compatible driver and firmware versions in the ARIES {external+aries:doc}`compatibility guide <compatibility>`; for runtime–MXQ compatibility, see [Checking Compatibility](compatibility.md).
```

## Table of Contents

- Linux

    - [Option 1: Installing via APT on Debian-based OS](#option-1-installing-via-apt-on-linux-ubuntu)

    - [Option 2: Installing via DNF on RedHat-based OS](#option-2-installing-via-dnf-on-redhat-based-os)

    - [Option 3: Manual Installation from Download Center](#option-3-manual-installation-from-download-center)

        - [Option 3-1: System-Wide Installation](#option-3-1-system-wide-installation)

        - [Option 3-2: Use Without Installation](#option-3-2-use-without-installation)

    - [Option 4: Installing with pip](#option-4-installation-via-pip)

- Windows

    - [Installing on Windows](#installing-on-windows)

## Linux

(option-1-installing-via-apt-on-linux-ubuntu)=
### Option 1: Installing via APT on Debian-based OS

This method installs the runtime system-wide using Debian-based OS's package manager `apt`.

#### Installation Process

1. Add the Mobilint APT repository to your system before proceeding with the installation.

    ```{tip}
    If you’ve already added the Mobilint APT repository during driver installation, you can skip this step.
    ```

    ```bash
    # Add Mobilint's official GPG key:
    sudo apt update
    sudo apt install ca-certificates curl
    sudo install -m 0755 -d /etc/apt/keyrings
    sudo curl -fsSL https://dl.mobilint.com/apt/gpg.pub -o /etc/apt/keyrings/mblt.asc
    sudo chmod a+r /etc/apt/keyrings/mblt.asc

    # Add the repository to apt sources:
    printf "%s\n" \
        "deb [signed-by=/etc/apt/keyrings/mblt.asc] https://dl.mobilint.com/apt \
        stable multiverse" | \
        sudo tee /etc/apt/sources.list.d/mobilint.list > /dev/null

    # Update available packages
    sudo apt update
    ```

2. Install via apt package manager.

    ```bash
    sudo apt install mobilint-qb-runtime
    ```

3. Verify installation.

    ```bash
    dpkg -L mobilint-qb-runtime
    ```

#### Troubleshooting Anaconda Error

If you are using anaconda virtual environment, you can get error message like below.

```bash
../lib/libstdc++.so.6: version `GLIBCXX_3.4.32' not found
```

This issue is caused by the version confliction of libstdc++ bundled with Anaconda, and the appropriate solution may vary depending on the Anaconda version.
We recommend searching online for the most suitable fix.

Additionally, to prevent such conflicts, it is recommended to use Python’s built-in virtual environment (`venv`), which utilizes the system’s `libstdc++` library.

### Option 2: Installing via DNF on RedHat-based OS

This method installs the runtime system-wide using RedHat-based OS's package manager `dnf`. The packages are built against glibc 2.28 (EL8) and support RHEL, Rocky Linux on both x86_64 and aarch64 architectures.

```{note}
The Mobilint DNF repository currently provides the `mobilint-qb-runtime` and `mobilint-cli` packages only. To install the NPU driver on RedHat-based OS, refer to {external+aries:doc}`Manual Download <driver-installation>`.
```

#### Installation Process

1. Add the Mobilint DNF repository to your system before proceeding with the installation.

    ```bash
    # Register the repository
    sudo curl -fsSL https://dl.mobilint.com/dnf/mobilint.repo \
         -o /etc/yum.repos.d/mobilint.repo
    ```

2. Install via dnf package manager.

    ```bash
    # Install the runtime library
    sudo dnf install mobilint-qb-runtime

    # (Optional) Install the Mobilint CLI utility
    sudo dnf install mobilint-cli
    ```

    ````{note}
    On the first installation, `dnf` asks for confirmation before importing Mobilint's GPG signing key. Check that the output below, then please answer `y`.

    ```text
    Importing GPG key 0x________:
     Userid     : "Mobilint_RPM (gpg key for dnf - RSA key.) <infra@mobilint.com>"
     Fingerprint: 
     From       : https://dl.mobilint.com/dnf/gpg.pub
    Is this ok [y/N]: y
    ```
    ````

3. Verify installation.

    ```bash
    rpm -ql mobilint-qb-runtime
    ```

### Option 3: Manual Installation from Download Center

#### Requirements

- Download the appropriate runtime library from Mobilint’s official [Download Center](https://dl.mobilint.com).

#### Installation Process

1. Unzip the downloaded runtime library file. `{RUNTIME_VERSION}` corresponding to your runtime library version.

    ```bash
    tar -xvzf qb-runtime_aries2-v4_v{RUNTIME_VERSION}.tar.gz
    ```

    You should see a directory structure like this:

    ```bash
    qb-runtime_aries2-v4_v{RUNTIME_VERSION}
    ├── Makefile
    ├── qbruntime
    │   ├── qbruntime
    │   │ ├── include    # include path
    │   │ │   └── qbruntime
    │   │ ├── lib        # library path
    │   │ └── python
    │   └── resnet50
    └── mobilint-cli
    ```

There are two options from here: **System-wide installation**, or **using without installing**. 

#### Option 3-1: System-Wide Installation

Install the runtime library system-wide using the following commands.

```bash
cd qb-runtime_aries2-v4_v{RUNTIME_VERSION}
sudo make install
```

#### Option 3-2: Use Without Installation

Specify the paths to `qb-runtime_aries2-v4_v{RUNTIME_VERSION}/qbruntime/qbruntime/include` and `qb-runtime_aries2-v4_v{RUNTIME_VERSION}/qbruntime/qbruntime/lib` during compilation as shown below:

```bash
g++ -o {output_binary} {source_code} -I{path_to_include} \
    -L{path_to_library} -lqbruntime
```

Then export environment variable `LD_LIBRARY_PATH` to let linker know runtime library(`*.so`) path.

```bash
export LD_LIBRARY_PATH={path_to_library}
```

### Option 4: Installation via pip

```{note}
Installing the Python library package via pip on Ubuntu is supported starting from runtime library version **0.29.0**.
```

The Python library can be installed using pip. Run the following command to install the Python library package:

```bash
pip install mobilint-qb-runtime
```

````{note}
The Python wheel uses the `manylinux_x_y` platform tag, which requires **pip 20.3 or later**. If pip cannot find the package even on a supported Python version (3.8–3.14), check your pip version and upgrade it if needed:

```bash
pip install --upgrade pip
```
````

## Installing on Windows

### Requirements

- Download the appropriate runtime library from Mobilint’s official [Download Center](https://dl.mobilint.com).

### Installation Process
On Windows, only **non-installation** method is supported. Please refer to section [Comiling C++ code - Windows](#compile-windows).