Unreleased - 2026-05-19

Author: Union-Crax

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased - 2026-05-19
+
+### Wishlist
+
+- **PC compatibility card on the Wishlist page** — the upgrade-suggestions card from Settings → System Profile is now surfaced directly on the Wishlist page. When all wishlisted games pass minimum requirements it shows the "Your PC clears every wishlist game" good-news banner; otherwise it shows the bottleneck breakdown with per-component suggestions. The card is skipped entirely when no system profile has been scanned or the wishlist has no evaluable games.
+
 ## v2.2.0 — Crossroads · 2026-05-19
 
 Linux gets first-class treatment across the launcher, the system scanner gets sharper teeth, and the updater + installer stop tripping over themselves. Picks up the system-profile groundwork laid in v2.1.0 and makes that data actually matter cross-platform — sysreq panels auto-pick your OS, the runnable filter respects it, the scanner reports DDR/NVMe types correctly on both platforms, and the launcher no longer pretends a Linux user lives in a Windows world.

electron/main.cjs

@@ -1761,7 +1761,10 @@ function applySettingsDefaults(settings) {
       forums: 'off',
       profilePublic: 'off',
       sysreqCheck: 'on',     // local pre-download check — no PII leaves device
+      shareGamePlaytime: true, // when false, user is excluded from playtime leaderboard + public playtime card
     }
+  } else if (typeof next.systemProfileVisibility.shareGamePlaytime !== 'boolean') {
+    next.systemProfileVisibility.shareGamePlaytime = true
   }
   if (typeof next.systemProfileSyncEnabled !== 'boolean') next.systemProfileSyncEnabled = false
   // When sharing error logs / diagnostics, optionally include a one-line hardware

electron/system-profile.cjs

@@ -12,7 +12,7 @@ const path = require('node:path')
 const crypto = require('node:crypto')
 const child_process = require('node:child_process')
 
-const SPEC_VERSION = 2
+const SPEC_VERSION = 3
 
 // PowerShell on Windows has a meaningful cold-start cost (CLR init + WMI
 // service spin-up can easily blow past 5s on the first call after boot),
@@ -139,8 +139,101 @@ try {
   }
 } catch { }
 
+# Real VRAM via the display-adapter class key. Win32_VideoController.AdapterRAM
+# is a DWORD and is capped at 4GB (and often outright wrong on modern cards);
+# the kernel writes the 64-bit truth into HardwareInformation.qwMemorySize.
+# We collect every adapter subkey and let the JS side correlate by PNPDeviceID
+# (MatchingDeviceId) so we can attach VRAM to the right Win32_VideoController row.
+$adapters = @()
+try {
+  $classRoot = 'HKLM:\SYSTEM\CurrentControlSet\Control\Class\{4d36e968-e325-11ce-bfc1-08002be10318}'
+  if (Test-Path $classRoot) {
+    $adapters = Get-ChildItem $classRoot -ErrorAction SilentlyContinue | Where-Object { $_.PSChildName -match '^\d{4}$' } | ForEach-Object {
+      $vals = $null
+      try { $vals = Get-ItemProperty -Path $_.PSPath -ErrorAction Stop } catch { }
+      if ($vals) {
+        @{
+          subkey       = $_.PSChildName
+          driverDesc   = "$($vals.DriverDesc)"
+          matchingDevId = "$($vals.MatchingDeviceId)"
+          # qwMemorySize is the 64-bit value; HardwareInformation.MemorySize is the
+          # legacy DWORD. Prefer the QWORD when present.
+          qwMemorySize = if ($vals.'HardwareInformation.qwMemorySize') { [int64]$vals.'HardwareInformation.qwMemorySize' } else { $null }
+          dwMemorySize = if ($vals.'HardwareInformation.MemorySize')   { [int64]$vals.'HardwareInformation.MemorySize'   } else { $null }
+        }
+      }
+    }
+  }
+} catch { }
+
+# Physical monitors (panels actually attached) via the WMI monitor namespace.
+# Win32_VideoController only knows about adapters; a single GPU can drive 1..N
+# monitors. We pull EDID-derived manufacturer/product strings + the largest
+# supported source mode (proxy for the panel's native resolution) so the
+# scanner reports every attached monitor, not just "the GPU's primary".
+$monitors = @()
+try {
+  $ids = Get-CimInstance -Namespace root/wmi -ClassName WmiMonitorID -ErrorAction Stop
+  $modes = @()
+  try { $modes = Get-CimInstance -Namespace root/wmi -ClassName WmiMonitorListedSupportedSourceModes -ErrorAction Stop } catch { }
+  $modesByInstance = @{}
+  foreach ($m in $modes) {
+    $modesByInstance[$m.InstanceName] = $m
+  }
+  foreach ($id in $ids) {
+    $name = ''
+    if ($id.UserFriendlyName) {
+      $name = -join ($id.UserFriendlyName | Where-Object { $_ -gt 0 } | ForEach-Object { [char]$_ })
+    }
+    $manuf = ''
+    if ($id.ManufacturerName) {
+      $manuf = -join ($id.ManufacturerName | Where-Object { $_ -gt 0 } | ForEach-Object { [char]$_ })
+    }
+    $product = ''
+    if ($id.ProductCodeID) {
+      $product = -join ($id.ProductCodeID | Where-Object { $_ -gt 0 } | ForEach-Object { [char]$_ })
+    }
+    $serial = ''
+    if ($id.SerialNumberID) {
+      $serial = -join ($id.SerialNumberID | Where-Object { $_ -gt 0 } | ForEach-Object { [char]$_ })
+    }
+    # Native mode = largest preferred mode. The list is unordered; pick the one
+    # with the highest horizontal active pixels and matching vertical.
+    $w = $null; $h = $null; $hz = $null
+    $sm = $modesByInstance[$id.InstanceName]
+    if ($sm -and $sm.MonitorSourceModes) {
+      $best = $sm.MonitorSourceModes | Sort-Object -Property HorizontalActivePixels -Descending | Select-Object -First 1
+      if ($best) {
+        $w = [int]$best.HorizontalActivePixels
+        $h = [int]$best.VerticalActivePixels
+        if ($best.VerticalRefreshRateNumerator -and $best.VerticalRefreshRateDenominator) {
+          $hz = [int][math]::Round($best.VerticalRefreshRateNumerator / $best.VerticalRefreshRateDenominator)
+        }
+      }
+    }
+    $monitors += @{
+      instance = $id.InstanceName
+      name     = $name
+      manuf    = $manuf
+      product  = $product
+      serial   = $serial
+      yearOfManufacture = $id.YearOfManufacture
+      active   = [bool]$id.Active
+      width    = $w
+      height   = $h
+      refreshHz = $hz
+    }
+  }
+} catch { }
+
+# DPI / current-mode pass: Win32_DesktopMonitor has the *current* (not native)
+# resolution for whichever monitor each Win32_VideoController is currently
+# driving. Useful as a fallback when WmiMonitor* isn't accessible (some
+# locked-down corporate images).
+$desktopMonitors = Try-CIM 'Win32_DesktopMonitor' $null | Select-Object Name,ScreenWidth,ScreenHeight,DeviceID,PNPDeviceID,MonitorManufacturer,MonitorType
+
 $out = @{
-  cs=$cs; os=$os_; cpu=$cpu; gpu=$gpu; mem=$mem; disk=$disk; vol=$vol; volMedia=$volMedia; pdisks=$pdisks
+  cs=$cs; os=$os_; cpu=$cpu; gpu=$gpu; mem=$mem; disk=$disk; vol=$vol; volMedia=$volMedia; pdisks=$pdisks; adapters=$adapters; monitors=$monitors; desktopMonitors=$desktopMonitors
 }
 $out | ConvertTo-Json -Depth 8 -Compress
 `
@@ -172,14 +265,39 @@ async function scanWindows() {
   const cpu = cpus[0] || {}
   const archMap = { 0: 'x86', 5: 'arm', 6: 'ia64', 9: 'x64', 12: 'arm64' }
 
+  // Build a lookup of "real" VRAM from the registry. AdapterRAM (DWORD) is
+  // capped at 4GB and outright wrong on most modern cards. The display class
+  // key stores the 64-bit HardwareInformation.qwMemorySize that we trust over
+  // the WMI value. Correlate by PNPDeviceID prefix.
+  const vramByPnpPrefix = new Map()
+  for (const a of toArray(parsed.adapters)) {
+    const matching = String(a?.matchingDevId || '').toUpperCase()
+    if (!matching) continue
+    const bytes = Number(a?.qwMemorySize) || Number(a?.dwMemorySize) || 0
+    if (!bytes) continue
+    // Strip the subsys/rev suffix so we match "PCI\VEN_10DE&DEV_2786" against
+    // both shortened PnP IDs and full ones.
+    const key = matching.split('&').slice(0, 2).join('&')
+    vramByPnpPrefix.set(key, bytes)
+    vramByPnpPrefix.set(matching, bytes)
+  }
+  function lookupRealVram(pnp) {
+    if (!pnp) return null
+    const up = String(pnp).toUpperCase()
+    if (vramByPnpPrefix.has(up)) return vramByPnpPrefix.get(up)
+    const short = up.split('&').slice(0, 2).join('&')
+    if (vramByPnpPrefix.has(short)) return vramByPnpPrefix.get(short)
+    return null
+  }
+
   // Rank GPUs so virtual / paravirtual adapters (Meta Oculus Virtual,
   // Parsec, Microsoft Basic Display, IddSampleDriver, RDP, Hyper-V) lose
   // to real silicon when the renderer reads `gpus[0]`.
   const rawGpus = toArray(parsed.gpu)
     .filter((g) => g && (g.Name || g.PNPDeviceID))
     .map((g) => ({
       name: g?.Name || null,
-      vramBytes: Number(g?.AdapterRAM) || null,
+      vramBytes: lookupRealVram(g?.PNPDeviceID) || Number(g?.AdapterRAM) || null,
       vendor: detectGpuVendor(g?.Name || ''),
       driverVersion: g?.DriverVersion || null,
       driverDate: g?.DriverDate || null,
@@ -258,23 +376,77 @@ async function scanWindows() {
     }
   })
 
-  // Re-derive displays from the same Win32_VideoController rows (they
-  // carry CurrentHorizontalResolution/Refresh). Filter to active adapters
-  // so a disabled Oculus virtual display doesn't show up as your monitor.
-  const displays = toArray(parsed.gpu)
-    .filter((d) => d?.CurrentHorizontalResolution && d?.CurrentVerticalResolution)
-    .map((d) => ({
-      label: d?.Name || null,
-      width: Number(d.CurrentHorizontalResolution) || null,
-      height: Number(d.CurrentVerticalResolution) || null,
-      refreshHz: Number(d.CurrentRefreshRate) || null,
-    }))
-    // Same virtual-adapter pushdown as GPUs.
+  // Enumerate every *physical* monitor attached to the machine. The previous
+  // implementation derived displays from Win32_VideoController, which is
+  // per-adapter and only ever reported one entry (the GPU's primary surface)
+  // — multi-monitor setups appeared as a single 1080p panel. Now we use
+  // root/wmi → WmiMonitorID for the panel list and WmiMonitorListedSupported-
+  // SourceModes for the native resolution, falling back to Win32_DesktopMonitor
+  // and finally Win32_VideoController for locked-down systems where the WMI
+  // monitor namespace is blocked.
+  const monitorRows = toArray(parsed.monitors).filter((m) => m && (m.name || m.product || m.manuf))
+  let displays = monitorRows.map((m) => ({
+    label: (m.name && m.name.trim()) || [m.manuf, m.product].filter(Boolean).join(' ').trim() || null,
+    width: Number(m.width) || null,
+    height: Number(m.height) || null,
+    refreshHz: Number(m.refreshHz) || null,
+    manufacturer: m.manuf || null,
+    product: m.product || null,
+    serial: m.serial || null,
+    active: m.active !== false,
+  }))
+
+  if (displays.length === 0) {
+    // Win32_DesktopMonitor fallback. Multiple rows per machine on multi-head
+    // rigs; sometimes one ghost row with zero dimensions — filter those.
+    displays = toArray(parsed.desktopMonitors)
+      .filter((d) => Number(d?.ScreenWidth) && Number(d?.ScreenHeight))
+      .map((d) => ({
+        label: d?.Name || d?.MonitorType || null,
+        width: Number(d.ScreenWidth) || null,
+        height: Number(d.ScreenHeight) || null,
+        refreshHz: null,
+        manufacturer: d?.MonitorManufacturer || null,
+        product: null,
+        serial: null,
+        active: true,
+      }))
+  }
+
+  if (displays.length === 0) {
+    // Last-resort fallback: the old per-adapter view. Only fires when both
+    // monitor namespaces are unavailable (rare).
+    displays = toArray(parsed.gpu)
+      .filter((d) => d?.CurrentHorizontalResolution && d?.CurrentVerticalResolution)
+      .map((d) => ({
+        label: d?.Name || null,
+        width: Number(d.CurrentHorizontalResolution) || null,
+        height: Number(d.CurrentVerticalResolution) || null,
+        refreshHz: Number(d.CurrentRefreshRate) || null,
+        manufacturer: null,
+        product: null,
+        serial: null,
+        active: true,
+      }))
+  }
+
+  // Push virtual / inactive monitors to the back, and dedupe entries that
+  // share width+height+label (Win32_DesktopMonitor sometimes lists the same
+  // monitor twice once via DDC and once via EDID).
+  const seen = new Set()
+  displays = displays
     .sort((a, b) => {
+      if (a.active !== b.active) return a.active ? -1 : 1
       const av = isVirtualGpu(a.label || '', '')
       const bv = isVirtualGpu(b.label || '', '')
       if (av !== bv) return av ? 1 : -1
-      return 0
+      return (b.width || 0) - (a.width || 0)
+    })
+    .filter((d) => {
+      const k = `${d.label}|${d.width}|${d.height}|${d.serial || ''}`
+      if (seen.has(k)) return false
+      seen.add(k)
+      return true
     })
 
   return {

renderer/src/app/pages/WishlistPage.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "react"
+import { useCallback, useEffect, useMemo, useState } from "react"
 import { useNavigate } from "react-router-dom"
 import { Button } from "@/components/ui/button"
 import { Card, CardContent } from "@/components/ui/card"
@@ -7,6 +7,7 @@ import { GameCardSkeleton } from "@/components/GameCardSkeleton"
 import { apiFetch, apiUrl, getApiBaseUrl } from "@/lib/api"
 import { useDiscordAccount } from "@/hooks/use-discord-account"
 import { Heart, LogIn, RefreshCw, Star } from "lucide-react"
+import { UpgradeSuggesterSection } from "@/components/SystemProfilePanel"
 
 interface Game {
   appid: string
@@ -32,6 +33,8 @@ export function WishlistPage() {
   const [loggingIn, setLoggingIn] = useState(false)
   const [refreshing, setRefreshing] = useState(false)
 
+  const baseUrl = useMemo(() => { try { return getApiBaseUrl() } catch { return undefined } }, [])
+
   const loadItems = useCallback(async (retrySession = true) => {
     setError(null)
     setLoading(true)
@@ -123,6 +126,10 @@ export function WishlistPage() {
           </div>
         )}
 
+        {accountUser && (
+          <UpgradeSuggesterSection baseUrl={baseUrl} />
+        )}
+
         {!accountUser && !accountLoading ? null : loading || accountLoading ? (
           <div className="grid gap-4 grid-cols-2 sm:grid-cols-3 md:grid-cols-3 lg:grid-cols-4 xl:grid-cols-5">
             {Array.from({ length: 10 }).map((_, idx) => (

renderer/src/components/SystemProfilePanel.tsx

@@ -3,7 +3,8 @@ import { Card, CardContent } from "@/components/ui/card"
 import { Button } from "@/components/ui/button"
 import { Badge } from "@/components/ui/badge"
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
-import { Cpu, Loader2, RefreshCw, Monitor, HardDrive, Zap, MemoryStick, Trash2, ShieldCheck, CloudUpload, CloudOff, CheckCircle2, Laptop, X, Check, Pencil, TrendingUp } from "lucide-react"
+import { Cpu, Loader2, RefreshCw, Monitor, HardDrive, Zap, MemoryStick, Trash2, ShieldCheck, CloudUpload, CloudOff, CheckCircle2, Laptop, X, Check, Pencil, TrendingUp, Clock3 } from "lucide-react"
+import { Switch } from "@/components/ui/switch"
 import { Input } from "@/components/ui/input"
 import { getApiBaseUrl } from "@/lib/api"
 
@@ -12,6 +13,7 @@ const DEFAULT_VISIBILITY: SystemProfileVisibility = {
   forums: "off",
   profilePublic: "off",
   sysreqCheck: "on",
+  shareGamePlaytime: true,
 }
 
 function formatBytes(bytes: number | null | undefined): string {
@@ -207,6 +209,7 @@ export function SystemProfilePanel({ autoScanOnMount = false, onAutoScanConsumed
             comments: next.comments === "summary" ? "summary" : "off",
             forums: next.forums === "summary" ? "summary" : "off",
             profilePublic: next.profilePublic,
+            shareGamePlaytime: next.shareGamePlaytime,
           })
         } catch { /* swallow, will retry on next scan/visibility change */ }
       }
@@ -350,6 +353,22 @@ export function SystemProfilePanel({ autoScanOnMount = false, onAutoScanConsumed
               value={visibility.profilePublic}
               onChange={(v) => updateVisibility({ profilePublic: v })}
             />
+            <div className="flex items-start justify-between gap-4 py-2">
+              <div className="flex-1 min-w-0">
+                <div className="text-sm font-medium flex items-center gap-1.5">
+                  <Clock3 className="h-3.5 w-3.5 text-zinc-400" />
+                  Game playtime sharing
+                </div>
+                <div className="text-xs text-zinc-400 mt-0.5">
+                  When on, your playtime appears on the public leaderboard and the playtime card on your profile (with which games you've played). <b>When off, you're removed from the playtime leaderboard and the card is hidden</b> — but your sessions are still tracked, so flipping this back on later restores everything without losing any playtime.
+                </div>
+              </div>
+              <Switch
+                checked={visibility.shareGamePlaytime}
+                onCheckedChange={(v) => updateVisibility({ shareGamePlaytime: v })}
+                aria-label="Share game playtime publicly"
+              />
+            </div>
             <div className="flex items-start justify-between gap-4 py-2">
               <div className="flex-1 min-w-0">
                 <div className="text-sm font-medium">Pre-download requirement check</div>
@@ -397,7 +416,7 @@ type UpgradeReport = {
   }>
 }
 
-function UpgradeSuggesterSection({ baseUrl }: { baseUrl: string | undefined }) {
+export function UpgradeSuggesterSection({ baseUrl }: { baseUrl: string | undefined }) {
   const [report, setReport] = useState<UpgradeReport | null>(null)
   const [reason, setReason] = useState<string | null>(null)
   const [loading, setLoading] = useState(true)
@@ -418,6 +437,8 @@ function UpgradeSuggesterSection({ baseUrl }: { baseUrl: string | undefined }) {
           setReason(res.reason || res.error || null)
         }
       } catch (err: any) {
+        // ignore
+      } finally {
         setLoading(false)
       }
     })()

renderer/src/vite-env.d.ts

@@ -131,6 +131,10 @@ declare global {
     forums: SystemProfileVisibilityTier
     profilePublic: SystemProfileVisibilityTier
     sysreqCheck: 'off' | 'on'
+    /** When false, user is excluded from the playtime leaderboard and the
+     *  playtime card on their public profile. Sessions still record locally
+     *  and on the server, so flipping back on restores everything. */
+    shareGamePlaytime: boolean
   }
 
   /** Pre-download storage reservation check result from window.ucStorage.precheck. */