option
MaisonMaison Skill Outils de développement holoscan-install-wheel

holoscan-install-wheel

NVIDIA/skills NVIDIA/skills

Installez le « wheel » Python du SDK Holoscan via pip dans un environnement virtuel, puis vérifiez son fonctionnement à l'aide des scripts d'exemple.

...Développer tout
6
Heure mise à jour 25 septembre 2026

Installation de la roue Holoscan

Objectif

Installer les liaisons Python du SDK Holoscan via le fichier pip « holoscan-cu12 » / « holoscan-cu13 » dans un environnement virtuel, puis effectuer une vérification à l'aide des scripts « hello_world » et « video_replayer ».

Prérequis

  • Système Linux x86_64 équipé d’un GPU NVIDIA et de son pilote (nvidia-smi).
  • Kit d'outils CUDA dans le PATH correspondant à la version majeure de CUDA de l'hôte (12 ou 13).
  • Python 3.10–3.13 avec venv disponible.
  • Accès réseau à PyPI et à docs.nvidia.com.

Limitations

  • Python uniquement. Pour les en-têtes/bibliothèques C++, à associer à /holoscan-install-debian.
  • holoscan-cu12 et holoscan-cu13 s’excluent mutuellement — le fichier wheel doit correspondre au pilote CUDA de l’hôte.
  • Les donnéesde video_replayer ne sont fournies qu’avec le paquet Debian ; en l’absence de celui-ci, définissez HOLOSCAN_INPUT_PATH sur un répertoire contenant racerx/.
  • Il est recommandé d'exécuter `ulimit -s 32768 ` dans chaque shell exécutant Holoscan — sans cela, certaines applications génèrent un avertissement concernant la taille de la pile ou, dans de rares cas, une erreur de segmentation.

Étape 0 : Consultez les instructions d’installation officielles

Consultez toujours la section pip-wheel du site https://docs.nvidia.com/holoscan/sdk-user-guide/sdk_installation.html avant l’installation. Extrait : noms exacts des paquets wheel (holoscan-cu12, holoscan-cu13), plage de versions Python prises en charge pour la version actuelle, prérequis devant figurer dans le PATH (CUDA Toolkit) et éventuels éléments supplémentaires facultatifs (versions spécifiques de LibTorch / ONNX Runtime). Si la documentation contredit l’une des informations ci-dessous, c’est la documentation qui prévaut.

Vous devez disposer de la variante CUDA déjà déterminée. Si vous ne la connaissez pas, exécutez d’abord la commande ` nvidia-smi 2>&1 | head -5 `.

Règle relative à la variante CUDA — choisissez le paquet pip :

Version CUDA selon nvidia-smi Paquet pip
13.x+ holoscan-cu13
12.x (tout GPU) holoscan-cu12

Prérequis : CUDA Toolkit dans le PATH, Python 3.10–3.13. Options supplémentaires : LibTorch 2.11.0+, ONNX Runtime 1.22.0+.

Installez toujours le logiciel dans un environnement virtuel Python — cela évite les conflits avec les paquets système et est obligatoire sous Ubuntu 24.04 (qui bloque complètement l'utilisation de pip à l'échelle du système).

Étape 1 : Créer et activer l’environnement virtuel (venv)

Vérifiez d’abord s’il en existe déjà un :

ls ~/holoscan/venv 2>/dev/null && echo "existe" || echo "manquant"

S'il n'existe pas :

python3 -m venv ~/holoscan/venv

Puis activez-le :

source ~/holoscan/venv/bin/activate

Étape 2 : Installation

pip install holoscan-cu12   # ou holoscan-cu13

Étape 3 : Vérification

L'environnement venv doit être actif pour toutes les commandes ci-dessous.

# Importation de base — résultat attendu : chaîne de version, par ex. « 4.1.0 »
# L’avertissement RuntimeWarning relatif à la taille de la pile est sans conséquence ; la commande `ulimit -s 32768` permet de le désactiver.
python3 -c "import holoscan; print(holoscan.__version__)"

# Récupérer les exemples Python depuis GitHub à partir de la balise correspondant à la version installée.
# Il s’agit d’exemples officiels de NVIDIA, récupérés via HTTPS et associés à la balise
# correspondant au fichier wheel installé (v${SDK_VER}). Avant de les exécuter, prévenez l’utilisateur
# que vous êtes sur le point de télécharger et d’exécuter des scripts d’exemples à distance à partir de cette URL. Si
# il refuse ou si GitHub est inaccessible, passez directement à la consultation des exemples à l’étape 4.
SDK_VER=$(python3 -c "import holoscan; print(holoscan.__version__)")
BASE="https://raw.githubusercontent.com/nvidia-holoscan/holoscan-sdk/v${SDK_VER}/examples"

# hello_world — résultat attendu : « Hello World ! »
curl -fsSL "${BASE}/hello_world/python/hello_world.py" -o /tmp/hs_hello_world.py
ulimit -s 32768 && python3 /tmp/hs_hello_world.py

# video_replayer (10 images, en mode sans interface graphique) — résultat attendu : « Exécution du graphe terminée. »
# Toujours exécuter en mode sans interface graphique : fonctionne avec ou sans écran, évite les défaillances de l’interface graphique via SSH.
curl -fsSL "${BASE}/video_replayer/python/video_replayer.py" -o /tmp/hs_video_replayer.py
curl -fsSL "${BASE}/video_replayer/python/video_replayer.yaml" -o /tmp/hs_video_replayer.yaml
python3 -c "
c = open('/tmp/hs_video_replayer.yaml').read()
c = c.replace('count: 0','count: 10').replace('repeat: true','repeat: false').replace('realtime: true','realtime: false')
c = c.replace('holoviz:\n  width: 854','holoviz:\n  headless: true\n  width: 854')
open('/tmp/hs_video_replayer_run.yaml','w').write(c)"
ulimit -s 32768 && HOLOSCAN_INPUT_PATH=/opt/nvidia/holoscan/data \
  python3 /tmp/hs_video_replayer.py --config /tmp/hs_video_replayer_run.yaml

Remarque : video_replayer a besoin des fichiers de données racerx. Ceux-ci sont fournis avec le paquet Debian dans /opt/nvidia/holoscan/data. Si le paquet Debian n’est pas installé, exécutez d’abord sudo /opt/nvidia/holoscan/examples/download_example_data (ce script nécessite l’installation du paquet apt), ou définissez HOLOSCAN_INPUT_PATH sur l’emplacement où se trouvent les données.

Étape 4 : Rappel à l'utilisateur

Il doit activer l’environnement venv à chaque nouvelle session de shell :

source ~/holoscan/venv/bin/activate
ulimit -s 32768   # pour supprimer l'avertissement concernant la taille de la pile

Proposez ensuite les étapes suivantes :

  • Découvrez des exemples Python sur https://github.com/nvidia-holoscan/holoscan-sdk/tree/v/examples
  • Suivez pas à pas un exemple spécifique : /explain-example
  • Commencez à créer une application Holoscan personnalisée

Dépannage

  • Erreurs « externally-managed-environment » lors del’installation de pip install holoscan-cu12. Ubuntu 24.04 bloque pip à l’échelle du système. Créez et activez d’abord l’environnement venv de l’étape 1.
  • ImportError / version CUDA incorrecte lors de l'importation de holoscan. La variante du fichier wheel ne correspond pas à la version CUDA de l'hôte. Désinstallez et réinstallez la version correspondante : pip uninstall -y holoscan-cu13 && pip install holoscan-cu12 (ou inversement).
  • RuntimeWarning : taille de la pile… Sans conséquence, mais définissez ulimit -s 32768 dans le shell actuel pour faire taire ce message.
  • Erreur de segmentation lors de l'exécution d'un exemple. ulimit -s 32768 n'a pas été défini. Définissez-le avant python3....
  • video_replayer ne trouve pas racerx/. HOLOSCAN_INPUT_PATH ne pointe pas vers un répertoire le contenant. Installez le paquet Debian pour /opt/nvidia/holoscan/data, ou définissez HOLOSCAN_INPUT_PATH vers l'emplacement où se trouvent les données.
  • source : fichier introuvable : ~/holoscan/venv/bin/activate dans un nouveau shell. Venv n’a pas été créé ou le chemin d’accès est incorrect. Relancez l’étape 1 ou corrigez le chemin d’accès.
Voir sur GitHub
---
name: holoscan-install-wheel
description: Install the Holoscan SDK Python wheel via pip into a virtual environment and verify with example scripts.
license: Apache-2.0
---

# Holoscan pip Wheel Installation

## Purpose

Install the Holoscan SDK Python bindings via the `holoscan-cu12` / `holoscan-cu13` pip wheel into a virtual environment, and verify with `hello_world` and `video_replayer`.

## Prerequisites

- Linux x86_64 with NVIDIA GPU + driver (`nvidia-smi`).
- CUDA Toolkit on `PATH` matching the host CUDA major (12 or 13).
- Python 3.10–3.13 with `venv` available.
- Network access to PyPI and `docs.nvidia.com`.

## Limitations

- Python only. For C++ headers/libs, pair with `/holoscan-install-debian`.
- `holoscan-cu12` and `holoscan-cu13` are mutually exclusive — wheel must match host CUDA driver.
- `video_replayer` data ships only with the Debian package; without it, set `HOLOSCAN_INPUT_PATH` to a directory containing `racerx/`.
- `ulimit -s 32768` is recommended in every shell that runs Holoscan — without it some apps emit a stack-size warning or, in rarer cases, segfault.

## Step 0: Consult the Official Install Instructions

Always fetch the pip-wheel section of `https://docs.nvidia.com/holoscan/sdk-user-guide/sdk_installation.html` before installing. Extract: exact wheel package names (`holoscan-cu12`, `holoscan-cu13`), the supported Python range for the current release, prerequisites that must be on `PATH` (CUDA Toolkit), and any optional extras (LibTorch / ONNX Runtime version pins). If the doc disagrees with anything below, the doc wins.

You need the CUDA variant already determined. If not known, run `nvidia-smi 2>&1 | head -5` first.

**CUDA variant rule — pick the pip package:**

| nvidia-smi CUDA Version | pip package |
|------------------------|-------------|
| 13.x+ | `holoscan-cu13` |
| 12.x (any GPU) | `holoscan-cu12` |

Prerequisites: CUDA Toolkit on PATH, Python 3.10–3.13. Optional extras: LibTorch 2.11.0+, ONNX Runtime 1.22.0+.

Always install into a Python virtual environment — this avoids system-package conflicts and is required on Ubuntu 24.04 (which blocks system-wide pip entirely).

## Step 1: Create and Activate the venv

Check if one exists first:

```bash
ls ~/holoscan/venv 2>/dev/null && echo "exists" || echo "missing"
```

If missing:
```bash
python3 -m venv ~/holoscan/venv
```

Then activate:
```bash
source ~/holoscan/venv/bin/activate
```

## Step 2: Install

```bash
pip install holoscan-cu12   # or holoscan-cu13
```

## Step 3: Verify

The venv must be active for all commands below.

```bash
# Basic import — expected: version string, e.g. "4.1.0"
# The stack-size RuntimeWarning is harmless; ulimit -s 32768 suppresses it.
python3 -c "import holoscan; print(holoscan.__version__)"

# Fetch Python examples from GitHub at the installed version tag.
# These are official NVIDIA examples, fetched over HTTPS and pinned to the tag
# matching the installed wheel (v${SDK_VER}). Before running them, tell the user
# you're about to download and execute remote example scripts from this URL. If
# they decline or GitHub is unreachable, skip to browsing the examples in Step 4.
SDK_VER=$(python3 -c "import holoscan; print(holoscan.__version__)")
BASE="https://raw.githubusercontent.com/nvidia-holoscan/holoscan-sdk/v${SDK_VER}/examples"

# hello_world — expected: "Hello World!"
curl -fsSL "${BASE}/hello_world/python/hello_world.py" -o /tmp/hs_hello_world.py
ulimit -s 32768 && python3 /tmp/hs_hello_world.py

# video_replayer (10 frames, headless) — expected: "Graph execution finished."
# Always run headless: works with or without a display, avoids GUI failure modes over SSH.
curl -fsSL "${BASE}/video_replayer/python/video_replayer.py" -o /tmp/hs_video_replayer.py
curl -fsSL "${BASE}/video_replayer/python/video_replayer.yaml" -o /tmp/hs_video_replayer.yaml
python3 -c "
c = open('/tmp/hs_video_replayer.yaml').read()
c = c.replace('count: 0','count: 10').replace('repeat: true','repeat: false').replace('realtime: true','realtime: false')
c = c.replace('holoviz:\n  width: 854','holoviz:\n  headless: true\n  width: 854')
open('/tmp/hs_video_replayer_run.yaml','w').write(c)"
ulimit -s 32768 && HOLOSCAN_INPUT_PATH=/opt/nvidia/holoscan/data \
  python3 /tmp/hs_video_replayer.py --config /tmp/hs_video_replayer_run.yaml
```

Note: `video_replayer` needs the racerx data files. These ship with the Debian package at `/opt/nvidia/holoscan/data`. If the Debian package is not installed, run `sudo /opt/nvidia/holoscan/examples/download_example_data` first (requires the apt package to be installed for that script), or set `HOLOSCAN_INPUT_PATH` to wherever the data lives.

## Step 4: Remind the User

They must activate the venv in each new shell session:

```bash
source ~/holoscan/venv/bin/activate
ulimit -s 32768   # suppress stack-size warning
```

Then offer next steps:
- Explore Python examples at `https://github.com/nvidia-holoscan/holoscan-sdk/tree/v<VERSION>/examples`
- Walk through a specific example: `/explain-example`
- Start building a custom Holoscan application

## Troubleshooting

- **`pip install holoscan-cu12` errors with "externally-managed-environment".** Ubuntu 24.04 blocks system-wide pip. Create and activate the venv from Step 1 first.
- **`ImportError` / wrong CUDA at `import holoscan`.** Wheel variant doesn't match host CUDA. Uninstall and reinstall the matching one: `pip uninstall -y holoscan-cu13 && pip install holoscan-cu12` (or vice versa).
- **`RuntimeWarning: stack size ...`.** Harmless, but set `ulimit -s 32768` in the current shell to silence it.
- **Segmentation fault when running an example.** `ulimit -s 32768` wasn't set. Set it before `python3 ...`.
- **`video_replayer` can't find `racerx/`.** `HOLOSCAN_INPUT_PATH` isn't pointing at a directory containing it. Install the Debian package for `/opt/nvidia/holoscan/data`, or set `HOLOSCAN_INPUT_PATH` to wherever the data lives.
- **`source: no such file: ~/holoscan/venv/bin/activate` in a new shell.** Venv wasn't created or path differs. Re-run Step 1 or correct the path.

Tous les fichiers

5 fichiers
SKILL.md 6.2k
Voir

Installer holoscan-install-wheel

Téléchargez et décompressez les fichiers de compétences dans votre répertoire .claude/skills/.

Télécharger le ZIP

Clonez le dépôt et copiez les fichiers de compétence dans votre projet.

git clone https://github.com/NVIDIA/skills/tree/main/skills/holoscan-install-wheel # Copy SKILL.md to your .claude/skills/ directory

Copier Copier
Configuration rapide: Copiez le dossier de la compétence dans .claude/skills/ Claude détectera automatiquement la compétence et l'utilisera
Dépôt NVIDIA/skills

Compétences similaires

algorithmic-art
Heure mise à jour 27 août 2026
systematic-debugging
Heure mise à jour 3 septembre 2026
tech-debt-tracker
Heure mise à jour 29 août 2026
continual-learning
Heure mise à jour 10 septembre 2026
OR