Make the GPU backend picker vendor-aware (CUDA/Vulkan/Metal/ROCm guidance)

Classify detected GPUs by vendor (NVIDIA/AMD/Intel/Apple) across all
detection paths, add an lspci fallback so AMD/Intel GPUs on Linux are
no longer invisible, and have the llama.cpp backend picker recommend
the right backend for the hardware — CUDA for NVIDIA, Vulkan for
AMD/Intel, Metal for Apple — with an explicit note that native ROCm
means using the Ollama backend (node-llama-cpp ships no ROCm/SYCL
prebuilds).

Author: voidstackloop

app/src/system-specs.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { recommendModels, type SystemSpecs } from "./system-specs";
+import { classifyGpuVendor, recommendModels, type SystemSpecs } from "./system-specs";
 
 function baseSpecs(overrides: Partial<SystemSpecs> = {}): SystemSpecs {
     return {
@@ -16,6 +16,34 @@ function baseSpecs(overrides: Partial<SystemSpecs> = {}): SystemSpecs {
     };
 }
 
+describe("classifyGpuVendor", () => {
+    it("identifies NVIDIA cards by common product names", () => {
+        expect(classifyGpuVendor("NVIDIA GeForce RTX 4070")).toBe("nvidia");
+        expect(classifyGpuVendor("GTX 1660 Super")).toBe("nvidia");
+        expect(classifyGpuVendor("Tesla T4")).toBe("nvidia");
+    });
+
+    it("identifies AMD cards", () => {
+        expect(classifyGpuVendor("AMD Radeon RX 7900 XTX")).toBe("amd");
+        expect(classifyGpuVendor("Radeon Vega 8")).toBe("amd");
+        expect(classifyGpuVendor("Advanced Micro Devices, Inc. [AMD/ATI] Navi 31")).toBe("amd");
+    });
+
+    it("identifies Intel GPUs including integrated graphics", () => {
+        expect(classifyGpuVendor("Intel Arc A770")).toBe("intel");
+        expect(classifyGpuVendor("Intel(R) Iris(R) Xe Graphics")).toBe("intel");
+        expect(classifyGpuVendor("Intel(R) UHD Graphics 630")).toBe("intel");
+    });
+
+    it("identifies Apple GPUs", () => {
+        expect(classifyGpuVendor("Apple M3 Pro")).toBe("apple");
+    });
+
+    it("returns unknown for unrecognized names", () => {
+        expect(classifyGpuVendor("Matrox G200eW")).toBe("unknown");
+    });
+});
+
 describe("recommendModels", () => {
     it("falls back to RAM-based sizing when there's no GPU", () => {
         const result = recommendModels(baseSpecs({ totalRAMGB: 16 }));

app/src/system-specs.ts

@@ -68,6 +68,21 @@ export const MODEL_CATALOG: ModelCatalogEntry[] = [
     { name: "llama3.1:70b", label: "Llama 3.1 70B", minRAMGB: 48, description: "Near top-tier quality, requires a workstation-class PC.", supportsTools: true },
 ];
 
+export type GpuVendor = "nvidia" | "amd" | "intel" | "apple" | "unknown";
+
+// Classifies a GPU by its marketing name — the only identity most detection
+// paths give us (the Windows WMI path and macOS system_profiler report names,
+// not vendor IDs). Drives which llama.cpp backend gets recommended: CUDA is
+// NVIDIA-only, Metal is Apple-only, and AMD/Intel accelerate via Vulkan
+// (node-llama-cpp ships no ROCm/SYCL prebuilds — native ROCm means Ollama).
+export function classifyGpuVendor(name: string): GpuVendor {
+    if (/nvidia|geforce|\brtx\b|\bgtx\b|quadro|tesla/i.test(name)) return "nvidia";
+    if (/\bamd\b|radeon|\brx\s?\d{3,4}\b|vega|firepro|instinct/i.test(name)) return "amd";
+    if (/intel|\barc\b|iris|uhd graphics|hd graphics/i.test(name)) return "intel";
+    if (/apple/i.test(name)) return "apple";
+    return "unknown";
+}
+
 function execFileP(cmd: string, args: string[]): Promise<string | null> {
     return new Promise((resolve) => {
         execFile(cmd, args, { timeout: 3000 }, (err, stdout) => {
@@ -117,7 +132,7 @@ async function detectGpus(): Promise<GpuInfo[]> {
                     gpus.push({
                         name: gpu.Name,
                         vramGB: ramGB > 0 && ramGB < 64 ? +ramGB.toFixed(1) : null,
-                        vendor: "unknown",
+                        vendor: classifyGpuVendor(gpu.Name),
                     });
                 }
                 if (gpus.length > 0) return gpus;
@@ -127,6 +142,23 @@ async function detectGpus(): Promise<GpuInfo[]> {
         }
     }
 
+    // Linux without NVIDIA drivers (AMD/Intel boxes) previously detected
+    // nothing at all — lspci names the display controllers even when no
+    // vendor tooling is installed.
+    if (os.platform() === "linux") {
+        const out = await execFileP("lspci", []);
+        if (out) {
+            const gpus: GpuInfo[] = [];
+            for (const line of out.split("\n")) {
+                if (/VGA compatible controller|3D controller|Display controller/i.test(line)) {
+                    const name = line.split(":").slice(2).join(":").trim();
+                    if (name) gpus.push({ name, vramGB: null, vendor: classifyGpuVendor(name) });
+                }
+            }
+            if (gpus.length > 0) return gpus;
+        }
+    }
+
     if (os.platform() === "darwin") {
         const out = await execFileP("system_profiler", ["SPDisplaysDataType"]);
         if (out) {

frontend/src/lib/gpu.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { recommendGpuBackend, gpuBackendNote } from "./gpu";
+
+describe("recommendGpuBackend", () => {
+    it("recommends CUDA for NVIDIA when CUDA is available", () => {
+        expect(recommendGpuBackend(["nvidia"], ["cuda", "vulkan"])).toBe("cuda");
+    });
+
+    it("falls back to Vulkan for NVIDIA when CUDA is not available", () => {
+        expect(recommendGpuBackend(["nvidia"], ["vulkan"])).toBe("vulkan");
+    });
+
+    it("recommends Vulkan for AMD (no ROCm prebuilds exist)", () => {
+        expect(recommendGpuBackend(["amd"], ["cuda", "vulkan"])).toBe("vulkan");
+    });
+
+    it("recommends Vulkan for Intel", () => {
+        expect(recommendGpuBackend(["intel"], ["vulkan"])).toBe("vulkan");
+    });
+
+    it("recommends Metal for Apple", () => {
+        expect(recommendGpuBackend(["apple"], ["metal"])).toBe("metal");
+    });
+
+    it("tries Vulkan for an unidentified GPU rather than dropping to CPU", () => {
+        expect(recommendGpuBackend(["unknown"], ["vulkan"])).toBe("vulkan");
+    });
+
+    it("recommends CPU when no backend fits", () => {
+        expect(recommendGpuBackend([], [])).toBe("cpu");
+        expect(recommendGpuBackend(["amd"], [])).toBe("cpu");
+    });
+});
+
+describe("gpuBackendNote", () => {
+    it("explains Vulkan for AMD", () => {
+        expect(gpuBackendNote(["amd"])).toBe("amdViaVulkan");
+    });
+
+    it("explains Vulkan for Intel", () => {
+        expect(gpuBackendNote(["intel"])).toBe("intelViaVulkan");
+    });
+
+    it("notes when no GPU was detected", () => {
+        expect(gpuBackendNote([])).toBe("noGpuDetected");
+    });
+
+    it("returns null for NVIDIA/Apple where the default story needs no caveat", () => {
+        expect(gpuBackendNote(["nvidia"])).toBeNull();
+        expect(gpuBackendNote(["apple"])).toBeNull();
+    });
+});

frontend/src/lib/gpu.ts

@@ -0,0 +1,30 @@
+import type { LlamaCppGpuBackend } from "@/types/electron";
+
+// Which llama.cpp backend to suggest for the user's hardware, constrained to
+// the backends node-llama-cpp actually reports as loadable on this machine.
+// CUDA is NVIDIA-only and Metal is Apple-only; AMD and Intel GPUs are served
+// by Vulkan, since node-llama-cpp ships no ROCm or SYCL prebuilt binaries —
+// AMD users who want native ROCm should run those models through Ollama,
+// which supports it directly.
+export function recommendGpuBackend(vendors: string[], available: string[]): LlamaCppGpuBackend {
+    if (vendors.includes("nvidia") && available.includes("cuda")) return "cuda";
+    if (vendors.includes("apple") && available.includes("metal")) return "metal";
+    if ((vendors.includes("nvidia") || vendors.includes("amd") || vendors.includes("intel")) && available.includes("vulkan")) {
+        return "vulkan";
+    }
+    // A GPU we couldn't identify is still better served by trying Vulkan than
+    // silently falling back to CPU-only inference.
+    if (vendors.includes("unknown") && available.includes("vulkan")) return "vulkan";
+    return "cpu";
+}
+
+export type GpuBackendNote = "amdViaVulkan" | "intelViaVulkan" | "noGpuDetected" | null;
+
+// Which explanatory note (if any) the backend picker should show — returned
+// as a symbol rather than display text so the UI can translate it.
+export function gpuBackendNote(vendors: string[]): GpuBackendNote {
+    if (vendors.includes("amd")) return "amdViaVulkan";
+    if (vendors.includes("intel")) return "intelViaVulkan";
+    if (vendors.length === 0) return "noGpuDetected";
+    return null;
+}

frontend/src/lib/translations.ts

@@ -157,6 +157,11 @@ export interface Dictionary {
     gpuBackendHint: string;
     gpuBackendAuto: string;
     gpuBackendCpu: string;
+    gpuRecommended: string;
+    gpuDetected: string;
+    gpuAmdRocmNote: string;
+    gpuIntelVulkanNote: string;
+    gpuNoneDetectedNote: string;
     llamaCppNoModels: string;
     huggingFaceResults: string;
     huggingFaceResultsHint: string;
@@ -441,6 +446,12 @@ export const en: Dictionary = {
     gpuBackendHint: "Only backends detected on this machine are shown as selectable, besides Auto and CPU.",
     gpuBackendAuto: "Auto-detect",
     gpuBackendCpu: "CPU only",
+    gpuRecommended: "Recommended",
+    gpuDetected: "Detected",
+    gpuAmdRocmNote:
+        "AMD GPUs are accelerated through Vulkan here. For native ROCm acceleration, run your models through the Ollama backend instead — it supports ROCm directly.",
+    gpuIntelVulkanNote: "Intel GPUs (Arc and integrated) are accelerated through Vulkan.",
+    gpuNoneDetectedNote: "No GPU detected — inference will run on the CPU.",
     llamaCppNoModels: "No GGUF models downloaded yet — search Hugging Face below and choose \"Download for llama.cpp\".",
     huggingFaceResults: "Hugging Face results",
     huggingFaceResultsHint: "Real search results from huggingface.co — expand a model to see its GGUF files.",
@@ -733,6 +744,12 @@ export const tr: Dictionary = {
     gpuBackendHint: "Otomatik ve CPU dışında yalnızca bu makinede tespit edilen backend'ler seçilebilir olarak gösterilir.",
     gpuBackendAuto: "Otomatik algıla",
     gpuBackendCpu: "Yalnızca CPU",
+    gpuRecommended: "Önerilen",
+    gpuDetected: "Algılanan",
+    gpuAmdRocmNote:
+        "AMD GPU'lar burada Vulkan üzerinden hızlandırılır. Yerel ROCm hızlandırması için modellerinizi ROCm'u doğrudan destekleyen Ollama arka ucu üzerinden çalıştırın.",
+    gpuIntelVulkanNote: "Intel GPU'lar (Arc ve tümleşik) Vulkan üzerinden hızlandırılır.",
+    gpuNoneDetectedNote: "GPU algılanmadı — çıkarım CPU üzerinde çalışacak.",
     llamaCppNoModels: "Henüz indirilmiş GGUF modeli yok — aşağıdan Hugging Face'te arayın ve \"llama.cpp için indir\"i seçin.",
     huggingFaceResults: "Hugging Face sonuçları",
     huggingFaceResultsHint: "huggingface.co'dan gerçek arama sonuçları — GGUF dosyalarını görmek için bir modeli genişletin.",

frontend/src/pages/Settings.tsx

@@ -63,6 +63,7 @@ import type {
     AppActivity,
 } from "@/types/electron";
 import { EXTRA_MODELS } from "@/lib/model-catalog";
+import { recommendGpuBackend, gpuBackendNote } from "@/lib/gpu";
 import {
     DEFAULT_KEYBINDINGS,
     KEYBINDING_ACTIONS,
@@ -868,21 +869,52 @@ export default function Settings() {
                         {settings && (
                             <SettingsSection title={t.llamaCppSection} description={t.llamaCppHint} className="mt-8">
                                 <SettingsRow label={t.gpuBackend} description={t.gpuBackendHint} stacked>
-                                    <Select
-                                        value={settings.llamaCppGpuBackend ?? "auto"}
-                                        onValueChange={(v) => changeLlamaCppGpuBackend(v as LlamaCppGpuBackend)}
-                                    >
-                                        <SelectTrigger size="sm" className="w-48">
-                                            <SelectValue />
-                                        </SelectTrigger>
-                                        <SelectContent>
-                                            <SelectItem value="auto">{t.gpuBackendAuto}</SelectItem>
-                                            {llamaCppGpuBackends.includes("vulkan") && <SelectItem value="vulkan">Vulkan</SelectItem>}
-                                            {llamaCppGpuBackends.includes("cuda") && <SelectItem value="cuda">CUDA</SelectItem>}
-                                            {llamaCppGpuBackends.includes("metal") && <SelectItem value="metal">Metal</SelectItem>}
-                                            <SelectItem value="cpu">{t.gpuBackendCpu}</SelectItem>
-                                        </SelectContent>
-                                    </Select>
+                                    {(() => {
+                                        const vendors = specs?.gpus.map((g) => g.vendor) ?? [];
+                                        const recommended = recommendGpuBackend(vendors, llamaCppGpuBackends);
+                                        const note = gpuBackendNote(vendors);
+                                        const rec = (backend: string, label: string) =>
+                                            backend === recommended ? `${label} (${t.gpuRecommended})` : label;
+                                        return (
+                                            <>
+                                                <Select
+                                                    value={settings.llamaCppGpuBackend ?? "auto"}
+                                                    onValueChange={(v) => changeLlamaCppGpuBackend(v as LlamaCppGpuBackend)}
+                                                >
+                                                    <SelectTrigger size="sm" className="w-56">
+                                                        <SelectValue />
+                                                    </SelectTrigger>
+                                                    <SelectContent>
+                                                        <SelectItem value="auto">{t.gpuBackendAuto}</SelectItem>
+                                                        {llamaCppGpuBackends.includes("cuda") && (
+                                                            <SelectItem value="cuda">{rec("cuda", "CUDA (NVIDIA)")}</SelectItem>
+                                                        )}
+                                                        {llamaCppGpuBackends.includes("vulkan") && (
+                                                            <SelectItem value="vulkan">{rec("vulkan", "Vulkan (NVIDIA / AMD / Intel)")}</SelectItem>
+                                                        )}
+                                                        {llamaCppGpuBackends.includes("metal") && (
+                                                            <SelectItem value="metal">{rec("metal", "Metal (Apple)")}</SelectItem>
+                                                        )}
+                                                        <SelectItem value="cpu">{rec("cpu", t.gpuBackendCpu)}</SelectItem>
+                                                    </SelectContent>
+                                                </Select>
+                                                {specs && specs.gpus.length > 0 && (
+                                                    <p className="text-xs text-muted-foreground">
+                                                        {t.gpuDetected}: {specs.gpus.map((g) => g.name).join(", ")}
+                                                    </p>
+                                                )}
+                                                {note === "amdViaVulkan" && (
+                                                    <p className="text-xs text-muted-foreground">{t.gpuAmdRocmNote}</p>
+                                                )}
+                                                {note === "intelViaVulkan" && (
+                                                    <p className="text-xs text-muted-foreground">{t.gpuIntelVulkanNote}</p>
+                                                )}
+                                                {note === "noGpuDetected" && (
+                                                    <p className="text-xs text-muted-foreground">{t.gpuNoneDetectedNote}</p>
+                                                )}
+                                            </>
+                                        );
+                                    })()}
                                 </SettingsRow>
                                 <SettingsRow label={t.modelsDir} stacked>
                                     <div className="flex flex-wrap items-center gap-2">