🌐 English · Português

Steam Spec Overlay

Open a game's page on Steam. The overlay tells you, in seconds, if your PC can run it.

No typing anything, no pasting anything, no looking up requirements yourself.

---

What it is

A desktop overlay that sits on top of the Steam window. It detects on its own which game you're looking at, reads the minimum and recommended requirements, compares them against your machine's real hardware, and shows compatibility as a percentage — updating the instant you switch games.

⚠️Windows or Linux (X11/Wayland) + the Steam desktop app. Doesn't work with Steam in a browser, or on macOS. And it isn't an in-game overlay — it's about the store window.

---

How it works

Steam's desktop client is a Chromium (CEF) app that can expose a remote debugging endpoint. The overlay reads that endpoint to find out which page is open — no OCR, no reading pixels, no scraping the native window.

flowchart LR
A["Steam desktop<br/>(CEF remote debugging)"] -->|"/json"| B["steamDebug<br/>extracts the APPID"]
B --> C{"requirements<br/>source"}
C -->|"appdetails API"| D["requirements<br/>+ name + artwork"]
C -->|"fallback:<br/>store page"| D
E["detectSpecs<br/>your hardware"] --> F
D --> F["compare<br/>GPU · CPU · RAM"]
F --> G["% + verdict<br/>+ badges"]

Loading

Two kinds of page are recognized:

Page	How it's detected
Store	a CDP target whose URL is store.steampowered.com/app/<APPID> — works even behind the age gate
Library	the client creates an internal document whose URL carries the /library/app/<APPID> route

Requirements come from Steam's officialappdetails API (a ~5 KB JSON payload that also carries the canonical name and the game's artwork). If the API doesn't know the appid, it falls back to scraping the store page. If CEF debugging is off, there's a fallback mode that reads the Steam window's title. The indicator at the top shows which one is active: CDP (green) or FALLBACK (amber).

Everything is cached to disk: the second launch is instant, and a page you've already opened keeps working without internet.

---

Installation

End user — download from Releases:

Windows:

• Steam Spec Overlay Setup 1.2.0.exe — installer (creates a shortcut, lets you pick the folder)
• Steam Spec Overlay 1.2.0.exe — portable version, runs without installing

The executable isn't signed (a code-signing certificate costs money), so Windows may show a SmartScreen warning on first run. More info → Run anyway.

Linux:

• Steam-Spec-Overlay-1.2.0.AppImage — runs on any distro, no install:

  chmod +x Steam-Spec-Overlay-*.AppImage
  ./Steam-Spec-Overlay-*.AppImage

  Application-menu integration is optional by design — the AppImage runs directly without it. To create a menu shortcut, use an integrator like AppImageLauncher, or your file manager's "Integrate and run" option, if it has one.

  Requires libfuse2. Ubuntu stopped installing it by default starting with 22.04; on 24.04 the package was renamed to libfuse2t64 (the 64-bit time_t transition). Install it with sudo apt install libfuse2t64 (24.04+) or sudo apt install libfuse2 (22.04). Without FUSE, run with ./Steam-Spec-Overlay-*.AppImage --appimage-extract-and-run.

• steam-spec-overlay_1.2.0_amd64.deb — for Debian/Ubuntu and derivatives:

  sudo apt install ./steam-spec-overlay_1.2.0_amd64.deb

Steam itself also needs to be installed — natively (.deb/.rpm) or as a Flatpak. The overlay tries each format's usual paths, but Flatpak and Snap are supported on a best-effort basis, with no formal guarantee across every sandboxing variation.

Development:

npm install
npm start # runs the overlay
npm run verify # tables + self-check + 240 tests
npm run dist # Windows: builds the NSIS installer + portable exe into dist/
npm run dist:linux # Linux: builds AppImage + deb into dist/ (only works running on Linux)

Requires Node.js 18+ (tested on Node 24). Runs on Windows and Linux (X11 or Wayland — see Linux limitations for what changes per environment).

Producing the Linux packages from Windows

electron-builder can't package AppImage/deb/rpm while running on Windows — dpkg-deb, fakeroot and mksquashfs don't exist there. The options:

• GitHub Actions (recommended) — the workflow in .github/workflows/release.yml already does this on every v* tag.
• Docker, from the project root:

  docker run --rm -ti \
  -v ${PWD}:/project \
  -v ~/.cache/electron:/root/.cache/electron \
  -v ~/.cache/electron-builder:/root/.cache/electron-builder \
  electronuserland/builder:24 \
  /bin/bash -c "npm ci && npm run icons && npm run dist:linux"

• WSL2, with the repository cloned inside the Linux filesystem (something like ~/steam-spec-overlay, not/mnt/c/... — I/O on /mnt/c is slow enough to get in the way of npm install).

The winCodeSign symlink problem that blocks npm run dist on a Windows machine without Developer Mode turned on doesn't apply here: winCodeSign is only downloaded for --win targets, and both Docker and WSL2 run a real Linux filesystem, where the Windows restriction (SeCreateSymbolicLinkPrivilege) simply doesn't exist.

---

Required step: turning on CEF debugging

Steam only opens the debug port if there's an empty file called .cef-enable-remote-debugging at the root of its install folder — on Windows, for example C:\Program Files (x86)\Steam\.cef-enable-remote-debugging; on Linux, typically ~/.steam/steam/.cef-enable-remote-debugging (or ~/.var/app/com.valvesoftware.Steam/.steam/steam/... if Steam itself is a Flatpak).

The app does this for you:

1. Open the overlay. With no detection active, it shows an "Ativar debug" button — click it. It finds the Steam folder (through the Windows registry, or the default paths on Linux) and creates the file.
2. Close Steam completely (including the tray icon) and reopen it.
3. The indicator switches to CDP and the overlay starts detecting games on its own.

If creating the file fails due to permissions, create an empty file with that exact name in the Steam folder yourself and restart Steam.

---

Usage

Recommended 60% — "borderline, expect drops"

Minimum 99% — "runs comfortably"

• Open a game's page in the store or in your library. Within seconds you get the artwork, the name, the percentage meter and the GPU / CPU / RAM breakdown, plus badges for SO (OS) / DirectX / Disco (storage) / 64 bits.
• Toggle between Recomendado (Recommended) and Mínimo (Minimum) at the top — the choice is remembered.
• Switching games updates automatically. Leaving the page puts the overlay on standby.
• Global shortcut Ctrl+Shift+S to show/hide. If that combo is taken, it tries Ctrl+Alt+S, then Ctrl+Shift+F10; the active shortcut shows up in settings.
• Global shortcut Ctrl+Alt+C always turns click-through off and brings the window to the front (fallback Ctrl+Shift+C, then Ctrl+Shift+F11). Since click-through makes the window ignore every click — including the checkbox that turns it off — show/hide (Ctrl+Shift+S) alone can't fix that; this shortcut exists specifically to unstick the app without needing to click on it.
• Tray icon with show/hide, always-on-top, click-through, start with the system, and quit. It's also the recovery route if no global shortcut is free — on GNOME/Wayland without the tray extension installed, use Ctrl+Alt+C or just reopen the app: the instance is single, and the window comes back to the front on its own.
• Drag by the title bar to reposition — the position is remembered.

Settings opacity, click-through, autostart…

Compact mode meter only, 316px tall

Settings, cache and logs live under %APPDATA%\steam-spec-overlay\ on Windows, or under ~/.config/steam-spec-overlay/ on Linux — the Abrir pasta de dados (Open data folder) button goes straight there.

_{The screenshots use a reference PC (i5-12400F · RTX 3060 · 16 GB); the app shows your machine's real hardware.}

---

How the percentage is calculated

1. Each requirement field is compared against the machine's real spec.
2. GPU and CPU become a ratio, your score / required score, using internal benchmark tables, and that ratio runs through a curve: matching the requirement exactly scores 70; 1.4× or more scores 100.
3. RAM uses the same curve over GB.
4. Scores combine with weights GPU 45% · CPU 35% · RAM 20%, renormalized only over the components that were identified — an unidentified component is excluded from the math, never guessed at.

The rules that most often change the result in practice:

Rule	Example
"or" means the weakest one	GTX 1060 or RX 580 or Arc A380 is satisfied by any of them → the Arc A380 is the bar
Exclusion clauses are dropped	RX 580 (Intel UHD 630 not supported) doesn't let the UHD become the requirement
VRAM is a separate gate	a faster card with less VRAM than the game asks for has its score capped by that
Generic CPU requirements	4 hardware CPU threads, Dual core 2.8 GHz become a direct comparison of cores/threads/clock
A model outside the table is estimated	interpolated between neighbors in the same family and generation, flagged with ≈ and the ESTIMADO (estimated) badge — never presented as a measurement
Squashed names are understood	GTX1060, HD2600, 9600GT, RX6600XT

---

Limitations

• The % is an estimate, not a measurement. Store requirement text is free-form and imprecise ("or better", "equivalent"). Treat it as an order of magnitude.
• The benchmark tables are internal and estimated: 349 GPUs and 388 CPUs. If your component shows up as "não identificado" (not identified), it's not in the table and couldn't be estimated either — just add a line (lowercase key → relative score) and run npm run verify.
• The DirectX badge reflects what Windows exposes (including when running through Proton on Linux); the real feature level also depends on the GPU, which is why it's informational and kept out of the score. On native Linux, with no Windows underneath, this badge simply doesn't appear.
• Detection depends on the Steam client's behavior (the debug flag, the CDP port). Valve can change that, which is why the fallback mode exists.
• Console-only games, or ones with no PC requirements block, show up as "requisitos indisponíveis" (requirements unavailable).

Linux limitations

Environment	Transparency	Always on top	Click-through	Global shortcut	Position saved	Tray
X11 (with compositor)	Yes	Yes	Yes	Yes	Yes	Yes
X11 (no compositor)	No — solid black background	Yes	Yes	Yes	Yes	Yes
Wayland · KDE (KWin)	Yes	Yes	Yes, with 30-290ms of latency	No	No	Yes (native)
Wayland · GNOME (Mutter)	Yes	No	Not reliable	No	No	Only with extension
Wayland · other (Sway, Hyprland…)	Unverified	Unverified	Unverified	No	No	Unverified

• No compositor on X11 isn't detected automatically — that would need a native binding outside this app's scope. If the window renders with a solid black background instead of transparent, turn on Desativar transparência (Disable transparency) in settings; the app applies that on the next launch.
• The global shortcut doesn't work on any Wayland session today — this is a limitation of Electron itself (the xdg-desktop-portal handshake for registering global shortcuts isn't implemented). Without a shortcut and without a reliable tray, the app refuses to turn click-through on, so the window can never get stuck; use the tray icon, or reopen the app.
• Window position isn't saved on Wayland — the protocol doesn't let a client ask for or set its own screen position; the overlay always opens in the default corner.
• The tray on GNOME/Wayland needs the "AppIndicator and KStatusNotifierItem Support" extension, installed separately by the user — without it, the overlay has no way to know the tray exists.
• Steam Deck, Game Mode: out of scope. The Deck's gamescope exposes only one overlay slot (GAMESCOPE_EXTERNAL_OVERLAY), permanently held by mangoapp even while hidden, and it doesn't implement xdg-desktop-portal. Desktop Mode works normally — it's KDE Plasma Wayland, same row as the table above.

---

Quality

npm run verify

Runs three gates in sequence:

Gate	What it checks
scripts/validate-tables.js	duplicates, keys the matcher can never reach, monotonicity within each family/generation, and ordering anchors
scripts/selfcheck.js	an end-to-end smoke test with no network and no Electron — including whether every window.api.* the renderer uses exists in the preload and has a handler in main
node --test	240 unit tests

---

Rolling back to a previous version

This repository's history keeps both earlier versions as tags:

git checkout v0.1.0 # original version
git checkout v1.0.0 # earlier stable version
git checkout main # back to the top

To run the old version: git checkout v0.1.0 && npm install && npm start. What changed between them is in CHANGELOG.md.

---

Structure

steam-spec-overlay/
main.js Electron process: window + tray + orchestration + IPC
preload.js secure main↔renderer bridge (contextIsolation)
index.html
styles.css
renderer.js overlay UI (HUD)
lib/
steamDebug.js finds the CDP port, reads /json, extracts the appid (store + library)
steamSetup.js finds the Steam folder (registry), creates the debug flag
steamApi.js appdetails API + page fallback + cache + artwork
steamScraper.js parsing of requirement blocks (fragment and full page)
detectSpecs.js the real machine specs (systeminformation), cached
compare.js CPU/GPU matching, "or" semantics, estimator, % calculation
extras.js OS / DirectX / storage / 64-bit
windowFallback.js plan B via window title (tasklist)
session.js detects X11/Wayland, the compositor, and what each capability supports
autostart.js XDG autostart entry (~/.config/autostart) on Linux
settings.js persistent, validated preferences
cache.js disk cache with TTL and stale reads
logger.js rotating file log
jsonFile.js JSON read/write that survives a corrupted file
appPaths.js resolves the data directory (Electron or plain Node)
data/
cpu-benchmarks.json 388 entries
gpu-benchmarks.json 349 entries
scripts/
make-icon.js generates the app icon in code (PNG + ICO, no external asset)
validate-tables.js checks the benchmark tables for consistency
selfcheck.js smoke test of the whole pipeline
test/ 240 tests (node:test)

The app icon isn't a hand-drawn file — it's rendered in code in plain Node (a PNG encoder over zlib + an ICO container with BMP entries), so npm run icons regenerates all of it on any machine.

---

License

MIT.