Add auto-detection for Intel GPUs

Author: guangyey

crates/uv-torch/src/accelerator.rs

@@ -30,27 +30,34 @@ pub enum Accelerator {
     Amd {
         gpu_architecture: AmdGpuArchitecture,
     },
+    /// The Intel GPU (XPU).
+    ///
+    /// Currently, Intel GPUs do not depend on a driver/toolkit version at this level.
+    Xpu,
 }
 
 impl std::fmt::Display for Accelerator {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             Self::Cuda { driver_version } => write!(f, "CUDA {driver_version}"),
             Self::Amd { gpu_architecture } => write!(f, "AMD {gpu_architecture}"),
+            Self::Xpu => write!(f, "Intel GPU (XPU) detected"),
         }
     }
 }
 
 impl Accelerator {
-    /// Detect the CUDA driver version from the system.
+    /// Detect the GPU driver/architecture version from the system.
     ///
     /// Query, in order:
     /// 1. The `UV_CUDA_DRIVER_VERSION` environment variable.
     /// 2. The `UV_AMD_GPU_ARCHITECTURE` environment variable.
-    /// 2. `/sys/module/nvidia/version`, which contains the driver version (e.g., `550.144.03`).
-    /// 3. `/proc/driver/nvidia/version`, which contains the driver version among other information.
-    /// 4. `nvidia-smi --query-gpu=driver_version --format=csv,noheader`.
-    /// 5. `rocm_agent_enumerator`, which lists the AMD GPU architectures.
+    /// 3. `/sys/module/nvidia/version`, which contains the driver version (e.g., `550.144.03`).
+    /// 4. `/proc/driver/nvidia/version`, which contains the driver version among other information.
+    /// 5. `nvidia-smi --query-gpu=driver_version --format=csv,noheader`.
+    /// 6. `rocm_agent_enumerator`, which lists the AMD GPU architectures.
+    /// 7. `clinfo -l`, which lists the Intel GPU.
+    /// 8. `powershell` command querying `Win32_VideoController` for Intel GPU.
     pub fn detect() -> Result<Option<Self>, AcceleratorError> {
         // Read from `UV_CUDA_DRIVER_VERSION`.
         if let Ok(driver_version) = std::env::var(EnvVars::UV_CUDA_DRIVER_VERSION) {
@@ -150,6 +157,44 @@ impl Accelerator {
             }
         }
 
+        // Query `clinfo -l` to detect the Intel GPU.
+        if let Ok(output) = std::process::Command::new("clinfo").arg("-l").output() {
+            if output.status.success() {
+                let stdout = String::from_utf8(output.stdout)?;
+                if stdout.contains("Intel") {
+                    debug!("Detected Intel GPU from `clinfo` output: {stdout}");
+                    return Ok(Some(Self::Xpu));
+                }
+            } else {
+                debug!(
+                    "Failed to query Intel GPU with `clinfo` with status `{}`: {}",
+                    output.status,
+                    String::from_utf8_lossy(&output.stderr)
+                );
+            }
+        }
+
+        // Query Intel GPU by `powershell` command on Windows.
+        if let Ok(output) = std::process::Command::new("powershell")
+            .arg("-Command")
+            .arg("Get-WmiObject Win32_VideoController | Where-Object { $_.Name -like '*Intel*' } | Select-Object Name, DriverVersion")
+            .output()
+        {
+            if output.status.success() {
+                let stdout = String::from_utf8(output.stdout)?;
+                if stdout.contains("Intel") {
+                    debug!("Detected Intel GPU from powershell output: {stdout}");
+                    return Ok(Some(Self::Xpu));
+                }
+            } else {
+                debug!(
+                    "Failed to query Intel GPU with powershell with status `{}`: {}",
+                    output.status,
+                    String::from_utf8_lossy(&output.stderr)
+                );
+            }
+        }
+
         debug!("Failed to detect GPU driver version");
 
         Ok(None)

crates/uv-torch/src/backend.rs

@@ -185,6 +185,8 @@ pub enum TorchStrategy {
         os: Os,
         gpu_architecture: AmdGpuArchitecture,
     },
+    /// Select the appropriate PyTorch index based on the operating system and Intel GPU presence.
+    Xpu { os: Os },
     /// Use the specified PyTorch index.
     Backend(TorchBackend),
 }
@@ -202,6 +204,7 @@ impl TorchStrategy {
                     os: os.clone(),
                     gpu_architecture,
                 }),
+                Some(Accelerator::Xpu) => Ok(Self::Xpu { os: os.clone() }),
                 None => Ok(Self::Backend(TorchBackend::Cpu)),
             },
             TorchMode::Cpu => Ok(Self::Backend(TorchBackend::Cpu)),
@@ -347,9 +350,26 @@ impl TorchStrategy {
                     Either::Right(Either::Left(std::iter::once(TorchBackend::Cpu.index_url())))
                 }
             },
-            TorchStrategy::Backend(backend) => {
-                Either::Right(Either::Right(std::iter::once(backend.index_url())))
-            }
+            TorchStrategy::Xpu { os } => match os {
+                Os::Manylinux { .. } | Os::Windows => Either::Right(Either::Right(Either::Left(
+                    std::iter::once(TorchBackend::Xpu.index_url()),
+                ))),
+                Os::Musllinux { .. }
+                | Os::Macos { .. }
+                | Os::FreeBsd { .. }
+                | Os::NetBsd { .. }
+                | Os::OpenBsd { .. }
+                | Os::Dragonfly { .. }
+                | Os::Illumos { .. }
+                | Os::Haiku { .. }
+                | Os::Android { .. }
+                | Os::Pyodide { .. } => {
+                    Either::Right(Either::Left(std::iter::once(TorchBackend::Cpu.index_url())))
+                }
+            },
+            TorchStrategy::Backend(backend) => Either::Right(Either::Right(Either::Right(
+                std::iter::once(backend.index_url()),
+            ))),
         }
     }
 }

docs/guides/integration/pytorch.md

@@ -444,7 +444,7 @@ $ # With an environment variable.
 $ UV_TORCH_BACKEND=auto uv pip install torch
 ```
 
-When enabled, uv will query for the installed CUDA driver and AMD GPU versions then use the
+When enabled, uv will query for the installed CUDA driver, AMD GPU versions and Intel GPU presence then use the
 most-compatible PyTorch index for all relevant packages (e.g., `torch`, `torchvision`, etc.). If no
 such GPU is found, uv will fall back to the CPU-only index. uv will continue to respect existing
 index configuration for any packages outside the PyTorch ecosystem.