check-games

Cross-reference a game wishlist against your Steam, GOG, Humble Bundle, and Epic Games libraries. Then enrich the full owned-game list with Metacritic / Steam review ratings and Apple Silicon (ARM / Rosetta 2 / CrossOver) compatibility from AppleGamingWiki, and browse the results as interactive HTML.

macOS only for the library-scraping step (drives Safari via AppleScript). Everything after that needs Python 3.10+ and nothing else:

• Network required: fetch_ratings.py, best_arm_games.py
• Fully offline: reclassify.py, group_by_type.py, build_explorer.py, build_covers.py (the gallery it writes fetches cover art when opened)

Requirements

• macOS with Safari (only for check_games.py)
• Safari → Develop → Allow JavaScript from Apple Events: ON
• Logged in to Steam, GOG, Humble, and Epic in Safari
• Python 3.10+ (no external dependencies)

Usage

1. Scrape libraries + cross-reference wishlist

# First run (fetches everything, takes a few minutes)
python3 check_games.py

# Subsequent runs use cached data (instant)
python3 check_games.py

# Force re-fetch everything
python3 check_games.py --force

# Force re-fetch only one store
python3 check_games.py --force-store steam

# Change cache TTL (default: 24 hours)
python3 check_games.py --max-age 48

# Custom output directory
python3 check_games.py --output-dir ~/Desktop

2. Re-classify items without re-scraping

If you tweak the classification rules in check_games.py, re-run classification on the existing games_libraries.json in place.

Humble items scraped with bundle/platform/format metadata are re-derived in full, so the book vs comic split can be retuned offline. For every other item only the title-pattern types (game, course, asset, demo, software, wallpaper) are re-evaluated, preserving source-derived types that a title alone can't recover.

python3 reclassify.py

If it reports no Humble metadata, your games_libraries.json predates the metadata capture. Re-scrape just that store:

python3 check_games.py --force-store humble

3. Tabular inventory grouped by type

python3 group_by_type.py
# writes games_by_type.txt

4. Fetch ratings (Metacritic + Steam reviews)

Uses Steam's public store API for Metacritic scores and review summaries, with a Metacritic page-scrape fallback (parses the schema.org aggregateRating JSON-LD block). Resumable via games_ratings_cache.json.

# Full run (1500-ish games at ~1.5s each = ~30 min)
python3 fetch_ratings.py

# Try a small sample first
python3 fetch_ratings.py --limit 20

# Skip the Metacritic fallback
python3 fetch_ratings.py --no-metacritic

# Re-run only the Metacritic-fallback entries (e.g. after a regex fix)
python3 fetch_ratings.py --refresh-metacritic

# Just rebuild the table from the cache without fetching
python3 fetch_ratings.py --write-only

5. Best owned games runnable on Apple Silicon

Queries AppleGamingWiki's Cargo API in batches for the full owned-games list, falls back to Steam's platforms.mac flag for coverage gaps, then joins with the ratings cache and writes a table sorted by best available rating per category (ARM Native, Rosetta 2, Steam macOS, CrossOver).

python3 best_arm_games.py
# writes games_arm.txt and games_silicon_cache.json

# Skip the Steam mac-flag fallback
python3 best_arm_games.py --no-steam

# Just rebuild the table from cache
python3 best_arm_games.py --write-only

6. Interactive Apple Silicon explorer

Turns the fixed-width games_arm.txt table into a single self-contained HTML page with client-side search, filtering and sorting. Titles link to their Steam store page and Metacritic entry where the ratings cache has an appid or URL.

Filters: title search, compatibility category (ARM Native / Rosetta 2 / Steam macOS / CrossOver), store, minimum Metacritic score, and Steam-review threshold. Every column sorts.

python3 build_explorer.py
# reads games_arm.txt (+ games_ratings_cache.json for links)
# writes games_arm.html

# Custom input / output
python3 build_explorer.py --input ~/games_arm.txt --output ~/Desktop/explorer.html

Run best_arm_games.py first, since this only reformats its output and never fetches anything itself.

7. Cover gallery for comics and books

Humble's order API returns a cover thumbnail per item, stored as icon on each Humble library entry. This renders them as a lazy-loading gallery with search plus type and bundle filters, as a single self-contained HTML file.

Three views, all with 140px tiles. Type is marked by a colour dot (orange comic, blue book, green artbook).

• Series rows (default): issues / volumes of the same series on one wrapping row, labelled #1, #2, … and sorted by number, with everything else collected under a Standalone heading. Series are detected by stripping a trailing #N, Vol. N, Issue N, Chapter N, Book N or Part N from the title, so American Flagg! #1…#6 collapses into one row. The pattern requires a digit and refuses to match at position 0, which keeps prose titles like 100 Things to See in the Night Sky and Bookkeeping for Dummies intact.
• Flat grid: every item, alphabetical.
• List: full titles plus bundle name and formats.

The bundle dropdown is faceted: it only lists bundles that contain items matching the active type chips and the has cover only toggle, with counts updated to match (selecting comic narrows it from 181 bundles to the 71 that actually contain comics). If the selected bundle has no items left after a type change, it resets to All bundles and flags that it did, so a filter combination can never strand you on an empty grid. The search box is deliberately left out of this, since rebuilding the dropdown on every keystroke would fight typing.

python3 build_covers.py
# writes games_covers.html

# Include other types
python3 build_covers.py --types comic book artbook soundtrack

# Different tile size (source art is 70x70)
python3 build_covers.py --tile 70

# Custom output path
python3 build_covers.py --output ~/Desktop/covers.html

Covers are hot-linked from Humble's CDN (hb.imgix.net), so the page needs a connection but no server. Items whose cover fails to load fall back to a placeholder tile.

On cover size. Humble serves exactly one image per item, a 70x70 PNG averaging ~4KB. The imgix URLs are signature-signed over the full query string, so appending &w=400 or dropping s= returns 403; a larger render cannot be requested. Tiles default to 140px, a 2x upscale of that source, so expect them to look slightly soft; --tile 70 renders at native resolution instead. The URLs are publicly readable, verified with anonymous requests carrying no cookies and a file:// referer, so there is no need to mirror them locally for access, only for durability against link rot (all ~2,000 items would be roughly 7.5MB).

Note: download_struct entries in the Humble API contain time-limited signed download URLs embedding your gamekey. The scraper deliberately stores only format names, never those URLs, keeping games_libraries.json safe to share.

Output files

File	Producer	Description
games_ownership.json	check_games.py	Full cross-reference results for all wishlist games
games_ownership.txt	check_games.py	Human-readable wishlist summary table
games_owned.json	check_games.py	Wishlist items you own, with stores + Apple Silicon info
games_libraries.json	check_games.py	Complete library dumps from all stores, with item-type classification (plus bundle / platforms / formats / icon for Humble items)
games_cache.json	check_games.py	Library-scraping cache for incremental runs
games_by_type.txt	group_by_type.py	Tabular inventory grouped by item type
games_ratings.txt	fetch_ratings.py	All owned games sorted by Metacritic / Steam rating
games_ratings_cache.json	fetch_ratings.py	Per-title ratings cache (resumable)
games_arm.txt	best_arm_games.py	Owned games runnable on Apple Silicon, sorted by rating
games_silicon_cache.json	best_arm_games.py	AGW + Steam mac-flag cache
games_arm.html	build_explorer.py	Interactive Apple Silicon explorer (search / filter / sort)
games_covers.html	build_covers.py	Interactive cover gallery for comics / books

All output files are gitignored.

Item types

Items are classified using source metadata (Humble download platforms, download formats and bundle names, GOG media types) with title-pattern fallback:

game, book, audio, video, soundtrack, dlc, comic, artbook, demo, software, coupon, wallpaper, course, asset

course covers technical courses / workshops / video tutorials common in Humble book-and-software bundles. asset covers game-development asset packs (tilesets, sprites, icons, sound packs, etc.).

Comics and manga are separated from prose books using two Humble signals, in order:

1. Download format — a CBZ / CBR / CB7 / CBT archive means comic. Per-item and near-definitive, since prose ebooks only ever ship PDF/EPUB/MOBI.
2. Bundle name — for ebooks with no comic archive, a bundle named after a comics imprint (Image, IDW, Dynamite, Dark Horse, Humanoids, Titan, Boom! Studios, manga publishers, etc.) counts as comic. Weaker, because comic bundles sometimes include prose extras, so it is only consulted when signal 1 is absent.

Both are captured per item into games_libraries.json (bundle, platforms, formats), so retuning the rules later needs only reclassify.py, not another scrape.

Customization

Edit the GAMES list at the top of check_games.py to set your own wishlist.

Data sources

• Steam: Store API + community profile page (library scrape via Safari) + public storesearch / appdetails / appreviews APIs (ratings)
• GOG: embed.gog.com account API
• Humble Bundle: Order/library API (subproducts download platforms + download_struct formats + icon cover art, product.human_name bundle title)
• Epic Games: Account transactions page (DOM scraping with pagination)
• Metacritic: Steam's appdetails.metacritic field + Metacritic.com schema.org JSON-LD aggregateRating block (page scrape)
• Apple Silicon: AppleGamingWiki Cargo API (Compatibility_macOS table)