# Linux Setup

## **Instructions for Linux Host (Ubuntu, WSL, and other distros)**

Follow these instructions to install the Qualcomm Neural Processing SDK **(commonly referred to as SNPE)** and all necessary dependencies.

SNPE allows you to convert an AI model (e.g., a `.pt` model from PyTorch) into instructions that can be run on a target device’s various processing units (CPU, GPU, DSP).

Note

This guide is for a host machine running Linux. If you’re using a Windows machine, please follow the instructions for the [Windows setup](https://docs.qualcomm.com/doc/80-63442-2/topic/setup_windows.html).

Note

SNPE is verified with the Ubuntu 22.04 LTS (Focal) Linux host operating system and the Windows Subsystem for Linux (WSL2) environment, version 1.1.3.0 (currently limited to Linux host runnable artifacts such as converters, model generation and run tools).

There are several parts to this guide to install SNPE and all its corresponding dependencies:

- Part 1: Install the SNPE SDK.
- Part 2: Install SNPE dependencies.
- Part 3: Install model frameworks to interpret your AI model files (e.g., `PyTorch`).
- Part 4: Install Target Device OS-Specific Toolchain Code.
- Part 5: Install Dependencies for Target Hardware Processors.

These steps will require admin access in order to run some of the installation commands.

Note

To learn about acronyms which are new to you, see the [glossary](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/glossary.html).

Note

This guide contains many recommendations about specific versions of code to use that have been verified to work. Other versions of those dependencies may or may not work, so use them at your own risk.

## Part 1: Install the **Qualcomm Neural Processing Engine (aka “SNPE”)**

1. Go to the [SNPE product page](https://www.qualcomm.com/developer/software/neural-processing-sdk-for-ai).
2. Click “Get Software” to download the SNPE SDK (this will install the QAIRT SDK which contains SNPE inside).

    1. The zipped file should have a name like `v2.32.0.250228`.
    2. **Note:** the SNPE SDK is ~ 2.5GB when unzipped.
3. Unzip the downloaded SDK into the folder where you want the SDK to live.

### Set up your environment

1. Open a terminal.

Note

Please keep this terminal open, as it will contain environment variables you’ll need in later steps and tutorials.
2. Navigate inside the unzipped SNPE SDK to `/qairt/<SNPE_VERSION>/bin`.

    1. Replace `<SNPE_VERSION>` with the name of the folder directly under `qairt`.

        - It should look almost identical to the zipped folder name (ex. `2.32.0.250228`).
        - Example: `cd /path/to/unzipped/sdk/qairt/2.32.0.250228/bin`
3. To set important environment variables like `QAIRT_SDK_ROOT` run:

source ./envsetup.sh
        Copy to clipboard

Warning

The `envsetup.sh` script only updates environment variables for the current terminal session.
4. To copy install the core Linux build tools, run:

chmod +x "${QAIRT_SDK_ROOT}/bin/check-linux-dependency.sh"
        sudo "${QAIRT_SDK_ROOT}/bin/check-linux-dependency.sh"
        Copy to clipboard

    - If you see “Done!!”, then the installation has completed successfully.
    - If you do not see that message, you may need to re-run the command after it installs key packages (like build-essential, cmake, etc.).

Note

As the script is running, you may have to confirm additional downloads by pressing “Enter”. The script may take several minutes to complete.
5. Run the following command to verify that you have installed the required toolchain successfully:

"${QAIRT_SDK_ROOT}/bin/envcheck" -c
        Copy to clipboard

    - This will verify that you have installed the required toolchain successfully. You should see something like this:

Checking Clang Environment
            --------------------------------------------------------------
            [INFO] Found clang++ at /usr/bin/clang++
            --------------------------------------------------------------
            Copy to clipboard

## Part 2: Install SNPE SDK dependencies

1. Check whether you have Python 3.10 installed by running:

compgen -c python | grep -E '^python[0-9\.]*$' | sort -V | uniq
        Copy to clipboard

    - You should see `python3.10` if you have it installed.
    - **If you do not have Python 3.10**, you can install it by running:

sudo apt-get update && sudo apt-get install python3.10 python3-distutils libpython3.10
            Copy to clipboard
    - Verify the installation worked by running:

python3 --version
            Copy to clipboard

        - You should see `Python 3.10` as one of the options.
2. Run the following to check if you have `python3.10-venv` installed:

dpkg -l | grep python3.10-venv
        Copy to clipboard
3. If you do not have `python3.10-venv` installed, you can install it by running:

sudo apt install python3.10-venv
        Copy to clipboard
4. Create and activate a new virtual environment:

cd ${QAIRT_SDK_ROOT}/bin
        python3 -m venv venv --without-pip
        source venv/bin/activate
        Copy to clipboard

Warning

If your environment is in WSL, `<PYTHON3.10_VENV_ROOT>` must be under `$HOME`.

Warning

We have to use the flag `--without-pip` on Debian/Ubuntu systems to avoid a crash since venv will call `ensurepip` at the system level (which is disabled on these distros). Once we activate our venv, we can safely run `ensurepip` to create a local pip for installing packages.
5. Install `pip3` in your virtual environment (see warning above for why):

python3 -m ensurepip --upgrade
        Copy to clipboard
6. Verify `pip3` is installed by running:

which pip3
        Copy to clipboard

    1. You should see a path that is inside your virtual environment (e.g., `/venv/bin/pip3`)
7. Update all dependencies by running:

python "${QAIRT_SDK_ROOT}/bin/check-python-dependency"
        Copy to clipboard

Warning

If you run into an error with a specific version of a package, run `pip install PACKAGE_NAME` to get a more up-to-date version of the package then re-run the script above.

## Part 3: Install Model Frameworks

SNPE supports the following model frameworks.

1. Install the packages from the below table that are relevant for the AI model files you want to use.

Note

You can install a package by running `pip3 install package==version`. e.g., `pip3 install torch==2.4.0`

Warning

You do not need to install **all** packages here.

| Framework | **Package** | **Version** | **Description** |
| --- | --- | --- | --- |
| PyTorch | [torch](https://pypi.org/project/torch/) | 2.4.0 | PyTorch is used for building and training deep learning models with a focus on flexibility and speed. Used with `.pt` files. Install by downloading the proper binary from [PyTorch previous versions](https://pytorch.org/get-started/previous-versions/#v1130) if `pip install` does not work. **THIS REQUIRES INSTALLING ONNX 1.17.0.** |
| TensorFlow | [tensorflow](https://pypi.org/project/tensorflow/) | 2.10.1 | TensorFlow is used for building and training machine learning models, particularly deep learning models. Used with `.pb` files.<br>⚠️ The envcheck script may incorrectly say this file is not installed on Ubuntu. If you would like to use `tensorflow 1.15.1`, you must install Python 3.6.8 by rerunning the Python installation steps above with that version. |
| TFLite | [tflite](https://pypi.org/project/tflite/) | 2.18.0 | TFLite is used for running TensorFlow models on mobile and edge devices with optimized performance. Used with `.tflite` files. |
| ONNX | [onnx](https://pypi.org/project/onnx/) | 1.17.0 | ONNX stands for Open Neural Network Exchange. It is used for defining and exchanging deep learning models between different frameworks. Used with `.onnx` files. |
| ONNX Runtime | [onnxruntime](https://pypi.org/project/onnxruntime/) | for ubuntu22.04 - 1.22.0, for ubuntu20.04 - 1.19.2 | ONNX stands for Open Neural Network Exchange. It is used for running ONNX models with high performance across various hardware platforms. Used with `.onnx` files. |

Note

You can verify your installation by running `python -c "import <model>"` (replacing `<model>` with the import you downloaded above).
If the script executes without any errors, the package is installed correctly.

## Part 4: Install Target Device OS-Specific Toolchain Code

Depending on the target device’s operating system there may be additional installation requirements. These dependencies are mostly used for cross-compilation.

You only need to read the section that corresponds to your target device OS. SNPE supports versions of Android, Linux, OE Linux, and Windows target devices.

Note

For Windows target devices, you do not need to do any additional installations, you can skip to Part 5.

### Working with an Android Target Device

For working with Android devices, you will need to install a corresponding Android NDK (Native Developer Kit). You can install the recommended version (Android NDK version `r26c`) by following these steps:

1. Download the Android NDK: [Android NDK r26c](https://dl.google.com/android/repository/android-ndk-r26c-linux.zip)
2. Unzip the file.

Warning

If your environment is in WSL, the Android NDK must be unzipped under `$HOME` with the WSL `unzip` command.
3. Copy the path to your unzipped Android NDK root (the folder should be named `android-ndk-r26c`).
4. Replace `<path-to-your-android-ndk-root-folder>` with the path to the unzipped `android-ndk-r26c` folder, then run:

echo 'export ANDROID_NDK_ROOT="<path-to-your-android-ndk-root-folder>"' >> ~/.bashrc
        Copy to clipboard
5. Add the location of the unzipped file to your PATH by running:

echo 'export PATH="${ANDROID_NDK_ROOT}:${PATH}"' >> ~/.bashrc
        source ~/.bashrc
        Copy to clipboard
6. Verify your environment variables by running:

${QAIRT_SDK_ROOT}/bin/envcheck -n
        Copy to clipboard
7. Install Java 8 by running:

sudo apt-get install openjdk-8-jdk
        Copy to clipboard

Note

Java 8 has been verified with SNPE, other versions may not work as expected. Java is essential if you want to use SNPE with an Android application.

### Working with a Linux Target Device

1. Verify if you have `clang++` by running:

${QAIRT_SDK_ROOT}/bin/envcheck -c
        Copy to clipboard

    You should see something like:

Checking Clang Environment
        --------------------------------------------------------------
        [INFO] Found clang++ at /usr/bin/clang++
        --------------------------------------------------------------
        Copy to clipboard
2. If you don’t, you will likely need to use `clang++14` to build models for Linux target devices using SNPE (later versions may work but have not been verified).

Note

For more information, see [C++ Support in Clang](https://clang.llvm.org/cxx_status.html).

    1. To install `clang++14`, run:

sudo apt update
            sudo apt install -y wget gpg lsb-release
            wget https://apt.llvm.org/llvm.sh
            chmod +x llvm.sh
            sudo ./llvm.sh 14
            Copy to clipboard
    2. To verify if you have `clang++14`, run:

/usr/bin/clang++ --version
            Copy to clipboard

        You should see something like:

Ubuntu clang version 14.0.6
            Target: x86_64-pc-linux-gnu
            Thread model: posix
            InstalledDir: /usr/bin
            Copy to clipboard
3. If `make` is not already installed on your system, install it by running:

sudo apt-get install make
        Copy to clipboard

### OE Linux

Some Linux target devices, such as those based on **Yocto Kirkstone**, require cross-compilation using a GCC-based toolchain. The Qualcomm Neural Processing SDK has been verified to work with **GCC 11.2** for these systems.

If you do not already have the required toolchain installed or available in your system `PATH`, follow these steps to download and install the cross-compiler using Qualcomm’s eSDK:

1. Download the SDK package:

wget https://artifacts.codelinaro.org/artifactory/qli-ci/flashable-binaries/qimpsdk/qcm6490/x86/qcom-6.6.28-QLI.1.1-Ver.1.1_qim-product-sdk-1.1.3.zip
        Copy to clipboard
2. Unzip the downloaded archive:

unzip qcom-6.6.28-QLI.1.1-Ver.1.1_qim-product-sdk-1.1.3.zip
        Copy to clipboard
3. Update permissions:

umask a+rx
        Copy to clipboard
4. Navigate into the installation script folder:

cd ./target/qcm6490/sdk
        Copy to clipboard
5. Run the toolchain installer script:

sh qcom-wayland-x86_64-qcom-multimedia-image-armv8-2a-qcm6490-toolchain-ext-1.0.sh
        Copy to clipboard

    You can install the packages it asks you to install with a command like this:

sudo apt update
        sudo apt install <your packages separated by spaces>
        Copy to clipboard

Note

When it asks you where to install the toolchain, type Enter twice for default paths.
6. When the installation is complete successfully, you should see the following text:

done
        SDK has been successfully set up and is ready to be used.
        Each time you wish to use the SDK in a new shell session, you need to source the environment setup script e.g.
         $ . /home/usr/qcom-wayland_sdk/environment-setup-armv8-2a-qcom-linux
        Copy to clipboard
7. Copy the path to `qcom-wayland_sdk` from the installation output.

    1. Ex. `/home/usr/qcom-wayland_sdk/`
    2. Do NOT copy the last piece of the path `environment-setup-armv8-2a-qcom-linux`.
8. Set `ESDK_ROOT` to the path at the bottom of your installation output (like above) by running:

export ESDK_ROOT="<path-to-qcom-wayland_sdk>"
        Copy to clipboard
9. Set your eSDK root and source the toolchain environment:

cd $ESDK_ROOT
        source environment-setup-armv8-2a-qcom-linux
        Copy to clipboard

Warning

If you see an error like `...environment-setup-armv8-2a-qcom-linux: Not a directory`, go back to **Step 7** and reset your ESDK\_ROOT to just the path to `qcom-wayland_sdk` NOT the path to the `environment-setup...` script.

This sets up the correct cross-compilation environment to build and deploy models for Yocto-based Linux targets.

## Part 5: Install Dependencies for Target Hardware Processors

Some of the target processors (CPU, GPU, or DSP) require additional dependencies to build models.

### CPU (Central Processing Unit)

The x86\_64 targets are built using `clang-14`. If you’re using this kind of target, please install `clang++14`.

1. To install `clang++14`, follow the **“Working with a Linux Device”** steps above.
2. ARM CPU targets are built using the Android NDK (see the Working with an Android Target Device section above).

### GPU (Graphics Processing Unit)

The GPU backend kernels are written based on OpenCL. The GPU operations must be implemented based on OpenCL headers with a minimum version of OpenCL 1.2.

### DSP

Compiling for DSP hardware requires the use of the Qualcomm Hexagon SDK and Hexagon SDK Tools which you can install by following these steps:

1. If you do not already have Qualcomm Package Manager 3 (QPM3) installed, install it by following the steps below:

    1. [Create an account or sign in with your Qualcomm ID](https://myaccount.qualcomm.com/login?TYPE=33554433&amp;REALMOID=06-0006f786-a2f4-1c10-ad60-90840a310000&amp;GUID=&amp;SMAUTHREASON=0&amp;METHOD=GET&amp;SMAGENTNAME=-SM-3povwZYzFq7kK5igjUBYgAdpxIaTZVkPnsewLqmuJzlQ75llbe6K2%2fAof8H6S9Ca&amp;TARGET=-SM-HTTPS%3a%2f%2fopenid%2equalcomm%2ecom%2faffwebservices%2fredirectjsp%2fredirect_openid%2ejsp%3fresponse_type%3dcode%26client_id%3d000abfc2--73ce--1d40--90c3--90840a310000%26redirect_uri%3dhttps%3a%2f%2fmyid%2equalcomm%2ecom%2fapi%2floggedIn%26scope%3dopenid%2bprofile%26state%3daHR0cHM6Ly9teWFjY291bnQucXVhbGNvbW0uY29tL3Byb2ZpbGU%3d%26SMPORTALURL%3dhttps-%3A-%2F-%2Fopenid%2equalcomm%2ecom-%2Faffwebservices-%2FCASSO-%2Foidc-%2Fauthorize)
    2. Go to the [Qualcomm Package Manager 3](https://qpm.qualcomm.com/#/main/tools/details/QPM3) download page. You must be signed in.

Warning

You may have to click the link again after logging in to have it load properly. If you just created an account, this may take up to 10 minutes to fully register your new account.

    3. Download the Linux version of Qualcomm Package Manager 3 (QPM3).

        1. The downloaded file will have a name similar to: `QualcommPackageManager3.3.0.121.7.Linux-x86.deb`.
    4. Install the `.deb` (replacing the path with the path to the downloaded QPM3 file):

sudo dpkg -i ./<path-to-your-downloaded-.deb>
            Copy to clipboard
2. Start the Qualcomm Package Manager 3 App (from the activities section).
3. Log in with your Qualcomm ID within the QPM 3 app when prompted.
4. Once logged in to QPM3, click on “Tools.”
5. Look up which “Hexagon Architecture” your chip supports in the [supported Snapdragon devices table](https://docs.qualcomm.com/bundle/publicresource/topics/80-63442-50/overview.html#tbl-supported-snapdragon-devices) (it should look like “V00”).
6. Use the Hexagon Architecture you just looked up to determine which version of the “Hexagon SDK” you need from this table:

    | **Hexagon Architecture** | **Hexagon SDK Version** |
    | --- | --- |
    | V75 | 5.4.0 |
    | V73 | 5.4.0 |
    | V69 | 4.3.0 |
    | v68 | 4.2.0 |
    | v66 | 4.1.0 |
7. Search for “Hexagon SDK” in QPM3.
8. Download the proper version for your target device based on the table above.

    1. You will have to accept terms and conditions to use the downloaded files.
    2. You will likely want to leave the files in the default location.
    3. The download should pre-select which add-ons are relevant. You may download the “Full NDK” as an alternative to the “Minimal NDK” depending on your use case.
9. Write down the path to the Hexagon SDK, you will need it later.
10. In QPM3, go back to the search bar and search for “Hexagon Toolchain”.
11. Based on your Hexagon Architecture, choose the corresponding version of the Hexagon Toolchain to click into:

> 
> 
> Note
> 
> 
> Hexagon SDK tools version 8.7.03/8.6.02/8.5.03/8.4.09/8.4.06 is **not** currently pre-packaged into Hexagon SDK version 5.4.0/4.3.0/4.2.0/4.1.0 respectively.
> It needs to be downloaded separately and placed at the location `$HEXAGON_SDK_ROOT/tools/HEXAGON_Tools/`.

12. Download the corresponding version of the “Hexagon Toolchain”.
13. Ensure you have installed `clang++` so you can compile code for DSP hardware (see the **“Working with a Linux Target”** section above).
14. Follow the rest of the instructions at `$HEXAGON_SDK_ROOT/docs/readme.html` (where `$HEXAGON_SDK_ROOT` is the location of the Hexagon SDK installation) to complete the installation.

## Next Steps

Now that you’ve finished setting up SNPE and its dependencies, you can start using SNPE. Follow the [“Building and Executing a Model” Tutorial](https://docs.qualcomm.com/doc/80-63442-2/topic/building_and_executing_tutorial.html) to learn how to transform your AI models, build them for your target device, and use them to generate inferences on the information processing cores you choose. Use SNPE to allow your AI models to execute on your specific target device’s cores.

Last Published: Oct 02, 2025

[Previous Topic
Setup](https://docs.qualcomm.com/bundle/publicresource/80-63442-2/topics/setup.md) [Next Topic
Windows Setup](https://docs.qualcomm.com/bundle/publicresource/80-63442-2/topics/setup_windows.md)