feat: add native Intel XPU (torch.xpu) device support

docs/src/content/docs/start-here/manual.mdx

@@ -105,6 +105,12 @@ The following commands vary depending on the version of Invoke being installed a
               --torch-backend=cu128
               ```
             </TabItem>
+            <TabItem label="Intel Arc GPU">
+              Use:
+              ```sh
+              --torch-backend=xpu
+              ```
+            </TabItem>
             <TabItem label="Other / no GPU">
               Do not use a torch backend.
             </TabItem>
@@ -142,6 +148,12 @@ The following commands vary depending on the version of Invoke being installed a
                 This workaround applies to the reported ROCm case only.
               :::
             </TabItem>
+            <TabItem label="Linux + Intel Arc GPU">
+              Use:
+              ```sh
+              --torch-backend=xpu
+              ```
+            </TabItem>
             <TabItem label="All other cases">
               Do not use a torch backend.
             </TabItem>

docs/src/content/docs/start-here/system-requirements.mdx

@@ -17,6 +17,7 @@ The requirements below are rough guidelines for best performance. GPUs with less
 
 - All Apple Silicon (M1, M2, etc) Macs work, but 16GB+ memory is recommended.
 - AMD GPUs are supported on Linux only. The VRAM requirements are the same as Nvidia GPUs.
+- Intel Arc GPUs (Alchemist, Battlemage and newer) are supported on Windows and Linux `x86_64`. The VRAM requirements are the same as Nvidia GPUs.
 - Linux ARM64 (`aarch64`) devices — e.g. Raspberry Pi 5, other SBCs, ARM servers — are supported in CPU-only mode. Local generation is slow without a GPU, but API-backed models (e.g. GPT Image, Gemini) work well.
 
 ### Windows/Linux
@@ -74,7 +75,34 @@ Check that your system has an up-to-date Python installed by running `python3 --
 
 ## Drivers
 
-If you have an Nvidia or AMD GPU, you may need to manually install drivers or other support packages for things to work well or at all.
+If you have an Nvidia, AMD or Intel GPU, you may need to manually install drivers or other support packages for things to work well or at all.
+
+### Intel
+
+Intel Arc support uses PyTorch's native XPU backend, so no separate oneAPI toolkit install is required — the runtime libraries come in with the `xpu` torch wheels. You do need an up-to-date **GPU driver**.
+
+- **Windows:** install the latest [Intel Arc & Iris Xe Graphics driver]. Older drivers are a common cause of failures on Battlemage cards.
+- **Linux:** install the client GPU driver packages by following the [Intel client GPU install guide]. Kernel 6.8+ (or the `xe`/`i915` backport packages) is required.
+
+Verify the GPU is visible to PyTorch:
+
+```sh
+python -c "import torch; print(torch.xpu.is_available(), torch.xpu.device_count())"
+```
+
+:::note[Integrated GPUs]
+  Level Zero enumerates your CPU's integrated GPU alongside any discrete Arc card. Invoke excludes integrated GPUs from automatic device selection when a discrete GPU is present. To use one anyway, name it explicitly in the `generation_devices` setting.
+
+  An integrated GPU shares its memory with the CPU, so Invoke does not keep a second RAM copy of a model's weights there — that copy would double each model's footprint against the same memory. `keep_ram_copy_of_weights` is ignored on such a device, and a warning says so once. Partial loading still applies, so device residency stays bounded.
+:::
+
+:::note[Both an Nvidia and an Intel GPU?]
+  Automatic device selection prefers CUDA: if any Nvidia GPU is visible, `auto` enumerates only those and your Arc card is left unused. Name it explicitly to generate on it, e.g. `generation_devices: [xpu:0]`.
+:::
+
+:::caution[Free VRAM reporting]
+  Some driver and kernel combinations — notably GPU passthrough VMs and WSL2 — cannot report free VRAM to PyTorch. Invoke falls back to estimating it, which ignores memory used by *other* processes on the same GPU. If you share the GPU with other workloads and hit out-of-memory errors, set `max_cache_vram_gb` explicitly rather than relying on the estimate. A warning is logged once per device when this fallback is in use.
+:::
 
 ### Nvidia
 
@@ -139,5 +167,7 @@ An alternative to installing ROCm locally is to use a [ROCm docker container] to
 [CUDA Toolkit Downloads]: https://developer.nvidia.com/cuda-downloads
 [Cuda Docs]: https://developer.nvidia.com/cudnn
 [cuDNN support matrix]: https://docs.nvidia.com/deeplearning/cudnn/support-matrix/index.html
+[Intel Arc & Iris Xe Graphics driver]: https://www.intel.com/content/www/us/en/download/785597/intel-arc-iris-xe-graphics-windows.html
+[Intel client GPU install guide]: https://dgpu-docs.intel.com/driver/client/overview.html
 [ROCm Documentation]: https://rocmdocs.amd.com
 [ROCm docker container]: https://rocmdocs.amd.com/en/latest/Deep_learning/Deep_learning.html#docker-containers

docs/src/generated/settings.json

@@ -504,7 +504,7 @@
     {
       "category": "DEVICE",
       "default": "auto",
-      "description": "Preferred execution device. `auto` will choose the device depending on the hardware platform and the installed torch capabilities.<br>Valid values: `auto`, `cpu`, `cuda`, `mps`, `cuda:N` (where N is a device number)",
+      "description": "Preferred execution device. `auto` will choose the device depending on the hardware platform and the installed torch capabilities.<br>Valid values: `auto`, `cpu`, `cuda`, `mps`, `xpu`, `cuda:N`, `xpu:N` (where N is a device number)",
       "env_var": "INVOKEAI_DEVICE",
       "literal_values": [],
       "name": "device",
@@ -515,7 +515,7 @@
     {
       "category": "DEVICE",
       "default": "auto",
-      "description": "Devices to use for parallel generation. `auto` (the default) uses every available GPU, running one generation session per GPU concurrently and distributing jobs fairly across users \u2014 unless the legacy `device` setting is pinned to a specific device, in which case `auto` uses only that device (preserving configs that pinned `device` before multi-GPU support existed). Provide an explicit list (e.g. `[cuda:0, cuda:1]`) to use specific devices regardless of `device`, or a single-device list (e.g. `[cuda:0]`) to run serially. On systems without a GPU, `auto` resolves to the single `cpu`/`mps` device.<br>Valid values: `auto`, or a list whose entries are each `cpu`, `cuda`, `mps`, or `cuda:N` (where N is a device number)",
+      "description": "Devices to use for parallel generation. `auto` (the default) uses every available GPU, running one generation session per GPU concurrently and distributing jobs fairly across users \u2014 unless the legacy `device` setting is pinned to a specific device, in which case `auto` uses only that device (preserving configs that pinned `device` before multi-GPU support existed). Provide an explicit list (e.g. `[cuda:0, cuda:1]`) to use specific devices regardless of `device`, or a single-device list (e.g. `[cuda:0]`) to run serially. On systems without a GPU, `auto` resolves to the single `cpu`/`mps` device.<br>Valid values: `auto`, or a list whose entries are each `cpu`, `cuda`, `mps`, `xpu`, `cuda:N`, or `xpu:N` (where N is a device number)",
       "env_var": "INVOKEAI_GENERATION_DEVICES",
       "literal_values": [],
       "name": "generation_devices",

invokeai/app/api/routers/app_info.py

@@ -120,7 +120,7 @@ def _remove_nullable_default_from_schema(schema: dict[str, Any]) -> None:
             schema.update(non_null_schemas[0])
 
 
-_GENERATION_DEVICE_PATTERN = re.compile(r"^(cpu|mps|cuda(:\d+)?)$")
+_GENERATION_DEVICE_PATTERN = re.compile(r"^(cpu|mps|xpu(:\d+)?|cuda(:\d+)?)$")
 
 
 class GenerationDeviceOption(BaseModel):
@@ -163,7 +163,8 @@ def validate_generation_devices(
         for device in v:
             if not _GENERATION_DEVICE_PATTERN.match(device):
                 raise ValueError(
-                    f"Invalid generation device '{device}'. Valid values are 'auto', 'cpu', 'mps', 'cuda', or 'cuda:N'."
+                    f"Invalid generation device '{device}'. Valid values are 'auto', 'cpu', 'mps', 'cuda', 'cuda:N', "
+                    "'xpu', or 'xpu:N'."
                 )
         return v
 
@@ -227,6 +228,14 @@ async def get_generation_device_options(current_user: CurrentUserOrDefault) -> l
             except Exception:
                 name = device
             options.append(GenerationDeviceOption(device=device, name=name))
+    elif hasattr(torch, "xpu") and torch.xpu.is_available():
+        for index in range(torch.xpu.device_count()):
+            device = f"xpu:{index}"
+            try:
+                name = torch.xpu.get_device_name(index)
+            except Exception:
+                name = device
+            options.append(GenerationDeviceOption(device=device, name=name))
     elif torch.backends.mps.is_available():
         options.append(GenerationDeviceOption(device="mps", name="Apple MPS"))
     else:

invokeai/app/invocations/anima_latents_to_image.py

@@ -42,16 +42,31 @@
 
 
 def _is_oom_error(e: RuntimeError) -> bool:
-    """Return True if the error indicates a CUDA out-of-memory condition.
+    """Return True if the error indicates an out-of-memory condition.
 
     The caching allocator raises torch.cuda.OutOfMemoryError, but an OOM surfaced from inside a
     cuDNN/cuBLAS kernel (e.g. workspace allocation in the Wan VAE's convolutions) arrives as a
-    plain RuntimeError, which must be matched by message.
+    plain RuntimeError, which must be matched by message. XPU exhaustion likewise arrives as a
+    plain RuntimeError, naming the Level Zero/UR result code (`..._OUT_OF_DEVICE_MEMORY`) rather
+    than the words "out of memory" -- so it needs its own spelling to be matched here.
+
+    `out_of_host_memory` is knowingly over-broad: Level Zero returns it for driver-side resource
+    failures generally (kernel compilation, handle exhaustion), not only host allocation. Matching
+    it means a genuinely broken decode costs one wasted tiled retry before the error re-raises
+    unchanged. That is preferred over the alternative -- a real host-memory exhaustion that skips
+    the retry -- because the retry is bounded and non-destructive, while a missed OOM fails a
+    generation that would have succeeded tiled.
     """
     if isinstance(e, torch.cuda.OutOfMemoryError):
         return True
-    msg = str(e)
-    return "out of memory" in msg.lower() or "CUDNN_STATUS_ALLOC_FAILED" in msg or "CUBLAS_STATUS_ALLOC_FAILED" in msg
+    msg = str(e).lower()
+    return (
+        "out of memory" in msg
+        or "out_of_device_memory" in msg
+        or "out_of_host_memory" in msg
+        or "cudnn_status_alloc_failed" in msg
+        or "cublas_status_alloc_failed" in msg
+    )
 
 
 @invocation(
@@ -83,9 +98,12 @@ def _use_tiled_decode(device: torch.device, full_decode_working_memory: int) ->
         memory would consume most of the device, otherwise a single-pass decode is
         faster (~0.65s vs ~1.05s at 1024x1024) and exact.
         """
-        if device.type != "cuda":
+        if device.type == "cuda":
+            total_vram = torch.cuda.get_device_properties(device).total_memory
+        elif device.type == "xpu":
+            total_vram = torch.xpu.get_device_properties(device).total_memory
+        else:
             return False
-        total_vram = torch.cuda.get_device_properties(device).total_memory
         return full_decode_working_memory > 0.7 * total_vram
 
     @torch.no_grad()

invokeai/app/invocations/blend_latents.py

@@ -114,7 +114,7 @@ def invoke(self, context: InvocationContext) -> LatentsOutput:
 
         # https://discuss.huggingface.co/t/memory-usage-by-later-pipeline-stages/23699
         blended_latents = blended_latents.to("cpu")
-        torch.cuda.empty_cache()
+        TorchDevice.empty_cache()
 
         name = context.tensors.save(tensor=blended_latents)
         return LatentsOutput.build(latents_name=name, latents=blended_latents)

invokeai/app/invocations/qwen_image_text_encoder.py

@@ -18,6 +18,7 @@
     ConditioningFieldData,
     QwenImageConditioningInfo,
 )
+from invokeai.backend.util.devices import TorchDevice
 
 # Prompt templates and drop indices for the two Qwen Image model modes.
 # These are taken directly from the diffusers pipelines.
@@ -319,6 +320,6 @@ def cleanup():
             nonlocal text_encoder
             del text_encoder
             gc.collect()
-            torch.cuda.empty_cache()
+            TorchDevice.empty_cache()
 
         return text_encoder, device, cleanup

invokeai/app/invocations/wan_latents_to_video.py

@@ -132,19 +132,22 @@ def invoke(self, context: InvocationContext) -> VideoOutput:
         use_tiling = False
         if not getattr(vae_info.config, "cpu_only", None):
             exec_device = TorchDevice.choose_torch_device()
+            total_vram: int | None = None
             if exec_device.type == "cuda":
                 total_vram = torch.cuda.get_device_properties(exec_device).total_memory
-                if estimated_working_memory > 0.9 * total_vram:
-                    use_tiling = True
-                    tile_size = int(getattr(vae_info.model, "tile_sample_min_height", 256))
-                    estimated_working_memory = estimate_vae_working_memory_wan(
-                        operation="decode",
-                        vae=vae_info.model,
-                        pixel_height=h_pixel,
-                        pixel_width=w_pixel,
-                        pixel_frames=t_pixel,
-                        tile_size=tile_size,
-                    )
+            elif exec_device.type == "xpu":
+                total_vram = torch.xpu.get_device_properties(exec_device).total_memory
+            if total_vram is not None and estimated_working_memory > 0.9 * total_vram:
+                use_tiling = True
+                tile_size = int(getattr(vae_info.model, "tile_sample_min_height", 256))
+                estimated_working_memory = estimate_vae_working_memory_wan(
+                    operation="decode",
+                    vae=vae_info.model,
+                    pixel_height=h_pixel,
+                    pixel_width=w_pixel,
+                    pixel_frames=t_pixel,
+                    tile_size=tile_size,
+                )
 
         with vae_info.model_on_device(working_mem_bytes=estimated_working_memory) as (_, vae):
             assert isinstance(vae, AutoencoderKLWan)