Add AMD ROCm/HIP support across installer and hardware detection

install.sh

@@ -982,7 +982,58 @@ get_torch_index_url() {
     elif [ -x "/usr/bin/nvidia-smi" ]; then
         _smi="/usr/bin/nvidia-smi"
     fi
-    if [ -z "$_smi" ]; then echo "$_base/cpu"; return; fi
+    if [ -z "$_smi" ]; then
+        # No NVIDIA GPU -- check for AMD ROCm GPU
+        # First confirm an actual AMD GPU is present (not just ROCm tools installed)
+        _has_rocm_gpu=false
+        if command -v rocminfo >/dev/null 2>&1 && \
+           rocminfo 2>/dev/null | awk '/Name:[[:space:]]*gfx[0-9]/{found=1} END{exit !found}'; then
+            _has_rocm_gpu=true
+        elif command -v amd-smi >/dev/null 2>&1 && \
+             amd-smi list 2>/dev/null | awk 'NR>1 && NF{found=1} END{exit !found}'; then
+            _has_rocm_gpu=true
+        fi
+        if [ "$_has_rocm_gpu" != true ]; then
+            echo "$_base/cpu"; return
+        fi
+        # AMD GPU confirmed -- detect ROCm version
+        _rocm_tag=""
+        _rocm_tag=$({ command -v amd-smi >/dev/null 2>&1 && \
+            amd-smi version 2>/dev/null | awk -F'ROCm version: ' \
+                'NF>1{gsub(/[^0-9.]/, "", $2); split($2,a,"."); print "rocm"a[1]"."a[2]; ok=1; exit} END{exit !ok}'; } || \
+            { [ -r /opt/rocm/.info/version ] && \
+                awk -F. '{print "rocm"$1"."$2; exit}' /opt/rocm/.info/version; } || \
+            { command -v hipconfig >/dev/null 2>&1 && \
+                hipconfig --version 2>/dev/null | awk 'NR==1{split($1,a,"."); if(a[1]+0>0) print "rocm"a[1]"."a[2]}'; } || \
+            { command -v dpkg-query >/dev/null 2>&1 && \
+                ver="$(dpkg-query -W -f='${Version}\n' rocm-core 2>/dev/null)" && \
+                [ -n "$ver" ] && \
+                printf '%s\n' "$ver" | sed 's/^[0-9]*://' | awk -F'[.-]' '{print "rocm"$1"."$2; exit}'; } || \
+            { command -v rpm >/dev/null 2>&1 && \
+                ver="$(rpm -q --qf '%{VERSION}\n' rocm-core 2>/dev/null)" && \
+                [ -n "$ver" ] && \
+                printf '%s\n' "$ver" | awk -F'[.-]' '{print "rocm"$1"."$2; exit}'; }) 2>/dev/null
+        # Validate _rocm_tag: must match "rocmX.Y" with major >= 1
+        case "$_rocm_tag" in
+            rocm[1-9]*.[0-9]*) : ;;  # valid (major >= 1)
+            *) _rocm_tag="" ;;        # reject malformed (empty, garbled, or major=0)
+        esac
+        if [ -n "$_rocm_tag" ]; then
+            # ROCm 7.2 only has torch 2.11.0 which exceeds current bounds (<2.11.0).
+            # Fall back to rocm7.1 index which has torch 2.10.0.
+            # TODO: uncomment the next line when torch upper bound is bumped to >=2.11.0
+            # echo "$_base/$_rocm_tag"; return
+            case "$_rocm_tag" in
+                rocm6.*|rocm7.0*|rocm7.1*)
+                    echo "$_base/$_rocm_tag" ;;
+                *)
+                    # ROCm 7.2+ (including future 10.x+): cap to rocm7.1
+                    echo "$_base/rocm7.1" ;;
+            esac
+            return
+        fi
+        echo "$_base/cpu"; return
+    fi
     # Parse CUDA version from nvidia-smi output (POSIX-safe, no grep -P)
     _cuda_ver=$(LC_ALL=C $_smi 2>/dev/null \
         | sed -n 's/.*CUDA Version:[[:space:]]*\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/p' \
@@ -1007,13 +1058,19 @@ case "$TORCH_INDEX_URL" in
     */cpu)
         if [ "$SKIP_TORCH" = false ] && [ "$OS" != "macos" ]; then
             echo ""
-            echo "  NOTE: No NVIDIA GPU detected (nvidia-smi not found)."
+            echo "  NOTE: No GPU detected (nvidia-smi and ROCm not found)."
             echo "  Installing CPU-only PyTorch. If you only need GGUF chat/inference,"
             echo "  re-run with --no-torch for a faster, lighter install:"
             echo "    curl -fsSL https://unsloth.ai/install.sh | sh -s -- --no-torch"
+            echo "  AMD ROCm users: see https://docs.unsloth.ai/get-started/install-and-update/amd"
             echo ""
         fi
         ;;
+    */rocm*)
+        echo ""
+        echo "  AMD ROCm detected -- installing ROCm-enabled PyTorch ($TORCH_INDEX_URL)"
+        echo ""
+        ;;
 esac
 
 # ── Install unsloth directly into the venv (no activation needed) ──
@@ -1051,6 +1108,13 @@ elif [ -n "$TORCH_INDEX_URL" ]; then
         substep "installing PyTorch ($TORCH_INDEX_URL)..."
         run_install_cmd "install PyTorch" uv pip install --python "$_VENV_PY" "torch>=2.4,<2.11.0" torchvision torchaudio \
             --index-url "$TORCH_INDEX_URL"
+        # AMD ROCm: install bitsandbytes with AMD support
+        case "$TORCH_INDEX_URL" in
+            */rocm*)
+                substep "installing bitsandbytes for AMD ROCm..."
+                run_install_cmd "install bitsandbytes (AMD)" uv pip install --python "$_VENV_PY" "bitsandbytes>=0.49.1"
+                ;;
+        esac
     fi
     # Fresh: Step 2 - install unsloth, preserving pre-installed torch
     substep "installing unsloth (this may take a few minutes)..."

studio/backend/utils/hardware/__init__.py

@@ -9,6 +9,7 @@
     DeviceType,
     DEVICE,
     CHAT_ONLY,
+    IS_ROCM,
     detect_hardware,
     get_device,
     is_apple_silicon,
@@ -49,6 +50,7 @@
     "DeviceType",
     "DEVICE",
     "CHAT_ONLY",
+    "IS_ROCM",
     "detect_hardware",
     "get_device",
     "is_apple_silicon",

studio/backend/utils/hardware/hardware.py

@@ -43,6 +43,7 @@ class DeviceType(str, Enum):
 
 DEVICE: Optional[DeviceType] = None
 CHAT_ONLY: bool = True  # No CUDA GPU -> GGUF chat only (Mac, CPU-only, etc.)
+IS_ROCM: bool = False  # True when running on AMD ROCm (HIP) -- display/logging only
 
 
 # ========== Detection ==========
@@ -85,18 +86,28 @@ def detect_hardware() -> DeviceType:
       2. MLX   (Apple Silicon via MLX framework)
       3. CPU   (fallback)
     """
-    global DEVICE, CHAT_ONLY
-    CHAT_ONLY = True  # reset -- only CUDA sets it to False
+    global DEVICE, CHAT_ONLY, IS_ROCM
+    CHAT_ONLY = True  # reset -- only CUDA/ROCm sets it to False
+    IS_ROCM = False
 
-    # --- CUDA: try PyTorch ---
+    # --- CUDA / ROCm: try PyTorch ---
     if _has_torch():
         import torch
 
         if torch.cuda.is_available():
             DEVICE = DeviceType.CUDA
             CHAT_ONLY = False
             device_name = torch.cuda.get_device_properties(0).name
-            print(f"Hardware detected: CUDA — {device_name}")
+
+            # Distinguish AMD ROCm (HIP) from NVIDIA CUDA for display purposes.
+            # DeviceType stays CUDA since torch.cuda.* works on ROCm via HIP.
+            if getattr(torch.version, "hip", None) is not None:
+                IS_ROCM = True
+                print(
+                    f"Hardware detected: ROCm (HIP {torch.version.hip}) -- {device_name}"
+                )
+            else:
+                print(f"Hardware detected: CUDA -- {device_name}")
             return DEVICE
 
     # --- XPU: Intel GPU ---
@@ -315,13 +326,15 @@ def get_package_versions() -> Dict[str, Optional[str]]:
         except PackageNotFoundError:
             versions[name] = None
 
-    # CUDA toolkit version bundled with torch
+    # GPU runtime version bundled with torch
     try:
         import torch
 
         versions["cuda"] = getattr(torch.version, "cuda", None)
+        versions["rocm"] = getattr(torch.version, "hip", None)
     except Exception:
         versions["cuda"] = None
+        versions["rocm"] = None
 
     return versions
 

studio/install_llama_prebuilt.py

@@ -88,6 +88,7 @@ class HostInfo:
     visible_cuda_devices: str | None
     has_physical_nvidia: bool
     has_usable_nvidia: bool
+    has_rocm: bool = False
 
 
 @dataclass
@@ -1430,6 +1431,25 @@ def detect_host() -> HostInfo:
         except Exception:
             pass
 
+    # Detect AMD ROCm (HIP) -- require actual GPU, not just tools installed
+    has_rocm = False
+    if not is_macos:
+        for _cmd, _marker in (
+            (["rocminfo"], "gfx"),
+            (["amd-smi", "list"], "gpu"),
+        ):
+            _exe = shutil.which(_cmd[0])
+            if not _exe:
+                continue
+            try:
+                _result = run_capture([_exe, *_cmd[1:]], timeout = 10)
+            except Exception:
+                continue
+            if _result.returncode == 0 and _result.stdout.strip():
+                if _marker in _result.stdout.lower():
+                    has_rocm = True
+                    break
+
     return HostInfo(
         system = system,
         machine = machine,
@@ -1444,6 +1464,7 @@ def detect_host() -> HostInfo:
         visible_cuda_devices = visible_cuda_devices,
         has_physical_nvidia = has_physical_nvidia,
         has_usable_nvidia = has_usable_nvidia,
+        has_rocm = has_rocm,
     )
 
 
@@ -1724,6 +1745,32 @@ def resolve_linux_cuda_choice(
 def resolve_upstream_asset_choice(host: HostInfo, llama_tag: str) -> AssetChoice:
     upstream_assets = github_release_assets(UPSTREAM_REPO, llama_tag)
     if host.is_linux and host.is_x86_64:
+        # AMD ROCm: try upstream ROCm prebuilt first, then fall back to source build.
+        # Source build (via setup.sh) compiles with -DGGML_HIP=ON and auto-detects
+        # the exact GPU target via rocminfo, which is more reliable for consumer
+        # GPUs (e.g. gfx1151) that may not be in the prebuilt.
+        if host.has_rocm and not host.has_usable_nvidia:
+            rocm_name = f"llama-{llama_tag}-bin-ubuntu-rocm-7.2-x64.tar.gz"
+            if rocm_name in upstream_assets:
+                log(f"AMD ROCm detected -- trying upstream prebuilt {rocm_name}")
+                log(
+                    "Note: prebuilt is compiled for ROCm 7.2; if your ROCm version differs, "
+                    "this may fail preflight and fall back to a source build (safe)"
+                )
+                return AssetChoice(
+                    repo = UPSTREAM_REPO,
+                    tag = llama_tag,
+                    name = rocm_name,
+                    url = upstream_assets[rocm_name],
+                    source_label = "upstream",
+                    install_kind = "linux-rocm",
+                )
+            # No ROCm prebuilt available -- fall back to source build
+            raise PrebuiltFallback(
+                "AMD ROCm detected but no upstream ROCm prebuilt found; "
+                "falling back to source build with HIP support"
+            )
+
         upstream_name = f"llama-{llama_tag}-bin-ubuntu-x64.tar.gz"
         if upstream_name not in upstream_assets:
             raise PrebuiltFallback("upstream Linux CPU asset was not found")
@@ -1743,6 +1790,25 @@ def resolve_upstream_asset_choice(host: HostInfo, llama_tag: str) -> AssetChoice
                 return attempts[0]
             raise PrebuiltFallback("no compatible Windows CUDA asset was found")
 
+        # AMD ROCm on Windows: try HIP prebuilt
+        if host.has_rocm:
+            hip_name = f"llama-{llama_tag}-bin-win-hip-radeon-x64.zip"
+            if hip_name in upstream_assets:
+                log(
+                    f"AMD ROCm detected on Windows -- trying upstream HIP prebuilt {hip_name}"
+                )
+                return AssetChoice(
+                    repo = UPSTREAM_REPO,
+                    tag = llama_tag,
+                    name = hip_name,
+                    url = upstream_assets[hip_name],
+                    source_label = "upstream",
+                    install_kind = "windows-hip",
+                )
+            log(
+                "AMD ROCm detected on Windows but no HIP prebuilt found -- falling back to CPU"
+            )
+
         upstream_name = f"llama-{llama_tag}-bin-win-cpu-x64.zip"
         if upstream_name not in upstream_assets:
             raise PrebuiltFallback("upstream Windows CPU asset was not found")
@@ -2121,7 +2187,7 @@ def overlay_directory_for_choice(
 
 
 def runtime_patterns_for_choice(choice: AssetChoice) -> list[str]:
-    if choice.install_kind in {"linux-cpu", "linux-cuda"}:
+    if choice.install_kind in {"linux-cpu", "linux-cuda", "linux-rocm"}:
         return [
             "llama-server",
             "llama-quantize",
@@ -2131,11 +2197,12 @@ def runtime_patterns_for_choice(choice: AssetChoice) -> list[str]:
             "libmtmd.so*",
             "libggml-cpu-*.so*",
             "libggml-cuda.so*",
+            "libggml-hip.so*",
             "libggml-rpc.so*",
         ]
     if choice.install_kind in {"macos-arm64", "macos-x64"}:
         return ["llama-server", "llama-quantize", "lib*.dylib"]
-    if choice.install_kind in {"windows-cpu", "windows-cuda"}:
+    if choice.install_kind in {"windows-cpu", "windows-cuda", "windows-hip"}:
         return ["*.exe", "*.dll"]
     raise PrebuiltFallback(
         f"unsupported install kind for runtime overlay: {choice.install_kind}"