Hack-a-thon Resources#

The following software stack has already been pre-installed on your system. Feel free to review it and launch Physical AI Studio when you are ready to begin. For launch instructions, see Daily Use After Installation.

Edge AI and Robotics AI Suites — Script-Based Installation & Verification#

Target: Ubuntu 24.04 LTS (HWE kernel) · Intel® Core™ Ultra with Intel® Arc™ graphics (NPU + GPU) Stack: NPU Driver → Intel® Arc™ graphics driver → Miniforge3 (intel_dev_env) → Physical AI Studio → OpenVINO™ 2026.3 → Anomalib v2.6.0 → LeRobot (PyTorch XPU) → VS Code

Package Contents#

File

Purpose

1_install_drivers.sh

Installs Intel NPU + Intel® Arc™ graphics drivers (reboot required after)

2_install_software.sh

Installs Miniforge3, intel_dev_env, Physical AI Studio, OpenVINO™, Anomalib, LeRobot (+PyTorch XPU swap), VS Code

verify_stack.py

Python script that functionally tests every installed component

intel-edge-ai-stack-installation-guide.md

Full manual step-by-step guide (reference / troubleshooting)

README.md

This document

Installation Workflow#

Step 0 — Preparation#

Copy all files to the target machine, then:

chmod +x 1_install_drivers.sh 2_install_software.sh

Confirm the OS and kernel meet requirements:

lsb_release -a    # expect Ubuntu 24.04
uname -r          # expect kernel >= 6.8 (HWE); NPU needs >= 6.6

⚠️ Run all scripts as a normal user (not root / not with sudo in front). They call sudo internally where needed.

Step 1 — Install the drivers#

./1_install_drivers.sh

What it does:

  • Intel NPU driver — purges old NPU packages, installs dependencies (libtbb12), downloads the release tarball from github.com/intel/linux-npu-driver, installs the .deb packages, ensures the Level Zero loader (libze1), and adds you to the render group.

  • Intel® Arc™ graphics driver — adds the ppa:kobuk-team/intel-graphics PPA, installs the compute runtime (OpenCL + Level Zero GPU) and media (VA-API) packages, and adds you to the render and video groups.

📝 If the NPU download fails, a newer release has likely replaced the pinned one. Check https://github.com/intel/linux-npu-driver/releases and update the NPU_DRIVER_VERSION / NPU_DRIVER_TARBALL variables at the top of 1_install_drivers.sh.

Step 2 — Reboot (mandatory)#

sudo reboot

The reboot loads the intel_vpu kernel module and applies the new group memberships. Do not skip this — every later GPU/NPU check will fail without it.

After reboot, quick-verify the drivers:

ls /dev/accel/accel0            # NPU device node exists
sudo dmesg | grep intel_vpu     # "Initialized intel_vpu ..." with no errors
clinfo | grep "Device Name"     # Intel GPU listed
vainfo                          # VA-API profiles listed

Step 3 — Install the software stack#

./2_install_software.sh

What it does, in order:

  1. Miniforge3 + intel_dev_env — installs conda (conda-forge default channel) to ~/miniforge3, creates the intel_dev_env environment (Python 3.11). All Python packages below go into this one environment.

  2. Physical AI Studio — installs uv and nvm, clones the repo to ~/physical-ai-studio, syncs the backend with the Intel XPU extra (uv sync --extra xpu), and builds the UI. Setup only — launch commands are printed at the end.

  3. OpenVINO™ 2026.3 — pip install into intel_dev_env, then prints the available devices (expects ['CPU', 'GPU', 'NPU']).

  4. Anomalib v2.6.0 — installed with the [xpu,openvino] extras.

  5. LeRobot + PyTorch XPU swap — installs system ffmpeg/PyAV build libraries, installs LeRobot, then uninstalls the CUDA-backed torch wheels LeRobot pulls in and reinstalls PyTorch from the XPU wheel index (download.pytorch.org/whl/xpu). Verifies torch.xpu.is_available().

  6. VS Code — installs from the official Microsoft apt repository plus the Python and Jupyter extensions.

The script starts with a driver sanity check and warns if it looks like Step 1/2 were skipped.

Partial runs (e.g., after fixing an error):

./2_install_software.sh 6 7        # only OpenVINO + Anomalib
./2_install_software.sh --from 6   # OpenVINO onward

Both scripts are idempotent — re-running skips what’s already installed (Miniforge, the env, git clones, VS Code).

Step 4 — Verify everything with Python#

conda activate intel_dev_env
python verify_stack.py

The verifier goes beyond imports — it functionally exercises each component:

#

Check

What it actually does

1

Python environment

Confirms you’re inside intel_dev_env

2

OpenVINO™ discovery

Import + all three devices (CPU/GPU/NPU) visible

3

OpenVINO™ inference

Builds a tiny model in memory and compiles + runs it on each device, reporting device name and latency

4

PyTorch XPU

Verifies the +xpu build (catches CUDA wheels sneaking back), torch.xpu.is_available(), and runs a real 512×512 matmul on the GPU

5

Anomalib

Import, Patchcore model instantiation, Engine construction

6

LeRobot

Import + LeRobotDataset API loads

7

Physical AI Studio

Repo/backend presence (non-fatal — it lives in its own uv env)

8

System devices

/dev/accel/accel0, /dev/dri/renderD*, render/video group membership

Output is color-coded PASS/FAIL/WARN per check with a final summary. Exit code 0 = all required checks passed, 1 = something failed — so it can be chained or used in CI:

python verify_stack.py && echo "stack ready"
VERBOSE=1 python verify_stack.py     # full tracebacks for debugging

Expected healthy output ends with:

  ✓ ALL REQUIRED CHECKS PASSED — stack is ready

Quick Reference — Full Sequence#

# 1. Drivers
chmod +x 1_install_drivers.sh 2_install_software.sh
./1_install_drivers.sh

# 2. Reboot (mandatory)
sudo reboot

# 3. Software stack
./2_install_software.sh

# 4. Verify
conda activate intel_dev_env
python verify_stack.py

Daily Use After Installation#

conda activate intel_dev_env                  # every new shell

# Launch Physical AI Studio when needed:
cd ~/physical-ai-studio/application/backend && ./run.sh          # terminal 1
cd ~/physical-ai-studio/application/ui && nvm use && npm run start  # terminal 2
# → http://localhost:3000

Troubleshooting#

Symptom

Fix

curl: command not found (or wget/git/gpg)

Fixed in current scripts — both install base tools first. Re-download the zip or sudo apt install -y curl wget git gpg and re-run

Download fails with 502 Bad Gateway / Failed to fetch from pythonhosted.org

Transient PyPI CDN error — the script now auto-retries 3× with backoff. If it still fails, wait a few minutes and re-run the same step (downloads are cached)

curl: (7) Failed to connect to localhost port 7860 during UI build

The UI API-client build needs the backend running — current script starts it automatically, waits, builds, then stops it. Re-run: ./2_install_software.sh 5

npm “funding” / “vulnerabilities” / “new version” notices

Informational only — safe to ignore

NPU tarball download fails

Update NPU_DRIVER_* variables in 1_install_drivers.sh to the latest release

verify_stack.py: OpenVINO™ missing NPU/GPU

Confirm reboot happened; check /dev/accel/accel0 and clinfo; re-run ./1_install_drivers.sh

torch.xpu.is_available() False

Re-run the swap: ./2_install_software.sh 8

torch version has +cu1xx suffix

CUDA wheels came back (e.g., after a pip install pulled torch) — re-run ./2_install_software.sh 8

conda: command not found

~/miniforge3/bin/conda init bash && source ~/.bashrc

Group membership WARN in verifier

Log out/in (or reboot) so render/video groups apply

For full manual steps, package details, and deeper troubleshooting, see intel-edge-ai-stack-installation-guide.md.