Datasets:

AIencoder
/

llama-cpp-wheels

@@ -11,186 +11,223 @@ tags:
   - vulkan
 viewer: false
 ---
-[![Model Pulse](https://modelpulse.ifsp.dev/badge/dataset/AIencoder/llama-cpp-wheels.svg)](https://huggingface.co/spaces/tardellirs/model-pulse?dataset=AIencoder/llama-cpp-wheels)
 # llama-cpp-python Wheels — the complete collection
 Prebuilt [`llama-cpp-python`](https://github.com/abetlen/llama-cpp-python) wheels, gathered to be the
-single most complete place to grab one: **10,000+ wheels** covering **Linux, Windows, and macOS**,
-every published version from `0.1.x` to `0.3.x`, Python **3.7 – 3.14**, and **every backend this
-project can build** — from plain CPU up through AVX-512/AMX, OpenBLAS, MKL, Vulkan, OpenCL, SYCL,
-CLBlast, Metal, and **CUDA 12.1 → 12.9**.
-It combines two things:
 1. **A full mirror of the official upstream wheels** — everything abetlen publishes (`cpu`, `metal`,
-   `cu121`–`cu124`) across every version and OS.
-2. **Thousands of builds upstream never shipped** — produced here by an automated GitHub Actions
-   "wheel factory": newer CUDA versions (12.6 / 12.8 / 12.9), every CPU instruction-set tier, and the
-   OpenBLAS / MKL / Vulkan / OpenCL / SYCL / CLBlast / RPC backends, for the latest releases.
-> **These are self-contained.** CUDA wheels bundle the CUDA runtime, so you only need an NVIDIA
-> **driver** — not the full CUDA toolkit — to use them.
 ---
-## Quick start
-Every wheel is a direct download. Point `pip` at its URL:
-```bash
-pip install "https://huggingface.co/datasets/AIencoder/llama-cpp-wheels/resolve/main/linux/x86_64/cuda12.4/0.3.19/llama_cpp_python-0.3.19+cu124-cp311-cp311-manylinux_2_31_x86_64.whl"
 ```
-Browse the folders (below) to find the one matching your OS, CPU, GPU, Python, and version.
 ---
-## How the collection is organised
-Wheels are nested **`os / arch / backend / version /`**:
-```
-linux/
-  x86_64/
-    cpu/                         ← plain CPU, no special instructions (max compatibility)
-    cpu-avx2-fma-f16c/           ← CPU, AVX2 tier (most modern x86 CPUs)
-    cpu-avx512-fma-f16c-vnni-vbmi-bf16-amx/   ← newest Intel/AMD server CPUs
-    openblas-avx2-fma-f16c/
-    mkl-avx2-fma-f16c/
-    vulkan/  opencl/  clblast/  sycl/  rpc/
-    cuda12.4/  cuda12.6/  cuda12.8/  cuda12.9/
-      0.3.19/
-        llama_cpp_python-0.3.19+cu124-cp311-cp311-manylinux_2_31_x86_64.whl
-        …one per Python version…
-    aarch64/ …     i686/ …
-windows/
-  x86_64/
-    cpu/  cuda12.4/  cuda12.6/  cuda12.8/   (+ upstream-mirrored variants)
-      0.3.19/ …
-macos/
-  arm64/   metal/ …   (Apple Silicon)
-  x86_64/  metal/ …   (Intel Macs)
 ```
-**Why this order:** `os` is the hardest constraint (and a clean 3-way split at the root); `arch`
-keeps `arm64`/`aarch64`/`i686` wheels from being mixed in with `x86_64`; `backend` is the capability
-you actually choose; `version` sits at the leaf, which then holds just the per-Python builds for that
-exact combination. Every leaf folder stays tiny, which also keeps the repo under HuggingFace's hard
-limit of 10,000 files per directory.
-*(Some early wheels may still sit in the repository root during migration — both are valid; use the
-file browser or search.)*
 ---
 ## Choosing the right wheel
-You need to match **four** things. Work down the folder tree:
 ### 1. OS + architecture
-`linux` (manylinux/musllinux), `windows`, or `macos`; then your CPU architecture — `x86_64` (most
-desktops/servers, incl. Windows and Intel Macs), `arm64` (Apple Silicon), or `aarch64` (ARM Linux).
-### 2. Python version
-The `cpXY` tag in the filename is your Python: `cp311` = CPython 3.11. Check with `python --version`.
-Pick the wheel whose `cpXY` matches exactly.
 ### 3. Backend — the important choice
-**CPU (no GPU):** pick the highest instruction tier your CPU supports. Going too high causes an
-`Illegal instruction` crash; too low just runs slower.
-| Folder | Needs | Who it's for |
-|--------|-------|--------------|
-| `cpu` | nothing | oldest CPUs / max compatibility / VMs |
-| `cpu-avx` , `cpu-avx-f16c` | AVX | pre-2013 CPUs |
-| `cpu-avx2-fma-f16c` | AVX2 | **most modern desktops/laptops** |
-| `cpu-avx2-fma-f16c-avxvnni` | AVX2 + VNNI | Alder Lake+ consumer Intel |
-| `cpu-avx512-fma-f16c` | AVX-512 | HEDT / server |
-| `cpu-avx512-…-vnni-vbmi` , `…-bf16-amx` | AVX-512 VNNI/VBMI/BF16/AMX | Sapphire Rapids & newer servers |
-Check your CPU: Linux `lscpu | grep -o 'avx[^ ]*'` · or `pip install py-cpuinfo && python -c "import cpuinfo,pprint; pprint.pp(cpuinfo.get_cpu_info()['flags'])"` on any OS.
-**NVIDIA GPU:** use a `cudaXX.Y` folder. Run `nvidia-smi` — the top-right "CUDA Version: 12.x" is the
-**maximum** your driver supports. Pick a folder with that minor version **or lower** (e.g. driver shows
-12.6 → `cuda12.4` or `cuda12.6` both work; CUDA 12.x is forward-compatible within the 12 series). You
-do **not** need the CUDA toolkit installed — only the driver — because the runtime is bundled.
-**Apple GPU:** `metal` (Apple Silicon and Intel Macs with a Metal GPU).
-**Other accelerators / BLAS:**
-| Folder | What it is |
-|--------|-----------|
-| `openblas-*` | OpenBLAS-accelerated CPU BLAS (faster prompt processing on CPU) |
-| `mkl-*` | Intel MKL BLAS (fastest on Intel CPUs) |
 | `vulkan` | cross-vendor GPU (AMD / Intel / NVIDIA via Vulkan) |
 | `opencl` / `clblast` | OpenCL GPU acceleration (incl. older/mobile GPUs) |
 | `sycl` | Intel GPUs (oneAPI / SYCL) |
 | `rpc` | distributed inference across machines |
 ### 4. Version
-`0.3.19` is the newest release built here; older ones are kept for reproducibility. Newer is usually
-better unless you're pinning for compatibility.
 ---
 ## Filename anatomy
 ```
-llama_cpp_python-0.3.19+cu124-cp311-cp311-manylinux_2_31_x86_64.whl
-                 │      │     │     │     └── platform (manylinux… / win_amd64 / macosx…)
-                 │      │     └─────┴──────── Python (cp311 = CPython 3.11)
-                 │      └── backend tag  (+cu124, +basic_avx2_fma_f16c, +openblas_…, +vulkan; absent = base build)
                  └── llama-cpp-python version
 ```
-The folder name normalises that backend tag into something readable (`cu124` → `cuda12.4`,
 `basic_avx512_fma_f16c_vnni_vbmi` → `cpu-avx512-fma-f16c-vnni-vbmi`).
 ---
-## More install examples
-```bash
-# Linux, modern CPU, no GPU (AVX2):
-pip install "https://huggingface.co/datasets/AIencoder/llama-cpp-wheels/resolve/main/linux/x86_64/cpu-avx2-fma-f16c/0.3.19/llama_cpp_python-0.3.19+basic_avx2_fma_f16c-cp311-cp311-manylinux_2_31_x86_64.whl"
-# Windows, NVIDIA GPU, CUDA 12.6, Python 3.11:
-pip install "https://huggingface.co/datasets/AIencoder/llama-cpp-wheels/resolve/main/windows/x86_64/cuda12.6/0.3.19/llama_cpp_python-0.3.19+cu126-cp311-cp311-win_amd64.whl"
-# macOS Apple Silicon, Metal, Python 3.12:
-pip install "https://huggingface.co/datasets/AIencoder/llama-cpp-wheels/resolve/main/macos/arm64/metal/0.3.4/llama_cpp_python-0.3.4-cp312-cp312-macosx_11_0_arm64.whl"
 ```
-### Programmatic download
 ```python
-from huggingface_hub import hf_hub_download
-path = hf_hub_download(
-    repo_id="AIencoder/llama-cpp-wheels", repo_type="dataset",
-    filename="linux/x86_64/cuda12.4/0.3.19/llama_cpp_python-0.3.19+cu124-cp311-cp311-manylinux_2_31_x86_64.whl",
-)
-# then: pip install <path>
 ```
-List everything with `HfApi().list_repo_files("AIencoder/llama-cpp-wheels", repo_type="dataset")`.
 ---
 ## Coverage
-| | Linux (`x86_64`, plus some `aarch64`/`i686`) | Windows (`x86_64`) | macOS (`arm64` + `x86_64`) |
 |---|---|---|---|
-| **CPU** | plain + every AVX/AVX2/AVX-512 tier up to VNNI·VBMI·BF16·AMX | upstream mirror | upstream mirror |
 | **BLAS** | OpenBLAS, MKL (every tier) | upstream mirror | — |
-| **GPU** | CUDA 12.4 / 12.6 / 12.8 / 12.9, Vulkan, OpenCL, CLBlast, SYCL | CUDA 12.4 / 12.6 / 12.8 | Metal |
 | **Other** | RPC | — | — |
-- **Python:** cp38 – cp314 for factory builds; the upstream mirror goes back to cp37 / PyPy on old versions.
-- **Versions:** factory builds target 0.3.16 – 0.3.19; the mirror covers the full history (0.1.x → 0.3.x).
-- **Totals:** 10,000+ wheels and growing. The upstream mirror targets all ~6,800 official wheels; the
-  factory adds several thousand more that upstream never produced.
 ---
@@ -198,31 +235,34 @@ List everything with `HfApi().list_repo_files("AIencoder/llama-cpp-wheels", repo
 The non-mirror wheels are compiled automatically by a GitHub Actions "factory":
-- **No GPU required to build** — `nvcc` cross-compiles the CUDA kernels on ordinary CPU runners.
 - Built from the official `abetlen/llama-cpp-python` source at the exact tagged version.
-- **Self-contained:** Linux wheels are `auditwheel`-repaired; Windows CUDA wheels bundle the CUDA
-  runtime DLLs (`cudart`, `cublas`, `cublasLt`) next to `llama.dll`. You need only the GPU driver.
-- Each wheel is installed and structurally verified (dependency tree checked) before upload.
-- The build queue is **derived** by diffing this dataset against the target matrix, so the collection
-  fills in and stays current on its own.
 ---
-## Caveats & troubleshooting
-- **`Could not find module 'llama.dll' (or one of its dependencies)` (Windows CUDA):** you don't have an
-  NVIDIA driver installed, or it's too old for the CUDA minor version you picked. Install/update the
-  driver, or drop to a lower `cudaXX.Y` folder.
-- **`Illegal instruction` on import (CPU):** the wheel's instruction tier is higher than your CPU
-  supports. Use a lower `cpu-…` folder (when unsure, plain `cpu`).
-- **CUDA wheels are large** (~0.6 – 1.3 GB): expected — they bundle the runtime and the fat multi-arch
-  CUDA kernels, which is exactly what lets them run without a separate CUDA install.
-- **GPU wheels can't be import-tested without a GPU** — that's normal; the build verifies structure, not
-  a live GPU load.
 - Community builds, provided **as-is** under the same **MIT** license as llama-cpp-python.
 ---
 *Maintained by [AIencoder](https://huggingface.co/AIencoder). Wheels are builds of
-[abetlen/llama-cpp-python](https://github.com/abetlen/llama-cpp-python); all credit for llama-cpp-python
-and llama.cpp to their authors.*

   - vulkan
 viewer: false
 ---
 # llama-cpp-python Wheels — the complete collection
+[![Model Pulse](https://modelpulse.ifsp.dev/badge/dataset/AIencoder/llama-cpp-wheels.svg)](https://huggingface.co/spaces/tardellirs/model-pulse?dataset=AIencoder/llama-cpp-wheels)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 Prebuilt [`llama-cpp-python`](https://github.com/abetlen/llama-cpp-python) wheels, gathered to be the
+single most complete place to grab one: **over 11,400 wheels and growing**, covering **Linux, Windows,
+and macOS**, every published release from `0.1.x` through `0.3.36`, and **every backend the project can
+build** — plain CPU up through AVX-512 / AMX, OpenBLAS, MKL, Vulkan, OpenCL, CLBlast, SYCL, RPC, Metal,
+and **CUDA 12.1 → 12.9**.
+It is two things in one repo:
 1. **A full mirror of the official upstream wheels** — everything abetlen publishes (`cpu`, `metal`,
+   and `cu121`–`cu125`), across every version and OS, back to the early `0.1.x` releases.
+2. **Thousands of builds upstream never shipped** — produced here by an automated GitHub Actions "wheel
+   factory": newer CUDA toolkits (**12.6 / 12.8 / 12.9**), every CPU instruction-set tier, and the
+   OpenBLAS / MKL / Vulkan / OpenCL / CLBlast / SYCL / RPC backends, built for the **whole 0.3.x series**.
+> **Self-contained.** CUDA wheels bundle the CUDA runtime — you only need an NVIDIA **driver** installed,
+> not the full CUDA toolkit.
 ---
+## At a glance
+| | |
+|---|---|
+| **Wheels** | 11,400+ and climbing |
+| **OSes** | Linux (`manylinux`/`musllinux`), Windows (`win_amd64`), macOS (`arm64` + `x86_64`) |
+| **Versions** | full history `0.1.x` → `0.3.36` |
+| **Python** | `cp37`–`cp314` + PyPy on older releases; a single `py3-none` wheel per platform from `0.3.20` on (see below) |
+| **CPU** | `basic` → `avx` → `avx2` → `avx512` → `…vnni/vbmi/bf16/amx`, plus OpenBLAS & MKL at every tier |
+| **GPU** | CUDA **12.1 – 12.9**, Vulkan, OpenCL, CLBlast, SYCL, Metal |
+| **License** | MIT (same as llama-cpp-python) |
+---
+## ⚠️ One thing that trips people up: `py3-none` wheels (v0.3.20+)
+Starting at **v0.3.20**, llama-cpp-python's bindings load the compiled library through `ctypes` — there is
+no CPython ABI to vary — so upstream (and this repo) ship **one version-agnostic wheel per platform**
+instead of one per Python version. That wheel is tagged **`py3-none`** and works on **any** CPython 3.x
+(and PyPy):
+```
+llama_cpp_python-0.3.36+cu124_basic-py3-none-manylinux_2_31_x86_64.whl   ← one wheel, every Python
 ```
+For releases **≤ 0.3.19** you still pick the wheel whose `cpXY` tag matches your Python:
+```
+llama_cpp_python-0.3.19+cu124-cp311-cp311-manylinux_2_31_x86_64.whl      ← cp311 = CPython 3.11
+```
+So: **new versions → ignore Python, just match OS + backend. Old versions → also match `cpXY`.**
 ---
+## Quick start
+Every wheel is a plain file you can `pip install` from its URL. The most robust way to grab the right one
+(works no matter how the folders are arranged) is to let `huggingface_hub` find it by a substring and
+install it:
+```python
+# pip install huggingface_hub
+from huggingface_hub import HfApi, hf_hub_download
+import subprocess, sys
+REPO = "AIencoder/llama-cpp-wheels"
+WANT = "0.3.36+cu124"          # version + backend you want
+PLAT = "manylinux"             # "manylinux" | "win_amd64" | "macosx"
+f = next(p for p in HfApi().list_repo_files(REPO, repo_type="dataset")
+         if p.endswith(".whl") and WANT in p and PLAT in p)
+whl = hf_hub_download(REPO, f, repo_type="dataset")
+subprocess.run([sys.executable, "-m", "pip", "install", whl])
 ```
+Prefer a direct `pip install`? Open the **Files** tab, find your wheel, copy its download link, and:
+```bash
+pip install "https://huggingface.co/datasets/AIencoder/llama-cpp-wheels/resolve/main/<path-to>/<wheel>.whl"
+```
 ---
 ## Choosing the right wheel
+Match **four** things — OS, (Python), backend, version:
 ### 1. OS + architecture
+`linux` (manylinux/musllinux), `windows` (`win_amd64`), or `macos`; then your CPU architecture —
+`x86_64` (most desktops/servers, incl. Windows and Intel Macs), `arm64` (Apple Silicon), or
+`aarch64` (ARM Linux).
+### 2. Python — only for releases ≤ 0.3.19
+Releases `0.3.20+` are `py3-none` (one wheel, any Python — skip this step). For older releases, match the
+`cpXY` tag to your interpreter: `cp311` = CPython 3.11 (`python --version`).
 ### 3. Backend — the important choice
+**CPU (no GPU).** Pick the highest instruction tier your CPU supports. Too high → `Illegal instruction`
+on import; too low → just slower.
+| Backend tag | Needs | Who it's for |
+|---|---|---|
+| `basic` | nothing | oldest CPUs / VMs / max compatibility |
+| `basic_avx`, `basic_avx_f16c` | AVX | pre-2013 CPUs |
+| `basic_avx2_fma_f16c` | AVX2 | **most modern desktops/laptops** |
+| `basic_avx2_fma_f16c_avxvnni` | AVX2 + VNNI | Alder Lake+ consumer Intel |
+| `basic_avx512_fma_f16c` | AVX-512 | HEDT / server |
+| `…_avx512_fma_f16c_vnni_vbmi`, `…_bf16_amx` | AVX-512 VNNI/VBMI/BF16/AMX | Sapphire Rapids & newer servers |
+Check your CPU: Linux `lscpu | grep -o 'avx[^ ]*'`; any OS `pip install py-cpuinfo && python -c "import cpuinfo;print(cpuinfo.get_cpu_info()['flags'])"`.
+**NVIDIA GPU.** Use a `cu1XY` wheel. Run `nvidia-smi`; the "CUDA Version: 12.x" shown top-right is the
+**maximum** your driver supports — pick that minor **or lower** (CUDA 12.x is forward-compatible within the
+12 series, so a 12.6 driver runs `cu121`…`cu126`). You need only the **driver**, not the toolkit.
+**Apple GPU.** `metal` (Apple Silicon and Intel Macs with a Metal GPU).
+**Other accelerators / BLAS.**
+| Tag | What it is |
+|---|---|
+| `openblas_*` | OpenBLAS CPU BLAS (faster prompt processing) |
+| `mkl_*` | Intel MKL BLAS (fastest on Intel CPUs) |
 | `vulkan` | cross-vendor GPU (AMD / Intel / NVIDIA via Vulkan) |
 | `opencl` / `clblast` | OpenCL GPU acceleration (incl. older/mobile GPUs) |
 | `sycl` | Intel GPUs (oneAPI / SYCL) |
 | `rpc` | distributed inference across machines |
 ### 4. Version
+`0.3.36` is the newest built here; everything older is kept for reproducibility. Newer is usually better
+unless you're pinning for compatibility.
 ---
 ## Filename anatomy
 ```
+llama_cpp_python-0.3.36+cu124_basic-py3-none-manylinux_2_31_x86_64.whl
+                 │      │            │        └── platform (manylinux… / win_amd64 / macosx…)
+                 │      │            └── Python: py3-none (any Python, v0.3.20+) or cpXY-cpXY (≤0.3.19)
+                 │      └── backend tag (+cu124_basic, +basic_avx2_fma_f16c, +openblas_…, +vulkan, +metal; absent = plain CPU/upstream base)
                  └── llama-cpp-python version
 ```
+The backend tag is normalised into the readable folder names below (`cu124` → `cuda12.4`,
 `basic_avx512_fma_f16c_vnni_vbmi` → `cpu-avx512-fma-f16c-vnni-vbmi`).
 ---
+## How the collection is organised
+Wheels are being filed under **`os / arch / backend / version /`**:
+```
+linux/
+  x86_64/
+    cpu/                         ← plain CPU (max compatibility)
+    cpu-avx2-fma-f16c/           ← AVX2 tier (most modern x86)
+    cpu-avx512-fma-f16c-vnni-vbmi-bf16-amx/   ← newest Intel/AMD servers
+    openblas-avx2-fma-f16c/   mkl-avx2-fma-f16c/
+    vulkan/  opencl/  clblast/  sycl/  rpc/
+    cuda12.4/  cuda12.6/  cuda12.8/  cuda12.9/
+      0.3.36/
+        llama_cpp_python-0.3.36+cu124_basic-py3-none-manylinux_2_31_x86_64.whl
+        …+cu124_avx2_fma_f16c…, …+cu124_avx512_fma_f16c…   (CPU baseline is in the filename)
+    aarch64/ …     i686/ …
+windows/
+  x86_64/
+    cpu/  cuda12.4/  cuda12.6/  cuda12.8/   (+ upstream-mirrored variants)
+      0.3.36/ …
+macos/
+  arm64/   metal/ …   (Apple Silicon)
+  x86_64/  metal/ …   (Intel Macs)
 ```
+**Why this order:** `os` is the hardest constraint (a clean 3-way split); `arch` keeps `arm64`/`aarch64`/
+`i686` from mixing with `x86_64`; `backend` is the capability you actually choose; `version` is the leaf,
+so each leaf folder holds only a handful of wheels and never approaches HuggingFace's 10,000-files-per-dir
+limit. CPU wheels split by instruction tier (their primary axis); CUDA wheels group by toolkit version
+(their primary axis) with the CPU baseline carried in the filename.
+> **Migration in progress.** The reorganisation into this tree is still running. Many wheels (especially
+> upstream-mirrored and `≤0.3.19` builds) currently sit at the repository **root**, and the newest builds
+> under a `version/` folder. Everything is valid and installable wherever it sits — the `huggingface_hub`
+> snippet above and the **Files** tab search find a wheel regardless of its folder.
+### Programmatic listing
 ```python
+from huggingface_hub import HfApi
+files = HfApi().list_repo_files("AIencoder/llama-cpp-wheels", repo_type="dataset")
+cu124 = [f for f in files if f.endswith(".whl") and "+cu124" in f]
 ```
 ---
 ## Coverage
+| | Linux (`x86_64`, some `aarch64`/`i686`) | Windows (`x86_64`) | macOS (`arm64` + `x86_64`) |
 |---|---|---|---|
+| **CPU** | plain + every AVX/AVX2/AVX-512 tier to VNNI·VBMI·BF16·AMX | upstream mirror | upstream mirror |
 | **BLAS** | OpenBLAS, MKL (every tier) | upstream mirror | — |
+| **GPU** | CUDA 12.4/12.6/12.8/12.9, Vulkan, OpenCL, CLBlast, SYCL | CUDA 12.4/12.6/12.8 | Metal |
 | **Other** | RPC | — | — |
+- **Python:** `py3-none` (one wheel, any Python) for `0.3.20+`; `cp38`–`cp314` for the factory's `≤0.3.19`
+  builds; the upstream mirror reaches back to `cp37` / PyPy on old releases.
+- **Versions:** the factory builds the **entire `0.3.0`–`0.3.36` series**; the mirror covers the full
+  history (`0.1.x` → `0.3.x`).
+- **CUDA span:** `cu121`–`cu125` from the upstream mirror, plus `cu124`/`cu126`/`cu128`/`cu129` built here.
 ---
 The non-mirror wheels are compiled automatically by a GitHub Actions "factory":
+- **No GPU required to build** — `nvcc` cross-compiles the CUDA kernels on ordinary CPU runners, for GPU
+  architectures `sm_50`–`sm_90` (Maxwell through Hopper).
 - Built from the official `abetlen/llama-cpp-python` source at the exact tagged version.
+- **Self-contained:** Linux wheels are `auditwheel`-repaired; Windows CUDA wheels bundle the CUDA runtime
+  DLLs next to `llama.dll`. You need only the GPU driver.
+- Each wheel is installed and its import is exercised (with the CUDA driver stub, so a GPU-less runner still
+  loads it) before upload — catching missing runtime deps and bad symbols, not just a successful compile.
+- The build queue is **derived** by diffing this dataset against the target matrix every run, so the
+  collection fills in and stays current on its own.
 ---
+## Troubleshooting
+- **`Could not find module 'llama.dll' (or one of its dependencies)` (Windows CUDA)** — no NVIDIA driver, or
+  it's too old for the CUDA minor you picked. Install/update the driver, or drop to a lower `cu1XY` wheel.
+- **`libcuda.so.1: cannot open shared object file` (Linux CUDA)** — same thing: install the NVIDIA driver
+  (the wheel bundles the *runtime* but never the driver), or pick a lower CUDA minor.
+- **`Illegal instruction` on import (CPU)** — the wheel's instruction tier is above what your CPU supports.
+  Use a lower `cpu-…` tier (when unsure, plain `cpu`).
+- **CUDA wheels are large (~0.5 – 3 GB)** — expected: they bundle the runtime and fat multi-arch kernels,
+  which is exactly what lets them run with no separate CUDA install.
+- **GPU wheels can't be import-tested on a GPU-less machine beyond structure** — normal; a real GPU load is
+  only exercised at model-load time on your hardware.
 - Community builds, provided **as-is** under the same **MIT** license as llama-cpp-python.
 ---
 *Maintained by [AIencoder](https://huggingface.co/AIencoder). Wheels are builds of
+[abetlen/llama-cpp-python](https://github.com/abetlen/llama-cpp-python); all credit for llama-cpp-python and
+llama.cpp to their authors.*