pinokiod 7.5.14 → 7.5.15

package/kernel/gpu/amd.js

@@ -1,4 +1,19 @@
 const { normalize_model } = require("./common")
+const amd_gfx_targets = require("./amd_gfx_targets.json")
+
+const canonical_model_key = (model) => {
+  let key = normalize_model(model)
+  let previous
+  do {
+    previous = key
+    key = key
+      .replace(/^advanced micro devices\s+/, "")
+      .replace(/^amd\s+/, "")
+      .replace(/^instinct\s+/, "")
+      .trim()
+  } while (key !== previous)
+  return key
+}
 
 // Detect uninformative AMD APU names that need CPU-brand fallback matching.
 const is_generic_gpu_model = (model) => {
@@ -15,58 +30,30 @@ const resolve_cpu_brand = async (cpu_brand) => {
   }
 }
 
-// Match AMD GPU model names that Pinokio should route to PyTorch ROCm wheels.
-const matches_rocm_torch_model = (model) => {
-  let normalized = normalize_model(model)
-
-  // AMD PyTorch ROCm install policy. These checks are based on the
-  // hardware families Pinokio should route to ROCm-flavored PyTorch wheels,
-  // not on whether ROCm is already installed on the machine.
-
-  // Radeon RX 7600+:
-  // - RX 7600 / 7600 XT / 7600M / 7600M XT
-  // - RX 7700 / 7800 / 7900 families
-  // - RX 9000 families such as RX 9060 and RX 9070
-  // - Future RX 8xxx/9xxx names are treated as ROCm-intended by policy.
-  let rx = normalized.match(/\brx\s*([7-9]\d{3})(?!\d)/)
-  if (rx && Number(rx[1]) >= 7600) {
-    return true
+const resolve_rocm_gfx_target = (model) => {
+  let key = canonical_model_key(model)
+  if (/^gfx[0-9a-f]+$/i.test(key)) {
+    return key.toLowerCase()
   }
-
-  // Radeon PRO W7700+:
-  // - PRO W7700 / W7800 / W7900
-  // - Future PRO W 8xxx/9xxx names are treated as ROCm-intended by policy.
-  let pro = normalized.match(/\bpro\s*w\s*([7-9]\d{3})(?!\d)/)
-  if (pro && Number(pro[1]) >= 7700) {
-    return true
+  if (amd_gfx_targets.entries[key]) {
+    return amd_gfx_targets.entries[key]
   }
 
-  return (
-    // Radeon PRO V710
-    /\bpro\s*v\s*710\b/.test(normalized) ||
-    // Radeon AI PRO R9600/R9700 variants, including suffixes like R9700S.
-    /\bai\s*pro\s*r\s*9[67]\d{2}[a-z]?\b/.test(normalized) ||
-    // Supported APUs and codenames seen in PyTorch ROCm wheel support.
-    /\b(780m|820m|880m|890m|8050s|8060s|strix|phoenix|fire range)\b/.test(normalized)
-  )
+  return null
 }
 
-// Decide AMD ROCm install intent, using CPU brand only for generic APU GPU names.
-const supports_torch_backend = async (model, cpu_brand) => {
-  if (matches_rocm_torch_model(model)) {
-    return true
+const resolve_gpu_target = async (model, cpu_brand) => {
+  let target = resolve_rocm_gfx_target(model)
+  if (target) {
+    return target
   }
   if (!is_generic_gpu_model(model)) {
-    return false
+    return null
   }
-  // APU-only systems can report the GPU as just "AMD Radeon Graphics".
-  // In that generic case, use the CPU brand as a fallback because it often
-  // includes the Radeon model or codename, such as 8060S or Strix Halo.
-  return matches_rocm_torch_model(await resolve_cpu_brand(cpu_brand))
+  return resolve_rocm_gfx_target(await resolve_cpu_brand(cpu_brand))
 }
 
 module.exports = {
-  is_generic_gpu_model,
-  matches_rocm_torch_model,
-  supports_torch_backend
+  resolve_gpu_target,
+  resolve_rocm_gfx_target
 }

package/kernel/gpu/amd_gfx_targets.json

@@ -0,0 +1,67 @@
+{
+  "source": "https://raw.githubusercontent.com/ROCm/ROCm/develop/docs/reference/gpu-arch-specs.rst",
+  "generated_by": "script/update-amd-gfx-targets.js",
+  "entries": {
+    "mi100": "gfx908",
+    "mi210": "gfx90a",
+    "mi25": "gfx900",
+    "mi250": "gfx90a",
+    "mi250x": "gfx90a",
+    "mi300a": "gfx942",
+    "mi300x": "gfx942",
+    "mi325x": "gfx942",
+    "mi350x": "gfx950",
+    "mi355x": "gfx950",
+    "mi50 16gb": "gfx906",
+    "mi50 32gb": "gfx906",
+    "mi6": "gfx803",
+    "mi60": "gfx906",
+    "mi8": "gfx803",
+    "radeon 780m": "gfx1103",
+    "radeon 8060s": "gfx1151",
+    "radeon 860m": "gfx1152",
+    "radeon 890m": "gfx1150",
+    "radeon ai pro r9600d": "gfx1201",
+    "radeon ai pro r9700": "gfx1201",
+    "radeon pro v620": "gfx1030",
+    "radeon pro v710": "gfx1101",
+    "radeon pro vii": "gfx906",
+    "radeon pro w5500": "gfx1012",
+    "radeon pro w6600": "gfx1032",
+    "radeon pro w6800": "gfx1030",
+    "radeon pro w7700": "gfx1101",
+    "radeon pro w7800": "gfx1100",
+    "radeon pro w7800 48gb": "gfx1100",
+    "radeon pro w7900": "gfx1100",
+    "radeon pro w7900 dual slot": "gfx1100",
+    "radeon rx 6600": "gfx1032",
+    "radeon rx 6600 xt": "gfx1032",
+    "radeon rx 6650 xt": "gfx1032",
+    "radeon rx 6700": "gfx1031",
+    "radeon rx 6700 xt": "gfx1031",
+    "radeon rx 6750 xt": "gfx1031",
+    "radeon rx 6800": "gfx1030",
+    "radeon rx 6800 xt": "gfx1030",
+    "radeon rx 6900 xt": "gfx1030",
+    "radeon rx 6950 xt": "gfx1030",
+    "radeon rx 7600": "gfx1102",
+    "radeon rx 7700": "gfx1101",
+    "radeon rx 7700 xt": "gfx1101",
+    "radeon rx 7800 xt": "gfx1101",
+    "radeon rx 7900 gre": "gfx1100",
+    "radeon rx 7900 xt": "gfx1100",
+    "radeon rx 7900 xtx": "gfx1100",
+    "radeon rx 9060": "gfx1200",
+    "radeon rx 9060 xt": "gfx1200",
+    "radeon rx 9060 xt lp": "gfx1200",
+    "radeon rx 9070": "gfx1201",
+    "radeon rx 9070 gre": "gfx1201",
+    "radeon rx 9070 xt": "gfx1201",
+    "radeon vii": "gfx906",
+    "ryzen 7 7840u": "gfx1103",
+    "ryzen 9 270": "gfx1103",
+    "ryzen ai 9 hx 375": "gfx1150",
+    "ryzen ai max pro 395": "gfx1151",
+    "ryzen al 7 350": "gfx1152"
+  }
+}

package/kernel/gpu/nvidia.js

@@ -1,8 +1,94 @@
-// NVIDIA routes to CUDA PyTorch wheels on supported non-macOS platforms.
-const supports_torch_backend = (controller, platform) => {
-  return !!controller && platform !== "darwin"
+const { execFile } = require("node:child_process")
+
+const NVIDIA_SMI_COMPUTE_CAP_ARGS = [
+  "--query-gpu=pci.bus_id,compute_cap",
+  "--format=csv,noheader,nounits"
+]
+
+let cuda_sm_targets_promise = null
+
+const normalize_pci_bus = (bus) => {
+  let normalized = String(bus || "").trim().toLowerCase()
+  let match = /(?:[0-9a-f]{4,8}:)?([0-9a-f]{2}:[0-9a-f]{2}\.[0-7])$/.exec(normalized)
+  return match ? match[1] : normalized
+}
+
+const compute_cap_to_sm_target = (compute_cap) => {
+  let match = /^(\d+)\.(\d+)$/.exec(String(compute_cap || "").trim())
+  return match ? `sm_${match[1]}${match[2]}` : null
+}
+
+const parse_nvidia_smi_compute_caps = (stdout) => {
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      let parts = line.split(",").map((part) => part.trim())
+      if (parts.length < 2) return null
+      let target = compute_cap_to_sm_target(parts[1])
+      if (!target) return null
+      return {
+        pci_bus: normalize_pci_bus(parts[0]),
+        target
+      }
+    })
+    .filter(Boolean)
+}
+
+const query_cuda_sm_targets = (exec_file = execFile) => {
+  return new Promise((resolve) => {
+    exec_file(
+      "nvidia-smi",
+      NVIDIA_SMI_COMPUTE_CAP_ARGS,
+      { windowsHide: true, timeout: 5000 },
+      (error, stdout) => {
+        if (error) {
+          resolve([])
+        } else {
+          resolve(parse_nvidia_smi_compute_caps(stdout))
+        }
+      }
+    )
+  })
+}
+
+const cached_cuda_sm_targets = () => {
+  if (!cuda_sm_targets_promise) {
+    cuda_sm_targets_promise = query_cuda_sm_targets()
+  }
+  return cuda_sm_targets_promise
+}
+
+const select_cuda_sm_target = (controller, records) => {
+  let targets = Array.isArray(records) ? records : []
+  if (targets.length === 0) {
+    return null
+  }
+
+  let controller_bus = normalize_pci_bus(controller && (controller.pciBus || controller.busAddress))
+  if (controller_bus) {
+    let match = targets.find((record) => record.pci_bus === controller_bus)
+    if (match) {
+      return match.target
+    }
+  }
+
+  return targets.length === 1 ? targets[0].target : null
+}
+
+const resolve_cuda_sm_target = async (controller) => {
+  if (!controller) {
+    return null
+  }
+  let records = await cached_cuda_sm_targets()
+  return select_cuda_sm_target(controller, records)
 }
 
 module.exports = {
-  supports_torch_backend
+  compute_cap_to_sm_target,
+  parse_nvidia_smi_compute_caps,
+  query_cuda_sm_targets,
+  resolve_cuda_sm_target,
+  select_cuda_sm_target
 }

package/kernel/index.js

@@ -92,10 +92,10 @@ class Kernel {
     this.pinokio_configs = {}
     this.shellpath = shellPath.sync()
     this.favicon = new Favicon()
-    this.torch_backend = "cpu"
     this.vram = 0
     this.ram = 0
     this.gpu_driver = null
+    this.gpu_target = null
     this.readyState = new ReadyState(this)
     this.app_ready_status = this.readyState.status
     this.launchRequirements = new LaunchRequirements(this)
@@ -824,6 +824,7 @@ class Kernel {
       procs: this.procs,
       gpu: this.gpu,
       gpus: this.gpus,
+      gpu_target: this.gpu_target,
       ...info
     }
 
@@ -1152,7 +1153,7 @@ class Kernel {
           system,
           platform: this.platform,
           arch: this.arch,
-          torch_backend: this.torch_backend,
+          gpu_target: this.gpu_target,
           vram: this.vram,
           ram: this.ram,
           proxy: (port) => {
@@ -1349,7 +1350,7 @@ class Kernel {
         this.gpu = info.gpu
         this.gpu_model = info.gpu_model
         this.gpu_driver = info.gpu_driver || null
-        this.torch_backend = info.torch_backend || "cpu"
+        this.gpu_target = info.gpu_target || null
         this.gpus = info.gpus
         this.vram = typeof info.vram === "number" ? info.vram : 0
         this.ram = typeof info.ram === "number" ? info.ram : 0

package/kernel/sysinfo.js

@@ -3,8 +3,6 @@ const fs = require('fs')
 const path = require('path')
 const nvidia = require("./gpu/nvidia")
 const amd = require("./gpu/amd")
-const apple = require("./gpu/apple")
-const intel = require("./gpu/intel")
 class Sysinfo {
   async init(kernel) {
     this.kernel = kernel
@@ -74,7 +72,6 @@ class Sysinfo {
     let is_nvidia = controllers.find(x => /nvidia/i.test(x.vendor || ""))
     let is_amd = bestByVram(controllers.filter(x => /(amd|advanced micro devices)/i.test(x.vendor || "")))
     let is_apple = controllers.find(x => /apple/i.test(x.vendor || ""))
-    let is_intel = controllers.find(x => /intel/i.test(x.vendor || ""))
 
     let gpu
     let gpu_model
@@ -108,14 +105,22 @@ class Sysinfo {
     let vramMB = primaryController && primaryController.vram ? primaryController.vram : 0
     let vramGB = vramMB > 0 ? Math.round(vramMB / 1024) : 0
     let gpu_driver = driver(primaryController)
-    let torch_backend = await this.torch_backend({ is_nvidia, is_amd, is_apple, is_intel, gpu_model })
+    let cpu_brand_value
+    let cpu_brand = async () => {
+      if (cpu_brand_value === undefined) {
+        cpu_brand_value = await this.cpu_brand()
+      }
+      return cpu_brand_value
+    }
+    let detected = { is_nvidia, is_amd, gpu_model, primaryController, cpu_brand }
+    let gpu_target = await this.gpu_target(detected)
 
     this.info.graphics = g
     this.info.gpus = gpus
     this.info.gpu = gpu
     this.info.gpu_model = gpu_model
     this.info.gpu_driver = gpu_driver
-    this.info.torch_backend = torch_backend
+    this.info.gpu_target = gpu_target
     this.info.vram = vramGB
   }
   // Read CPU brand only when generic iGPU names need CPU fallback matching.
@@ -130,27 +135,13 @@ class Sysinfo {
     }
     return cpu && cpu.brand
   }
-  // Select the PyTorch backend install target from detected hardware identity.
-  async torch_backend(detected) {
-    // Do not require runtime probes such as rocminfo, hipInfo, ze_info, or
-    // an existing torch install here.
-    if (nvidia.supports_torch_backend(detected.is_nvidia, process.platform)) {
-      return "cuda"
-    } else if (apple.supports_torch_backend(detected.is_apple, process.platform)) {
-      return "mps"
-    } else if (
-      detected.is_amd &&
-      process.platform !== "darwin" &&
-      await amd.supports_torch_backend(detected.gpu_model, () => this.cpu_brand())
-    ) {
-      return "rocm"
-    } else if (
-      detected.is_intel &&
-      await intel.supports_torch_backend(detected.is_intel.model, () => this.cpu_brand())
-    ) {
-      return "xpu"
+  async gpu_target(detected) {
+    if (detected.is_nvidia) {
+      return await nvidia.resolve_cuda_sm_target(detected.primaryController)
+    } else if (detected.is_amd) {
+      return await amd.resolve_gpu_target(detected.gpu_model, detected.cpu_brand || (() => this.cpu_brand()))
     } else {
-      return "cpu"
+      return null
     }
   }
 //  async time() {

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "pinokiod",
-  "version": "7.5.14",
+  "version": "7.5.15",
   "description": "",
   "main": "index.js",
   "scripts": {
     "download_readme": "wget -O kernel/proto/PINOKIO.md https://raw.githubusercontent.com/pinokiocomputer/home/refs/heads/main/docs/README.md",
+    "update:amd-gfx-targets": "node script/update-amd-gfx-targets.js",
     "start": "node script/index"
   },
   "author": "",

package/script/update-amd-gfx-targets.js

@@ -0,0 +1,119 @@
+const fs = require('node:fs')
+const https = require('node:https')
+const path = require('node:path')
+
+const { normalize_model } = require('../kernel/gpu/common')
+
+const GPU_SPECS_URL = 'https://raw.githubusercontent.com/ROCm/ROCm/develop/docs/reference/gpu-arch-specs.rst'
+const GENERATOR = 'script/update-amd-gfx-targets.js'
+
+const repoRoot = path.resolve(__dirname, '..')
+
+function fetchText(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (response) => {
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        const nextUrl = new URL(response.headers.location, url).toString()
+        response.resume()
+        fetchText(nextUrl).then(resolve, reject)
+        return
+      }
+      if (response.statusCode !== 200) {
+        response.resume()
+        reject(new Error(`${url} returned ${response.statusCode}`))
+        return
+      }
+      let body = ''
+      response.setEncoding('utf8')
+      response.on('data', (chunk) => {
+        body += chunk
+      })
+      response.on('end', () => resolve(body))
+    }).on('error', reject)
+  })
+}
+
+function canonicalKey(value) {
+  let key = normalize_model(value)
+  let previous
+  do {
+    previous = key
+    key = key
+      .replace(/^advanced micro devices\s+/, '')
+      .replace(/^amd\s+/, '')
+      .replace(/^instinct\s+/, '')
+      .trim()
+  } while (key !== previous)
+  return key
+}
+
+function addEntry(entries, name, target) {
+  const key = canonicalKey(name)
+  if (key && /^gfx[0-9a-f]+$/i.test(target)) {
+    entries[key] = target.toLowerCase()
+  }
+}
+
+function parseGpuSpecs(rst) {
+  const entries = {}
+  let headers = null
+  let cells = []
+  let inRow = false
+
+  const flushRow = () => {
+    if (!inRow || cells.length === 0) return
+    if (cells.includes('Name') && cells.includes('LLVM target name')) {
+      headers = cells
+    } else if (headers) {
+      const nameIndex = headers.indexOf('Name')
+      const graphicsIndex = headers.indexOf('Graphics model')
+      const targetIndex = headers.indexOf('LLVM target name')
+      const target = cells[targetIndex]
+      if (target) {
+        addEntry(entries, cells[nameIndex], target)
+        if (graphicsIndex >= 0) {
+          addEntry(entries, cells[graphicsIndex], target)
+        }
+      }
+    }
+    cells = []
+  }
+
+  for (const line of rst.split(/\r?\n/)) {
+    if (/^\s*\*\s*$/.test(line)) {
+      flushRow()
+      inRow = true
+      continue
+    }
+    const cell = line.match(/^\s*-\s*(.*)$/)
+    if (inRow && cell) {
+      cells.push(cell[1].trim())
+    }
+  }
+  flushRow()
+
+  return entries
+}
+
+function writeJson(relativePath, data) {
+  const file = path.join(repoRoot, relativePath)
+  fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`)
+}
+
+async function main() {
+  const specs = await fetchText(GPU_SPECS_URL)
+  const entries = parseGpuSpecs(specs)
+
+  writeJson('kernel/gpu/amd_gfx_targets.json', {
+    source: GPU_SPECS_URL,
+    generated_by: GENERATOR,
+    entries: Object.fromEntries(Object.entries(entries).sort(([a], [b]) => a.localeCompare(b)))
+  })
+
+  console.log(`Wrote ${Object.keys(entries).length} AMD gfx target entries`)
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/server/lib/app_log_report.js

@@ -358,8 +358,7 @@ class AppLogReportService {
         version: this.readPinokioVersion(),
         node: process.version,
         platform: kernel.platform || process.platform,
-        arch: kernel.arch || process.arch,
-        torch_backend: kernel.torch_backend || info.torch_backend || null
+        arch: kernel.arch || process.arch
       },
       hardware: this.compactObject({
         gpu: kernel.gpu || info.gpu || null,

package/test/amd-gpu-target.test.js

@@ -0,0 +1,169 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const path = require('node:path')
+const test = require('node:test')
+
+const system = require('systeminformation')
+
+const amd = require('../kernel/gpu/amd')
+const gfxTargets = require('../kernel/gpu/amd_gfx_targets.json')
+const packageJson = require('../package.json')
+const Sysinfo = require('../kernel/sysinfo')
+
+const root = path.join(__dirname, '..')
+
+test('AMD gfx generated data is checked in and self describing', () => {
+  assert.equal(
+    gfxTargets.source,
+    'https://raw.githubusercontent.com/ROCm/ROCm/develop/docs/reference/gpu-arch-specs.rst'
+  )
+  assert.equal(gfxTargets.generated_by, 'script/update-amd-gfx-targets.js')
+
+  assert.equal(gfxTargets.entries['radeon rx 6800 xt'], 'gfx1030')
+  assert.equal(gfxTargets.entries['radeon rx 7900 xtx'], 'gfx1100')
+  assert.equal(gfxTargets.entries.mi210, 'gfx90a')
+})
+
+test('AMD gfx target refresh is an explicit maintainer command', () => {
+  assert.equal(packageJson.scripts['update:amd-gfx-targets'], 'node script/update-amd-gfx-targets.js')
+  assert.equal(Object.prototype.hasOwnProperty.call(packageJson.scripts, 'update:amd-rocm-targets'), false)
+
+  for (const script of ['preinstall', 'install', 'postinstall', 'prestart', 'start', 'poststart']) {
+    assert.doesNotMatch(packageJson.scripts[script] || '', /update-amd-gfx-targets/)
+  }
+})
+
+test('AMD gfx resolver maps common product names to exact gfx targets', () => {
+  const cases = [
+    ['AMD Radeon RX 6800 XT', 'gfx1030'],
+    ['AMD Radeon RX 7600', 'gfx1102'],
+    ['Advanced Micro Devices Radeon RX 7900 XTX', 'gfx1100'],
+    ['AMD Radeon RX 9070 XT', 'gfx1201'],
+    ['AMD Radeon AI PRO R9700', 'gfx1201'],
+    ['AMD Instinct MI210', 'gfx90a'],
+    ['AMD Radeon 780M', 'gfx1103'],
+    ['AMD Radeon 890M', 'gfx1150'],
+    ['gfx1030', 'gfx1030']
+  ]
+
+  for (const [model, target] of cases) {
+    assert.equal(amd.resolve_rocm_gfx_target(model), target, model)
+  }
+})
+
+test('AMD gfx resolver rejects unknown products and preserves raw gfx targets', () => {
+  const unknownModels = [
+    'AMD Radeon RX 480',
+    'AMD Radeon RX 5700 XT',
+    'AMD Radeon RX 9999',
+    'AMD Radeon RX 9999M XT'
+  ]
+
+  for (const model of unknownModels) {
+    assert.equal(amd.resolve_rocm_gfx_target(model), null, model)
+  }
+
+  for (const target of ['gfx803', 'gfx1013', 'gfx1104', 'gfx1209', 'GFX90A']) {
+    assert.equal(amd.resolve_rocm_gfx_target(target), target.toLowerCase(), target)
+  }
+})
+
+test('AMD gpu_target resolution uses CPU brand only for generic Radeon Graphics models', async () => {
+  let cpuBrandCalls = 0
+  const cpuBrand = async () => {
+    cpuBrandCalls += 1
+    return 'AMD Ryzen AI 9 HX 375'
+  }
+
+  assert.equal(await amd.resolve_gpu_target('AMD Radeon RX 6800 XT', cpuBrand), 'gfx1030')
+  assert.equal(cpuBrandCalls, 0)
+
+  assert.equal(await amd.resolve_gpu_target('AMD Radeon RX 480', cpuBrand), null)
+  assert.equal(cpuBrandCalls, 0)
+
+  assert.equal(await amd.resolve_gpu_target('AMD Radeon Graphics', cpuBrand), 'gfx1150')
+  assert.equal(cpuBrandCalls, 1)
+
+  assert.equal(await amd.resolve_gpu_target('AMD Radeon Graphics', 'Unknown AMD CPU'), null)
+})
+
+test('Sysinfo exposes AMD gpu_target for resolved discrete GPUs', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'AMD',
+        model: 'AMD Radeon RX 6800 XT',
+        vram: 16384,
+        driverVersion: '31.0.1'
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'amd')
+  assert.equal(sys.info.gpu_target, 'gfx1030')
+})
+
+test('Sysinfo leaves unresolved AMD gpu_target null', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'AMD',
+        model: 'AMD Radeon RX 480',
+        vram: 8192,
+        driverVersion: '31.0.1'
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'amd')
+  assert.equal(sys.info.gpu_target, null)
+})
+
+test('Sysinfo exposes AMD gpu_target through generic APU CPU fallback', async (t) => {
+  let cpuBrandCalls = 0
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'AMD',
+        model: 'AMD Radeon Graphics',
+        vram: 16384,
+        driverVersion: '31.0.1'
+      }
+    ],
+    displays: []
+  }))
+  t.mock.method(system, 'cpu', async () => {
+    cpuBrandCalls += 1
+    return { brand: 'AMD Ryzen AI 9 HX 375' }
+  })
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'amd')
+  assert.equal(sys.info.gpu_target, 'gfx1150')
+  assert.equal(cpuBrandCalls, 1)
+})
+
+test('AMD gfx runtime resolver stays offline and data-only', () => {
+  const source = fs.readFileSync(path.join(root, 'kernel', 'gpu', 'amd.js'), 'utf8')
+
+  assert.doesNotMatch(source, /require\(["'](?:node:)?https?["']\)/)
+  assert.doesNotMatch(source, /require\(["'](?:node:)?child_process["']\)/)
+  assert.doesNotMatch(source, /\b(fetch|axios|rocminfo|hipInfo|ze_info)\b/)
+  assert.doesNotMatch(source, /\b(kfd|topology)\b/i)
+})

package/test/gpu-target-template-variable.test.js

@@ -0,0 +1,69 @@
+const assert = require('node:assert/strict')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const test = require('node:test')
+
+const Kernel = require('../kernel')
+
+test('Kernel propagates sysinfo gpu_target to template state and public info', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-gpu-target-info-'))
+  const apiRoot = path.join(root, 'api')
+  await fs.mkdir(apiRoot, { recursive: true })
+
+  const templateUpdates = []
+  const kernel = {
+    version: 'test',
+    platform: 'linux',
+    arch: 'x64',
+    homedir: root,
+    shell: { shells: [] },
+    vars: {},
+    memory: {
+      local: {},
+      global: {},
+      key: {},
+      rpc: {},
+      input: {},
+      args: {}
+    },
+    procs: {},
+    api: {
+      running: {},
+      proxies: {},
+      userdir: apiRoot,
+      meta: async () => null
+    },
+    bin: { installed: {} },
+    template: {
+      update: (info) => templateUpdates.push(info)
+    },
+    sys: {
+      info: {
+        gpu: 'amd',
+        gpu_model: 'amd radeon rx 6800 xt',
+        gpu_driver: '31.0.1',
+        gpu_target: 'gfx1030',
+        gpus: [],
+        vram: 16,
+        ram: 64
+      }
+    },
+    path: (...parts) => path.join(root, ...parts),
+    dns: async () => {}
+  }
+
+  try {
+    await Kernel.prototype.update_sysinfo.call(kernel)
+    await Kernel.prototype.getInfo.call(kernel, false)
+
+    assert.equal(kernel.gpu, 'amd')
+    assert.equal(kernel.gpu_model, 'amd radeon rx 6800 xt')
+    assert.equal(kernel.gpu_target, 'gfx1030')
+    assert.equal(templateUpdates.length, 1)
+    assert.equal(templateUpdates[0].gpu_target, 'gfx1030')
+    assert.equal(kernel.i.gpu_target, 'gfx1030')
+  } finally {
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})

package/test/nvidia-gpu-target.test.js

@@ -0,0 +1,98 @@
+const assert = require('node:assert/strict')
+const childProcess = require('node:child_process')
+const test = require('node:test')
+
+const nvidia = require('../kernel/gpu/nvidia')
+
+test('NVIDIA compute capability parser emits CUDA SM targets', () => {
+  assert.deepEqual(
+    nvidia.parse_nvidia_smi_compute_caps([
+      '00000000:01:00.0, 8.6',
+      '00000000:02:00.0, 8.9',
+      '00000000:03:00.0, 12.0',
+      '00000000:04:00.0, N/A'
+    ].join('\n')),
+    [
+      { pci_bus: '01:00.0', target: 'sm_86' },
+      { pci_bus: '02:00.0', target: 'sm_89' },
+      { pci_bus: '03:00.0', target: 'sm_120' }
+    ]
+  )
+})
+
+test('NVIDIA target selection matches the selected controller by PCI bus', () => {
+  const records = [
+    { pci_bus: '01:00.0', target: 'sm_86' },
+    { pci_bus: '02:00.0', target: 'sm_89' }
+  ]
+
+  assert.equal(nvidia.select_cuda_sm_target({ pciBus: '00000000:02:00.0' }, records), 'sm_89')
+  assert.equal(nvidia.select_cuda_sm_target({ busAddress: '01:00.0' }, records), 'sm_86')
+  assert.equal(nvidia.select_cuda_sm_target({ pciBus: '03:00.0' }, records), null)
+})
+
+test('NVIDIA target selection uses the only record when the controller has no PCI bus', () => {
+  assert.equal(
+    nvidia.select_cuda_sm_target({}, [{ pci_bus: '01:00.0', target: 'sm_86' }]),
+    'sm_86'
+  )
+  assert.equal(
+    nvidia.select_cuda_sm_target({}, [
+      { pci_bus: '01:00.0', target: 'sm_86' },
+      { pci_bus: '02:00.0', target: 'sm_89' }
+    ]),
+    null
+  )
+})
+
+test('NVIDIA nvidia-smi query failure resolves to no targets', async () => {
+  const records = await nvidia.query_cuda_sm_targets((_cmd, _args, _options, done) => {
+    done(new Error('missing nvidia-smi'))
+  })
+
+  assert.deepEqual(records, [])
+})
+
+test('NVIDIA nvidia-smi query uses compute capability command and parses stdout', async () => {
+  const calls = []
+  const records = await nvidia.query_cuda_sm_targets((cmd, args, options, done) => {
+    calls.push({ cmd, args, options })
+    done(null, [
+      '00000000:01:00.0, 8.6',
+      '00000000:02:00.0, 8.9'
+    ].join('\n'))
+  })
+
+  assert.deepEqual(calls, [{
+    cmd: 'nvidia-smi',
+    args: [
+      '--query-gpu=pci.bus_id,compute_cap',
+      '--format=csv,noheader,nounits'
+    ],
+    options: { windowsHide: true, timeout: 5000 }
+  }])
+  assert.deepEqual(records, [
+    { pci_bus: '01:00.0', target: 'sm_86' },
+    { pci_bus: '02:00.0', target: 'sm_89' }
+  ])
+})
+
+test('NVIDIA gpu_target caches the nvidia-smi compute capability query', async (t) => {
+  const modulePath = require.resolve('../kernel/gpu/nvidia')
+  delete require.cache[modulePath]
+
+  let calls = 0
+  t.mock.method(childProcess, 'execFile', (_cmd, _args, _options, done) => {
+    calls += 1
+    done(null, '00000000:01:00.0, 8.6\n')
+  })
+  t.after(() => {
+    delete require.cache[modulePath]
+  })
+
+  const freshNvidia = require('../kernel/gpu/nvidia')
+
+  assert.equal(await freshNvidia.resolve_cuda_sm_target({ pciBus: '00000000:01:00.0' }), 'sm_86')
+  assert.equal(await freshNvidia.resolve_cuda_sm_target({ pciBus: '00000000:01:00.0' }), 'sm_86')
+  assert.equal(calls, 1)
+})

package/test/sysinfo-gpu-driver.test.js

@@ -2,6 +2,7 @@ const assert = require('node:assert/strict')
 const test = require('node:test')
 
 const system = require('systeminformation')
+const nvidia = require('../kernel/gpu/nvidia')
 const Sysinfo = require('../kernel/sysinfo')
 
 test('GPU sysinfo exposes per-controller drivers and primary NVIDIA driver', async (t) => {
@@ -17,11 +18,16 @@ test('GPU sysinfo exposes per-controller drivers and primary NVIDIA driver', asy
         vendor: 'NVIDIA',
         model: 'NVIDIA RTX A4500',
         vram: 20480,
-        driverVersion: '565.90'
+        driverVersion: '565.90',
+        pciBus: '00000000:02:00.0'
       }
     ],
     displays: []
   }))
+  t.mock.method(nvidia, 'resolve_cuda_sm_target', async (controller) => {
+    assert.equal(controller.pciBus, '00000000:02:00.0')
+    return 'sm_86'
+  })
 
   const sys = new Sysinfo()
   sys.info = {}
@@ -31,6 +37,8 @@ test('GPU sysinfo exposes per-controller drivers and primary NVIDIA driver', asy
   assert.equal(sys.info.gpu, 'nvidia')
   assert.equal(sys.info.gpu_model, 'nvidia rtx a4500')
   assert.equal(sys.info.gpu_driver, '565.90')
+  assert.equal(sys.info.gpu_target, 'sm_86')
+  assert.equal(sys.info.vram, 20)
   assert.deepEqual(sys.info.gpus, [
     {
       name: 'intel',
@@ -72,6 +80,8 @@ test('GPU sysinfo uses selected highest-VRAM AMD controller for gpu_driver', asy
   assert.equal(sys.info.gpu, 'amd')
   assert.equal(sys.info.gpu_model, 'amd radeon rx 7900 xtx')
   assert.equal(sys.info.gpu_driver, '31.0.2')
+  assert.equal(sys.info.gpu_target, 'gfx1100')
+  assert.equal(sys.info.vram, 24)
   assert.deepEqual(sys.info.gpus, [
     {
       name: 'advanced micro devices',
@@ -85,3 +95,126 @@ test('GPU sysinfo uses selected highest-VRAM AMD controller for gpu_driver', asy
     }
   ])
 })
+
+test('GPU sysinfo leaves gpu_target null for Intel targets', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'Intel',
+        model: 'Intel Arc A770',
+        vram: 16384,
+        driverVersion: '31.0.101.5590'
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'intel')
+  assert.equal(sys.info.gpu_model, 'intel arc a770')
+  assert.equal(sys.info.gpu_driver, '31.0.101.5590')
+  assert.equal(sys.info.gpu_target, null)
+})
+
+test('GPU sysinfo resolves gpu_target for the selected NVIDIA controller when AMD is also present', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'AMD',
+        model: 'AMD Radeon RX 7900 XTX',
+        vram: 24576,
+        driverVersion: '31.0.2'
+      },
+      {
+        vendor: 'NVIDIA',
+        model: 'NVIDIA GeForce RTX 4090',
+        vram: 24576,
+        driverVersion: '565.90',
+        pciBus: '00000000:02:00.0'
+      }
+    ],
+    displays: []
+  }))
+  t.mock.method(nvidia, 'resolve_cuda_sm_target', async (controller) => {
+    assert.equal(controller.model, 'NVIDIA GeForce RTX 4090')
+    return 'sm_89'
+  })
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'nvidia')
+  assert.equal(sys.info.gpu_model, 'nvidia geforce rtx 4090')
+  assert.equal(sys.info.gpu_target, 'sm_89')
+})
+
+test('GPU sysinfo leaves gpu_target null for Apple targets', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'Apple',
+        model: 'Apple M3',
+        vram: 0,
+        driverVersion: null
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'apple')
+  assert.equal(sys.info.gpu_model, 'apple m3')
+  assert.equal(sys.info.gpu_target, null)
+})
+
+test('GPU sysinfo leaves gpu_target null for unknown GPU vendors', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [
+      {
+        vendor: 'Qualcomm',
+        model: 'Adreno X1',
+        vram: 16384,
+        driverVersion: '1.2.3'
+      }
+    ],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'qualcomm')
+  assert.equal(sys.info.gpu_model, 'adreno x1')
+  assert.equal(sys.info.gpu_driver, '1.2.3')
+  assert.equal(sys.info.gpu_target, null)
+})
+
+test('GPU sysinfo leaves gpu_target null when no GPU controller is detected', async (t) => {
+  t.mock.method(system, 'graphics', async () => ({
+    controllers: [],
+    displays: []
+  }))
+
+  const sys = new Sysinfo()
+  sys.info = {}
+
+  await sys.gpus()
+
+  assert.equal(sys.info.gpu, 'none')
+  assert.equal(sys.info.gpu_model, undefined)
+  assert.equal(sys.info.gpu_target, null)
+  assert.deepEqual(sys.info.gpus, [])
+  assert.equal(sys.info.vram, 0)
+})

package/kernel/gpu/apple.js

@@ -1,8 +0,0 @@
-// Apple GPU routes to the built-in PyTorch MPS backend on macOS.
-const supports_torch_backend = (controller, platform) => {
-  return !!controller && platform === "darwin"
-}
-
-module.exports = {
-  supports_torch_backend
-}

package/kernel/gpu/intel.js

@@ -1,47 +0,0 @@
-const { normalize_model } = require("./common")
-
-// Resolve CPU brand lazily so clear GPU model matches do not trigger CPU probing.
-const resolve_cpu_brand = async (cpu_brand) => {
-  if (typeof cpu_brand === "function") {
-    return await cpu_brand()
-  } else {
-    return cpu_brand
-  }
-}
-
-// Match Intel GPU model names that Pinokio should route to PyTorch XPU wheels.
-const matches_xpu_torch_model = (model) => {
-  let normalized = normalize_model(model)
-  return (
-    // Intel Arc A-Series / B-Series, Arc Pro, and Core Ultra iGPUs when the
-    // GPU model itself includes Arc.
-    /\barc\b/.test(normalized) ||
-    // Intel Data Center GPU Max Series. Do not match generic Data Center GPU
-    // names because Data Center GPU Flex is not in current PyTorch XPU docs.
-    /\b(data center gpu max|gpu max|ponte vecchio)\b/.test(normalized)
-  )
-}
-
-// Detect uninformative Intel iGPU names that need CPU-brand fallback matching.
-const is_generic_gpu_model = (model) => {
-  let normalized = normalize_model(model)
-  return /^(intel )?graphics$/.test(normalized)
-}
-
-// Decide Intel XPU install intent, using CPU brand only for generic iGPU names.
-const supports_torch_backend = async (model, cpu_brand) => {
-  if (matches_xpu_torch_model(model)) {
-    return true
-  }
-  if (!is_generic_gpu_model(model)) {
-    return false
-  }
-  let brand = normalize_model(await resolve_cpu_brand(cpu_brand))
-  return /\bcore\s*ultra\b/.test(brand)
-}
-
-module.exports = {
-  is_generic_gpu_model,
-  matches_xpu_torch_model,
-  supports_torch_backend
-}

package/release_notes/8.0.0/ui.md

@@ -1,91 +0,0 @@
-# Pinokio 8.0.0 UI Updates
-
-This release brings Pinokio's main surfaces into a quieter, more consistent workspace: app discovery, app launch controls, logs, tools, plugins, skills, autolaunch, setup, and mobile navigation now share the same visual language and action patterns.
-
-The notes below are grouped by what users will notice, not by commit history. Screenshots were captured from the live local UI after comparing `de83785` to the current `HEAD`.
-
-## Cleaner App Discovery
-
-Pinokio's home screen now behaves more like a compact app manager. The sidebar is unified with the rest of the product, the app list is easier to scan, search and sort stay prominent, and each app row exposes quick actions without forcing users into the full app page first.
-
-![Home app list with unified sidebar](assets/home-sidebar-apps.png)
-
-The new action panel gives installed apps a focused command surface for common launch, install, update, reset, file, and dev actions. Related commands are grouped in one drawer, which reduces row clutter while keeping the next action close to the app.
-
-![Home app action panel](assets/home-app-actions.png)
-
-## App Workspace And Assistance
-
-App pages have been rebuilt around a more durable workspace shell. The page chrome, left command rail, right utility panels, app title area, status indicators, resource labels, and launch actions have been tightened so app-specific work feels connected to the rest of Pinokio.
-
-![App workspace chrome](assets/app-detail-header-actions.png)
-
-Ask AI now opens as an in-app assistance drawer with searchable terminal and desktop agents. Instead of a generic help entry point, users can choose from bundled agents such as Codex, Claude Code, Qwen Code, Antigravity, Cursor, VS Code, and desktop integrations directly inside the app context.
-
-![Ask AI agent drawer](assets/app-ask-ai-drawer.png)
-
-## Plugins, Agents, And Skills
-
-The Plugins page now separates terminal plugins from desktop plugins and shows install/manage affordances in a single list. This makes the new bundled native tools easier to understand: terminal agents launch inside Pinokio, while desktop tools launch externally.
-
-![Plugins and bundled agents](assets/plugins-agent-tools.png)
-
-Pinokio also has a new Skills management surface. Users can see where managed skills are stored, where they sync, whether each skill is valid, and whether it is currently enabled. The page also supports downloading skills from a Git URL.
-
-![Skills management](assets/skills-management.png)
-
-## Startup And Launch Requirements
-
-Autolaunch is now a first-class configuration page. Users can search installed apps, choose which launch script should run at startup, see how many apps are enabled, and toggle startup behavior without digging through app internals.
-
-![Autolaunch and launch script selection](assets/autolaunch-dependencies.png)
-
-Setup and requirements screens now present blocked routes as a clear checklist. When a destination such as Local network needs a package update, Pinokio shows what is installed, what needs attention, and the action required before continuing.
-
-![Network setup requirements](assets/network-phone-access.png)
-
-## Logs, Diagnostics, And Issue Reporting
-
-Logs have been redesigned around a file tree and live reader. Users can inspect logs from the machine, stream a selected file, clear the view, keep auto-scroll on, and generate a diagnostic zip from the same screen.
-
-![Logs file tree and live reader](assets/logs-terminal-reporting.png)
-
-Behind that surface, the issue-reporting flow is more capable: recent logs can be summarized, redacted, copied, handed to Ask AI, or prepared as a registry draft. Those states require an app failure or report context, so they are not shown in this static screenshot set.
-
-## Tools And Runtime Readiness
-
-The Tools page now groups package bundles with readiness counts, per-bundle install state, and package-level status. Users can see which runtime bundles are ready, which need installation, and which package manager modules are present without reading terminal output first.
-
-![Tools and package bundle readiness](assets/tools-runtime-management.png)
-
-## Login And Connected Services
-
-The Hugging Face login flow has been redesigned as a clear device-authorization page. It states the connection state, the credential provider, the reason to log in, and the next action without mixing auth details into unrelated setup UI.
-
-![Hugging Face login](assets/connect-huggingface-login.png)
-
-GitHub and git-related modals also received layout cleanup: modal tabs, footers, repository status controls, checkpoint rows, and history/diff areas were tightened so longer repository workflows fit better in the available space.
-
-## Mobile And Remote Access
-
-Mobile layouts now prioritize the app list and move primary navigation to a bottom bar. Search, sort, app cards, favorites, and action buttons remain reachable on a phone-width viewport without the desktop sidebar competing for space.
-
-![Mobile home and footer navigation](assets/mobile-home-footer-nav.png)
-
-Phone and LAN access also received targeted polish. QR and network access entry points are gated behind setup readiness, install terminals attach correctly over LAN, and the old mobile "Tap to connect" curtain has been replaced with a quieter first-interaction audio primer.
-
-## Smaller Visual Polish
-
-Several changes are intentionally broad but subtle:
-
-- Shared sidebar styling now covers home, app, tools, plugins, skills, logs, settings, setup, network, and auth pages.
-- App navigation is more responsive, especially where action labels previously wrapped or crowded the header.
-- Screenshot/capture modals, footer status indicators, popovers, tabs, and terminal controls use flatter, tighter styling.
-- Checkpoints rows, git history dialogs, network troubleshoot panels, and auth pages were normalized to match the newer page shell.
-- Hidden or unused toolbar buttons were removed from the visible chrome so users see fewer inactive controls.
-
-## Screenshot Coverage Notes
-
-Captured screenshots cover the major visible themes: home discovery, app actions, app workspace chrome, Ask AI, plugins, skills, autolaunch, setup requirements, logs, tools, connected-service login, and mobile navigation.
-
-Some UI states were not practical to screenshot without changing runtime state or forcing failures: failed-terminal fallback, report-draft creation, live dependency orchestration while an app is launching, completed peer-network routing, and git/checkpoint modal edge cases. Those changes are still included above because they are user-visible when the relevant workflow is active.