feat(shortcuts): a Gaming mode tile for the game, made and reversed by the Ready screen (Steam Deck) #130

Open
omgitsgela wants to merge 20 commits from omgitsgela/LongshotLauncher:feat/steam-gamemode-tile into main
First-time contributor

Why this is needed

On a Steam Deck — where the launcher's Linux support is aimed — a game you cannot start from Gaming mode is a game you cannot start from the couch. Today the tile has to be added by hand through Steam's own dialog in Desktop mode. This makes the launcher's Ready screen offer the tile and, with the untick, take exactly that tile away again.

What it does

  • Core/SteamShortcuts.cs: writes and removes the tile in shortcuts.vdf, in the exact binary grammar Steam's own writer uses, and computes the tile's appid the way Steam does: crc32(Exe + AppName) | 0x80000000, read signed — the rule ChimeraOS, Heroic and SteamTinkerLaunch all write to. Keeping the id honest is what makes the tile the game's: Steam keys grid art, controller settings and play time off that id.
  • The Ready screen's third tick (shown only where a Steam exists to add to): the tile starts ticked like the desktop and applications-menu ticks, so an install leaves something to press in Gaming mode, in Gaming mode's own library.
  • Ours-or-theirs is the appid, never the name: a tile the user added in Steam's own dialog stays exactly as they made it (a second tile named Longshot is refused, and the screen says why). A launcher that updated keeps the one tile it made, pointed at the newest copy — the marker beside the file records the id, and the marker's id has to be one Steam's rule could have written.
  • The tile runs the launcher's --play, like the desktop and menu shortcuts, so "Play starts this version" holds in Gaming mode too.
  • The artwork, which is three things, and the first version of this PR had that wrong (see below): the small icon, the library tile's capsule, and the tile's wordmark — the shipped capsule art showed only the weapon glyph, while the emulator's own start-up screen signs its picture with the LONGSHOT name under it (see the wordmark section).
  • Nothing stops Steam without the user being asked: Add/Remove work while Steam runs; takeDown exists for a caller that asked first, so a download is never cut. After a change made while Steam runs, the screen tells the user the one thing that does apply it: restart the console.

The artwork: what the icon field is, and what the tile actually shows

An earlier revision of this description said the icon field draws the tile's art and that one longshot.png covers all three shortcuts. A Deck with the tile installed and a blank tile in Gaming mode says otherwise, so the claim is retracted and the mechanism is now measured rather than inferred:

  • The icon field is the small application icon — the overlay, not the poster. Desktop and applications-menu entries draw a .png happily; Steam's own tiles name an .ico, so the tile field names the embedded longshot.ico and only when that write actually landed (an icon field naming a file that isn't there is a blank square).
  • The Gaming-mode library tile's art is a pre-baked capsule in userdata/<account>/config/grid/, keyed by the tile's appid read unsigned: <id>.png landscape 920x430, <id>p.png portrait 600x900 (suffix p, no underscore — that one is the library tile), <id>_hero.png, <id>_logo.png. A bare tile with no capsules shows the blank default, which is precisely what happened on hardware.
  • The same art answers to a second name. Steam also keys a shortcut's art by (appid << 32) | 0x02000000 (Steam ROM Manager's lengthenAppId, Ice's filename_for_shortcut). Ground truth on the Deck: a working tile's landscape capsule sits byte-identical at 2827843537.png and 12145495509653520384.png, and the second is exactly that formula. So both names get written; the two names are one slot seen by two UIs.
  • Art is written only when absent, and "absent" is judged wide and atomically. Steam's own library holds .jpg as readily as .png, so any file of any extension in a slot, under either name, means the user chose it and it stands. The check and the publish are one step (AtomicFile.WriteIfAbsent: temp, flush, publish without replace) because Steam's own UI can publish into that folder at any moment and an exists-then-overwrite sequence would rename straight over the user's choice. A half-written .tmp does not count as held: it is an interrupted publish, and treating one as the user's art would leave the tile blank on every launch afterwards. Temps are left on disk rather than deleted — same shape whatever wrote them, and clearing them could break a capsule Steam is mid-saving.

The wordmark: the tile carries the name as well as the glyph

The shipped capsule art showed the weapon glyph alone; the emulator's own start-up screen (gpu/vk/vk_menu.cpp draw_startup, gpu/vk/vk_ui.h) signs its picture with LONGSHOT under the glyph — Libertinus Serif Semibold (the fallback face the start-up screen itself uses; the game's own menu font is game data and cannot ship) in cream (246,232,204), letters spaced by 0.14 of their size, and the gold (214,170,96) flourish (faint rule, two mirrored bezier curls, centre diamond) under the word. The four slots now carry that same lockup: glyph top, name directly under it, flourish under the name.

Not hand-painted, and not hand-editable either: scripts/make_artwork.py composes the four slot files from the shipped pre-wordmark art, kept beside them as src_<slot>.png originals — the script reads only the originals and writes only the slots, because recomposing a recomposition doubles the glyph's soft glow into a fringe with every pass (a review pass caught exactly that in the first version). The capsules save RGB and the logo keeps real alpha: Steam scales with premultiplied alpha, and a capsule carrying a near-opaque alpha channel renders its dark edges wrong. The field the glyph sits on is sampled from the corners, never assumed. Re-running over unchanged originals reproduces the slot files byte for byte (md5-checked); App/Assets/steam/README-artwork.md carries the recipe and says a real artwork change means replacing the src_ originals and re-running the script, with a look at the output as part of the change. The Libertinus OFL licence ships beside the font; the src_ originals are build inputs and are excluded from the shipped binary (csproj).

How Steam's library actually behaves (measured on a Deck LCD)

  • Steam reads shortcuts.vdf when it starts and keeps the library in memory after that. A tile written while it runs is correct on disk and shows at Steam's next start — an earlier version of this description claimed Steam watches the file and reloads it, the way Heroic adds tiles; hardware says otherwise, and the code's comments now say so too.
  • Steam can write its in-memory library back over the file when it quits, which is why the write and the marker keep a coherent order and why Remove takes Steam down before reading when the caller consented.
  • Grid art is read on demand, when the tile is drawn, not at startup: an inotify watch on grid/ saw nothing across two Steam restarts, then the running UI requested the file. (A watcher that prints nothing is not evidence Steam never reads it — self-test the watcher first.)
  • The apply step that works for an end user, tested by the person who found this: a console restart. The tile then sits at the end of Gaming mode's library (where non-Steam tiles go) and launches the game. The launcher never restarts Steam itself, downloads and all; it says what to do instead.

What was checked (game-free, in the suite)

tests/launcher_core/SteamChecks.cs over fixtures from tests/make_steam_vdf_fixture.py:

  • Steam's appid rule reproduced from an authored vector: the tile the Deck's own Steam wrote for EmulationStation (id -1467123759, quoted Exe with spaces) comes out of the rule.
  • add/remove around a library that already holds two foreign tiles: their file comes back byte for byte identical, their tiles untouched.
  • a hand-made tile named Longshot (their id, their Exe): never replaced, never removed.
  • a launcher that updated: its one tile moves, no second tile.
  • the marker beside the file names the tile we wrote; a marker that can't be read is no claim.
  • the tile's icon field names the .ico only when the logo actually landed; desktop and menu entries point at the .png; the appid does not move.
  • capsules: each free slot fills under both the 32-bit and 64-bit names; a .jpg the user put in a slot holds it under either name with no competing .png beside it; an interrupted .tmp does not hold a slot and is not deleted; GridId64 reproduces the Deck's own working id pair.
  • every new text in every catalog (scripts/translations.py).

launcher core: 1439 checks passed; test_release.py OK (both re-run on the wordmark commits). (One check in BusyChecks.cs had gone stale against #121 and is fixed in the first commit — main's suite stops at it today.)

Ground truth the format came from

A byte-faithful copy of this Deck's real shortcuts.vdf (10 tiles, EmulationStation among them) parses with this code, and the reference vdf Python library — which round-trips that file byte for byte — parses the fixtures. The grammar detail the copy taught us: maps close on a lone 0x08, not 00 00.

Hardware, on the Deck itself

  • The tile went into the live library while Steam ran (10 tiles to 11), and the reversal brought the file back byte-identical.
  • A console restart made the tile appear in Gaming mode, and the game launched from the tile on the couch. That is the test behind the toast's wording.
  • Desktop mode: the launcher's own desktop icon shows the green logo (longshot.desktop → ~/.local/share/longshot/launcher/longshot.png), and the desktop library view renders the capsule. Crops of just the Longshot entries are attached; the full library is not, deliberately.
  • Gaming mode, machine evidence instead of a photograph (this one is for the pre-wordmark capsules; the wordmark capsules ride the same slots and mechanism, and their render on a Deck is the next hardware tick once a launcher build carrying them is installed and the console restarts): the running Big-Picture UI (Chromium, --remote-debugging-port=8080) requested customimages/2834237626p.png for our tile — our unsigned appid, our portrait capsule — the <img> reported complete:true at natural 600x900, and the served asset returned 200 with 131,186 bytes, md5-identical to this branch's embedded capsulep_600x900.png. That is the blank tile fixed, proven from inside Steam rather than from a screenshot. A readable Gaming-mode screenshot is still owed: spectacle sees nothing under gamescope, ffmpeg -f x11grab :0.0 and a clipped CDP capture both return black, and GAMESCOPECTL_REQUEST_SCREENSHOT is not settable on this image.

Not in this PR, on purpose

The uninstaller's reversal of the tile (the Ready screen's untick is the reversal today; an uninstall path for the tile itself belongs with the uninstall work), and Steam's own dialogs are never scripted.

## Why this is needed On a Steam Deck — where the launcher's Linux support is aimed — a game you cannot start from Gaming mode is a game you cannot start from the couch. Today the tile has to be added by hand through Steam's own dialog in Desktop mode. This makes the launcher's Ready screen offer the tile and, with the untick, take exactly that tile away again. ## What it does - `Core/SteamShortcuts.cs`: writes and removes the tile in `shortcuts.vdf`, in the exact binary grammar Steam's own writer uses, and computes the tile's `appid` the way Steam does: `crc32(Exe + AppName) | 0x80000000`, read signed — the rule ChimeraOS, Heroic and SteamTinkerLaunch all write to. Keeping the id honest is what makes the tile the game's: Steam keys grid art, controller settings and play time off that id. - The Ready screen's third tick (shown only where a Steam exists to add to): the tile starts ticked like the desktop and applications-menu ticks, so an install leaves something to press in Gaming mode, in Gaming mode's own library. - Ours-or-theirs is the appid, never the name: a tile the user added in Steam's own dialog stays exactly as they made it (a second tile named Longshot is refused, and the screen says why). A launcher that updated keeps the one tile it made, pointed at the newest copy — the marker beside the file records the id, and the marker's id has to be one Steam's rule could have written. - The tile runs the launcher's `--play`, like the desktop and menu shortcuts, so "Play starts this version" holds in Gaming mode too. - The artwork, which is three things, and the first version of this PR had that wrong (see below): the small icon, the library tile's capsule, and the tile's wordmark — the shipped capsule art showed only the weapon glyph, while the emulator's own start-up screen signs its picture with the LONGSHOT name under it (see the wordmark section). - Nothing stops Steam without the user being asked: `Add`/`Remove` work while Steam runs; `takeDown` exists for a caller that asked first, so a download is never cut. After a change made while Steam runs, the screen tells the user the one thing that does apply it: restart the console. ## The artwork: what the icon field is, and what the tile actually shows An earlier revision of this description said the `icon` field draws the tile's art and that one `longshot.png` covers all three shortcuts. A Deck with the tile installed and a blank tile in Gaming mode says otherwise, so the claim is retracted and the mechanism is now measured rather than inferred: - **The `icon` field is the small application icon** — the overlay, not the poster. Desktop and applications-menu entries draw a `.png` happily; Steam's own tiles name an `.ico`, so the tile field names the embedded `longshot.ico` and only when that write actually landed (an icon field naming a file that isn't there is a blank square). - **The Gaming-mode library tile's art is a pre-baked capsule in `userdata/<account>/config/grid/`**, keyed by the tile's appid read **unsigned**: `<id>.png` landscape 920x430, `<id>p.png` portrait 600x900 (suffix `p`, no underscore — that one is the library tile), `<id>_hero.png`, `<id>_logo.png`. A bare tile with no capsules shows the blank default, which is precisely what happened on hardware. - **The same art answers to a second name.** Steam also keys a shortcut's art by `(appid << 32) | 0x02000000` (Steam ROM Manager's `lengthenAppId`, Ice's `filename_for_shortcut`). Ground truth on the Deck: a working tile's landscape capsule sits **byte-identical** at `2827843537.png` and `12145495509653520384.png`, and the second is exactly that formula. So both names get written; the two names are one slot seen by two UIs. - **Art is written only when absent, and "absent" is judged wide and atomically.** Steam's own library holds `.jpg` as readily as `.png`, so any file of any extension in a slot, under either name, means the user chose it and it stands. The check and the publish are one step (`AtomicFile.WriteIfAbsent`: temp, flush, publish without replace) because Steam's own UI can publish into that folder at any moment and an exists-then-overwrite sequence would rename straight over the user's choice. A half-written `.tmp` does **not** count as held: it is an interrupted publish, and treating one as the user's art would leave the tile blank on every launch afterwards. Temps are left on disk rather than deleted — same shape whatever wrote them, and clearing them could break a capsule Steam is mid-saving. ## The wordmark: the tile carries the name as well as the glyph The shipped capsule art showed the weapon glyph alone; the emulator's own start-up screen (`gpu/vk/vk_menu.cpp` `draw_startup`, `gpu/vk/vk_ui.h`) signs its picture with LONGSHOT under the glyph — Libertinus Serif Semibold (the fallback face the start-up screen itself uses; the game's own menu font is game data and cannot ship) in cream `(246,232,204)`, letters spaced by 0.14 of their size, and the gold `(214,170,96)` flourish (faint rule, two mirrored bezier curls, centre diamond) under the word. The four slots now carry that same lockup: glyph top, name directly under it, flourish under the name. Not hand-painted, and not hand-editable either: `scripts/make_artwork.py` composes the four slot files from the shipped pre-wordmark art, kept beside them as `src_<slot>.png` originals — the script reads only the originals and writes only the slots, because recomposing a recomposition doubles the glyph's soft glow into a fringe with every pass (a review pass caught exactly that in the first version). The capsules save RGB and the logo keeps real alpha: Steam scales with premultiplied alpha, and a capsule carrying a near-opaque alpha channel renders its dark edges wrong. The field the glyph sits on is sampled from the corners, never assumed. Re-running over unchanged originals reproduces the slot files byte for byte (md5-checked); `App/Assets/steam/README-artwork.md` carries the recipe and says a real artwork change means replacing the `src_` originals and re-running the script, with a look at the output as part of the change. The Libertinus OFL licence ships beside the font; the `src_` originals are build inputs and are excluded from the shipped binary (`csproj`). ## How Steam's library actually behaves (measured on a Deck LCD) - Steam reads `shortcuts.vdf` when it starts and keeps the library in memory after that. A tile written while it runs is correct on disk and shows at Steam's next start — an earlier version of this description claimed Steam watches the file and reloads it, the way Heroic adds tiles; hardware says otherwise, and the code's comments now say so too. - Steam can write its in-memory library back over the file when it quits, which is why the write and the marker keep a coherent order and why `Remove` takes Steam down before reading when the caller consented. - Grid art is read **on demand, when the tile is drawn**, not at startup: an inotify watch on `grid/` saw nothing across two Steam restarts, then the running UI requested the file. (A watcher that prints nothing is not evidence Steam never reads it — self-test the watcher first.) - The apply step that works for an end user, tested by the person who found this: a console restart. The tile then sits at the end of Gaming mode's library (where non-Steam tiles go) and launches the game. The launcher never restarts Steam itself, downloads and all; it says what to do instead. ## What was checked (game-free, in the suite) `tests/launcher_core/SteamChecks.cs` over fixtures from `tests/make_steam_vdf_fixture.py`: - Steam's appid rule reproduced from an authored vector: the tile the Deck's own Steam wrote for EmulationStation (id `-1467123759`, quoted `Exe` with spaces) comes out of the rule. - add/remove around a library that already holds two foreign tiles: their file comes back byte for byte identical, their tiles untouched. - a hand-made tile named Longshot (their id, their Exe): never replaced, never removed. - a launcher that updated: its one tile moves, no second tile. - the marker beside the file names the tile we wrote; a marker that can't be read is no claim. - the tile's icon field names the `.ico` only when the logo actually landed; desktop and menu entries point at the `.png`; the appid does not move. - capsules: each free slot fills under both the 32-bit and 64-bit names; a `.jpg` the user put in a slot holds it under **either** name with no competing `.png` beside it; an interrupted `.tmp` does not hold a slot and is not deleted; `GridId64` reproduces the Deck's own working id pair. - every new text in every catalog (`scripts/translations.py`). `launcher core: 1439 checks passed`; `test_release.py` OK (both re-run on the wordmark commits). (One check in `BusyChecks.cs` had gone stale against #121 and is fixed in the first commit — main's suite stops at it today.) ## Ground truth the format came from A byte-faithful copy of this Deck's real `shortcuts.vdf` (10 tiles, EmulationStation among them) parses with this code, and the reference `vdf` Python library — which round-trips that file byte for byte — parses the fixtures. The grammar detail the copy taught us: maps close on a lone `0x08`, not `00 00`. ## Hardware, on the Deck itself - The tile went into the live library while Steam ran (10 tiles to 11), and the reversal brought the file back byte-identical. - A console restart made the tile appear in Gaming mode, and the game launched from the tile on the couch. That is the test behind the toast's wording. - Desktop mode: the launcher's own desktop icon shows the green logo (`longshot.desktop` → `~/.local/share/longshot/launcher/longshot.png`), and the desktop library view renders the capsule. Crops of just the Longshot entries are attached; the full library is not, deliberately. - Gaming mode, machine evidence instead of a photograph (this one is for the pre-wordmark capsules; the wordmark capsules ride the same slots and mechanism, and their render on a Deck is the next hardware tick once a launcher build carrying them is installed and the console restarts): the running Big-Picture UI (Chromium, `--remote-debugging-port=8080`) requested **`customimages/2834237626p.png`** for our tile — our unsigned appid, our portrait capsule — the `<img>` reported `complete:true` at natural 600x900, and the served asset returned 200 with 131,186 bytes, md5-identical to this branch's embedded `capsulep_600x900.png`. That is the blank tile fixed, proven from inside Steam rather than from a screenshot. A readable Gaming-mode screenshot is still owed: `spectacle` sees nothing under gamescope, `ffmpeg -f x11grab :0.0` and a clipped CDP capture both return black, and `GAMESCOPECTL_REQUEST_SCREENSHOT` is not settable on this image. ## Not in this PR, on purpose The uninstaller's reversal of the tile (the Ready screen's untick is the reversal today; an uninstall path for the tile itself belongs with the uninstall work), and Steam's own dialogs are never scripted.
The check reads HomeViewModel.cs and asks for the line without the third term #121
added, so the game-free suite has stopped at that check on main since then. It is
the check that is stale, not the behaviour it guards: Build is still off while the
check runs, while the launcher updates itself, and now also while old versions'
folders are deleted, which is what the source says.

Assisted-by: GPT-6 Astra
On a Deck, a build that only has a desktop shortcut is still a desktop chore: the
game has to be added to Steam by hand to be playable from the couch. This makes the
Ready screen offer the tile itself, and the untick take it away again.

Steam's own file, Steam's own rules. shortcuts.vdf in the exact grammar Steam's
writer uses (a type 0 section is 00 name 00 body 08, and a lone 08 closes every
map, not 00); the tile's appid as Steam computes it, crc32(Exe + AppName) with the
high bit set read signed, the rule ChimeraOS, Heroic and SteamTinkerLaunch all
write to. Keeping the id honest is what makes the tile the game's: Steam keys its
grid art, controller settings and play time off that id, so a tile made here and
one added in Steam's own dialog behave the same. Both were checked against the
file Steam wrote on a Deck: the real file parses, the ids it holds come out of the
rule, and the reference vdf library (which round-trips the real file byte for byte)
parses the fixtures here.

The tile starts the launcher's --play like the desktop and applications-menu
shortcuts, so it follows "Play starts this version" and an update's new folder.
Ours or theirs is decided by the id and a marker beside the file: a tile the user
made by hand in Steam under the same name is left exactly as they made it, and our
add and remove leave their file byte for byte identical. A launcher that updated
keeps the one tile, pointed at the newest copy, because the AppImage's name changes
with every release. Nothing is done to Steam itself without the user: the core can
ask Steam to quit through its own -shutdown, but only a caller that has asked the
user first passes that flag, so downloads are never cut.

Checks: SteamChecks.cs over fixtures made by tests/make_steam_vdf_fixture.py; every
new text in every catalog. The BusyChecks fix above is why the suite runs again.

Assisted-by: GPT-6 Astra
review: the tile is found by Steam's id, not by the name Longshot
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
0e1e9ee44a
The first cut looked a tile up by its name and then asked whether it was ours. A
tile the user made in Steam's own dialog under the name Longshot got past that in
two ways: the marker beside the file vouched for any id it was told to carry, and
the Ready screen's first call wrote a removal before anyone was asked. Both are
gone:

- identity is the appid alone (this launcher's, or the id the marker recorded), so
  Steam's own dialog's tile is a different id and is out of reach everywhere; Add
  refuses rather than putting a second tile of the same name in the grid, and says
  why, with the tick back to what the library holds
- the marker's id is checked as a rule could have written it, and a marker that
  cannot be read is no claim at all
- the Steam tick starts on like the desktop and menu ticks: an install leaves
  something to press; the first write only ever adds

Assisted-by: GPT-6 Astra
review round two: keys never double, a marker never outranks the tile it describes
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
0464d74fd6
A second review pass found real holes the first round's fixes left:

- Remove left the numbered keys as they were and Add keyed a new tile by the item
  count, so a library with a hole (an outside edit, an older Steam) could get two
  tiles under one key, and reading it back loses one that was not ours. Add now
  takes the first free key; a check makes the hole and asserts no key repeats
- the sidecar marker vouched for any id it carried, so a stale marker beside a
  tile the user re-pointed in Steam's Properties claimed that tile. The claim now
  holds only while the tile still points at the Exe the marker recorded, and the
  check relabels a tile byte for byte and proves it stays the user's
- Remove read the file before taking Steam down, so Steam's own quit-time flush
  was overwritten by the pre-shutdown snapshot; the order is down-then-read now
- Locate and the first library read ran outside the catch: a permissions fault
  there took the Ready screen down instead of hiding its tick. They are inside
  now, InLibrary answers false for an unreadable library rather than throwing,
  and an unasked screen never writes a Remove: the desktop-or-menu ticks changing
  after a failed Add cannot delete a tile the user did not untick
- a type-5 float parsed but wrote back as type 3, quietly retyping a field we do
  not own: refused instead, and the check proves a file holding one is left alone
- SteamUp's /proc scan parsed the whole path as a number, so it saw no process
  ever: fixed, given a proc root the checks can point at a fake, and the fake
  proves both the sighting and the absence; steam.sh -shutdown no longer
  redirects output it never drains (a talking helper deadlocked the wait)

Assisted-by: GPT-6 Astra
Author
First-time contributor

Second delegated review pass; its findings are in 0464d74:

  • Add keyed new tiles by item count, Remove left gaps: a library with a hole could get two tiles under one key (reading it back loses a foreign tile). Add now takes the first free key; a check makes the hole and asserts no key repeats.
  • The sidecar marker vouched for any id it carried: a stale marker beside a tile the user re-pointed in Steam's Properties claimed that tile. The claim now holds only while the tile still points at the Exe the marker recorded (check relabels the tile byte for byte and proves it stays the user's).
  • Remove read the library before taking Steam down, so Steam's quit-time flush was overwritten by the pre-shutdown snapshot; order is down-then-read now.
  • Locate/first read ran outside the catch: a permissions fault took the Ready screen down. Now inside; InLibrary answers false for an unreadable library; and an unasked screen never writes a Remove, so a failed Add plus a desktop-tick change cannot delete an intact tile.
  • Type-5 floats parsed but wrote back as type 3, quietly retyping a foreign field: refused; a check proves the file is left byte-identical.
  • SteamUp parsed /proc paths whole, so it saw no process ever: fixed, and the scan now takes a proc root so the checks prove both sighting Steam and its absence in a fake /proc; steam.sh -shutdown no longer redirects output it never drains.
Second delegated review pass; its findings are in 0464d74: - Add keyed new tiles by item count, Remove left gaps: a library with a hole could get two tiles under one key (reading it back loses a foreign tile). Add now takes the first free key; a check makes the hole and asserts no key repeats. - The sidecar marker vouched for any id it carried: a stale marker beside a tile the user re-pointed in Steam's Properties claimed that tile. The claim now holds only while the tile still points at the Exe the marker recorded (check relabels the tile byte for byte and proves it stays the user's). - Remove read the library before taking Steam down, so Steam's quit-time flush was overwritten by the pre-shutdown snapshot; order is down-then-read now. - Locate/first read ran outside the catch: a permissions fault took the Ready screen down. Now inside; InLibrary answers false for an unreadable library; and an unasked screen never writes a Remove, so a failed Add plus a desktop-tick change cannot delete an intact tile. - Type-5 floats parsed but wrote back as type 3, quietly retyping a foreign field: refused; a check proves the file is left byte-identical. - SteamUp parsed /proc paths whole, so it saw no process ever: fixed, and the scan now takes a proc root so the checks prove both sighting Steam and its absence in a fake /proc; steam.sh -shutdown no longer redirects output it never drains.
Owner

Screenshots please!

Screenshots please!
feat(linux): the Steam tile, desktop file and menu file all carry the Longshot logo
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
3d462bb50d
The Steam tile wrote icon "" and showed the blank default in Gaming mode; the
Deck's own EmulationStation tile proves the icon field is what Steam draws.
One logo file, written once under the launcher home, feeds all three Linux
shortcuts. The appid does not move (icon is not part of Steam's id rule), and
an older tile of ours gets the icon on the next write.

Also: the Ready-screen toast now tells users to restart the console, the one
apply path hardware proved works, and SteamShortcuts' comments stop claiming
a live reload that the Deck disproved.
omgitsgela changed title from WIP: feat(shortcuts): a Gaming mode tile for the game, made and reversed by the Ready screen (Steam Deck) to feat(shortcuts): a Gaming mode tile for the game, made and reversed by the Ready screen (Steam Deck) 2026-11-16 03:16:24 +00:00
review: a tile keeps the art it has, and a stale logo gets repaired
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
01c181ab3d
Three points from the delegated review of 3d462bb, all real, all edge cases:

- Update/Same treat an empty icon as claiming nothing: a caller whose logo write
failed no longer rewrites a working tile to point at a file that was never
written. The upgrade order that matters (tile first, logo later) is now its own
check, with the id pinned on both sides of it.
- EnsureLogo compares the file against the embedded logo and rewrites when they
differ, so a truncated png or a newer logo from a launcher update is repaired
instead of trusted forever.
- The restart notice no longer talks over a shortcuts-write failure: one toast
shows at a time, and the error outranks the note.

launcher core: 1418 checks passed; release OK.
fix(linux): the Steam tile names an .ico; the capsules, not the icon field, are the tile's art
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
6810eef2ee
Hardware, Deck LCD: a tile whose icon field pointed at longshot.png showed the blank
default after a full console restart, while every tile in the Deck's own library that
draws art names a .ico (EmulationStation's grid _icon.ico) and carries pre-baked
capsules in config/grid/ keyed by its appid. Heroic writes an .ico into the same field
for the same reason. The tile now names longshot.ico (the launcher's own Assets copy,
embedded and written beside the .png, repaired when it differs); the desktop and menu
files keep the .png, which KDE draws correctly. Grid art for the tile's appid is a
separate piece of work and is not in this commit.
feat(linux): the tile's real art: capsules in Steam's grid/, written only when missing
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
9206814a1f
Hardware + research, Deck LCD: a Gaming-mode library tile draws from pre-baked capsule
images in grid/ beside shortcuts.vdf, keyed by the tile's appid read UNSIGNED -
<id>p.png portrait 600x900 (the library tile itself), <id>.png landscape 920x430
(the recently-played row), _hero/_logo on the detail page. The icon field is only
the small overlay icon (Steam ROM Manager's source: "Steam shows the icon named in
shortcuts.vdf, not the grid's"; Heroic writes the same capsule names for the same
reason). Our tile showed the blank default because it had no capsules at all, not
because of the icon field. The Ready screen now drops the launcher's own artwork
(embedded, generated from the green logo) into grid/ for the appid the library tile
actually carries - write-if-absent, so a capsule the user chose in Steam's own UI
is never replaced.

Assisted-by: GPT-6 Astra
fix(linux): a shortcut's capsules answer to a SECOND name: (appid << 32) | 0x02000000
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
20ca2ea2dd
The Deck's own library settled the question. EmulationStation's working tile carries
its landscape capsule byte-identical under two names: 2827843537.png (the crc32 appid
from shortcuts.vdf, what the new library UI reads) and 12145495509653520384.png, which
is exactly (2827843537 << 32) | 0x02000000 — Steam ROM Manager's lengthenAppId, the
same 64-bit id Ice's filename_for_shortcut writes and the old Big Picture reads. Our
32-bit capsules alone left the tile blank on hardware; WriteArtwork now writes every
piece under both names. Check pinned to the Deck's numbers: GridId64(-1467123759)
must equal 12145495509653520384.

Assisted-by: GPT-6 Astra
review: a capsule slot the user holds is theirs under every name and every format
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
caeaf241d2
Delegated review of the capsule work, three findings, all real:

- "Never overwrite" was not atomic: File.Exists, then AtomicFile.Write renamed with
  overwrite:true, and Steam's own UI publishes capsules at any moment — the window
  between look and rename was us possibly renaming over art the user just chose.
  AtomicFile.WriteIfAbsent: same temp-then-publish, but the rename itself is the gate
  (MoveFileEx without REPLACE_EXISTING / rename O_EXCL), no mutex needed for a
  non-replacement.
- Formats: the Deck's grid/ shows Steam's own art in .jpg as readily as .png
  (4100769614p.jpg). A .png of ours beside a .jpg of theirs is a coin flip in Steam,
  so any file in a slot, ANY extension, means the slot is taken.
- The two names (32-bit and 64-bit) are one slot seen by two UIs: art held under
  either name is held, and we never fill only the other half. Caught by the suite,
  not by reading — the fixture now seeds a .jpg hero under the 32-bit name only, and
  neither name gets our .png.

The first review's minor (a failed .ico extraction still naming the tile at a missing
file) was already fixed at 9206814; re-verified here.

Assisted-by: GPT-6 Astra
review: a half-written temp is not a capsule the user chose
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
8ed8f1bab4
The capsule review's own fix had a hole in it, and my first attempt at closing
it made it worse, so both are worth recording.

WriteArtwork asks "does any file already sit in this slot" with the glob
<stem><suffix>.* — deliberately wide, because Steam's own library art is not
always .png (this Deck holds 4100769614p.jpg). But AtomicFile publishes as
<target>.<guid>.tmp and then renames. That temp matches the wide glob. A launch
interrupted between the write and the rename therefore leaves a file that reads
as "the user's art", the slot is declared held, and the tile stays blank on
every launch afterwards with no way back except deleting files by hand.

Fix: a .tmp never counts as holding a slot. It is left on disk rather than
removed. Removing it was my first instinct and it is wrong: the temp has the
same shape whatever wrote it, so a launcher that deletes temps in the grid
folder can break a capsule Steam is mid-saving. Deleting the user's in-flight
art to work around a stale file we did not create is the exact harm this
feature exists to avoid, and once any real file lands in the slot the temp is
inert anyway.

Two checks: the tile's art still lands when a temp sits in the slot, and a temp
we did not write survives us. Suite: 1435 checks.
Author
First-time contributor

description rewritten after hardware: the icon field is only the small overlay icon, and the Gaming-mode tile's art is the capsule grid files under both the 32-bit appid name and (appid << 32) | 0x02000000. also documents the never-overwrite rules (any extension, either name, atomic publish, .tmp not counted as held) and the machine-proven Game Mode DOM evidence. latest head 8ed8f1b: 1435 checks.

description rewritten after hardware: the icon field is only the small overlay icon, and the Gaming-mode tile's art is the capsule grid files under both the 32-bit appid name and (appid << 32) | 0x02000000. also documents the never-overwrite rules (any extension, either name, atomic publish, .tmp not counted as held) and the machine-proven Game Mode DOM evidence. latest head 8ed8f1b: 1435 checks.
Author
First-time contributor

the desktop-mode library renders the same capsule files Gaming mode reads (one crop, only the Longshot entry):

pr130-steam-capsule.png

the desktop-mode library renders the same capsule files Gaming mode reads (one crop, only the Longshot entry): ![pr130-steam-capsule.png](https://git.magicbean.dev/attachments/d8fbf6bc-41fe-4b79-b04b-8f1412cf8cde)
merge: launcher main (the DirectWrite fixes #134/#137, the nightly note #133) into the Gaming-mode tile branch
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
94d6e948c5
Author
First-time contributor

merged launcher main into the branch (the DirectWrite fixes #134/#137 and the nightly note #133) — clean merge, no conflicts with the Steam tile work. Gate on the merged tree: 1439 checks (main added its own), test_release OK. head now 94d6e94.

merged launcher main into the branch (the DirectWrite fixes #134/#137 and the nightly note #133) — clean merge, no conflicts with the Steam tile work. Gate on the merged tree: 1439 checks (main added its own), test_release OK. head now 94d6e94.
madebyjordan left a comment

Reviewed the diff at 94d6e94 against main (bfa2448). I read SteamShortcuts, the Ready screen's changes, AtomicFile.WriteIfAbsent and the checks.

Run here (Windows 11, SDK 10.0.404):

  • dotnet build App/LongshotLauncher.csproj: 0 warnings, 0 errors.
  • SteamChecks, run early: it stops at its first tile check on Windows (SteamChecks.cs:54, the quoted Exe on the test's Windows scratch path). The tile is Linux only, and main's full run on Windows already stops at ShellLinkChecks, so I didn't chase it. Your Linux run is the one that counts.
  • translations.py: each catalog lacks 2 more texts than on main. "Steam already has a shortcut called Longshot that this launcher did not make, …" and "The Steam shortcut could not be made: {0}" are missing from all 12 catalogs. The description says every new text is in every catalog.

The vdf handling looks careful: other tiles come back byte for byte, a tile is matched by its id rather than its name, keys never repeat, and art is only written to an empty slot. No blockers from me, so this is a comment.

Worth fixing (inline):

  • Moving the tile changes its id. When the launcher runs from a new path (a new AppImage downloaded under a new name), Update re-aims our tile and writes the new path's id into appid. Steam keys the tile's controller layout, play time and the art the player picked by that id. All of those stay behind under the old id, and the new id gets our default art. Steam itself keeps the id when you change a tile's target in Properties, as the comment in FindOurs says. Keeping the id would need the marker to stop requiring that its id hashes from its Exe. (The launcher's own self-update replaces the AppImage in place, so it doesn't hit this.)
  • The default. The tick starts on, and every Ready screen (every build, update and rebuild) runs Add. A player who unticked it after one build gets the tile back after the next. That matches the desktop and menu ticks. But this is a third program's library, on every Linux PC with Steam, not just the Deck. Worth HumanBean's call whether it should start on, or remember the player's untick.
  • The restart toast says "Restart the console", which reads oddly on a Linux desktop. "Restart Steam" covers both.
  • Locate picks the account by the newest config/ folder. config/loginusers.vdf's MostRecent is Steam's own answer, if the account in use matters on a shared PC.

Nits: SteamTickVisible is unused. The comment above LogoPath still says the icon field is what the tile draws, which the description takes back. File.Move(..., overwrite: false) on Linux is .NET's link() and then unlink(), not "rename(2) with O_EXCL". It is still atomic where links work, but .NET falls back to check-then-rename on filesystems without them.

Screenshots: HumanBean asked for screenshots. The library crop shows the art, but there's none of the Ready screen with its fourth tick. The row was already full at 960 wide with three ticks, and German's labels are longer.

Merges: #59 merges cleanly with this PR. #55 conflicts in .gitignore, the csproj and BusyChecks.cs. #49 conflicts in AtomicFile.cs. #46 and #128 conflict in the 12 catalogs (all append at the end). The first commit's BusyChecks change is only a message now, since main already has the deletingLeftovers check, so dropping it would clear #55's third conflict.

Reviewed the diff at 94d6e94 against main (bfa2448). I read `SteamShortcuts`, the Ready screen's changes, `AtomicFile.WriteIfAbsent` and the checks. **Run here (Windows 11, SDK 10.0.404):** - `dotnet build App/LongshotLauncher.csproj`: 0 warnings, 0 errors. - `SteamChecks`, run early: it stops at its first tile check on Windows (SteamChecks.cs:54, the quoted Exe on the test's Windows scratch path). The tile is Linux only, and main's full run on Windows already stops at `ShellLinkChecks`, so I didn't chase it. Your Linux run is the one that counts. - `translations.py`: each catalog lacks 2 more texts than on main. "Steam already has a shortcut called Longshot that this launcher did not make, …" and "The Steam shortcut could not be made: {0}" are missing from all 12 catalogs. The description says every new text is in every catalog. The vdf handling looks careful: other tiles come back byte for byte, a tile is matched by its id rather than its name, keys never repeat, and art is only written to an empty slot. No blockers from me, so this is a comment. **Worth fixing** (inline): - **Moving the tile changes its id.** When the launcher runs from a new path (a new AppImage downloaded under a new name), `Update` re-aims our tile and writes the new path's id into `appid`. Steam keys the tile's controller layout, play time and the art the player picked by that id. All of those stay behind under the old id, and the new id gets our default art. Steam itself keeps the id when you change a tile's target in Properties, as the comment in `FindOurs` says. Keeping the id would need the marker to stop requiring that its id hashes from its Exe. (The launcher's own self-update replaces the AppImage in place, so it doesn't hit this.) - **The default.** The tick starts on, and every Ready screen (every build, update and rebuild) runs `Add`. A player who unticked it after one build gets the tile back after the next. That matches the desktop and menu ticks. But this is a third program's library, on every Linux PC with Steam, not just the Deck. Worth HumanBean's call whether it should start on, or remember the player's untick. - The restart toast says "Restart the console", which reads oddly on a Linux desktop. "Restart Steam" covers both. - `Locate` picks the account by the newest `config/` folder. `config/loginusers.vdf`'s `MostRecent` is Steam's own answer, if the account in use matters on a shared PC. **Nits:** `SteamTickVisible` is unused. The comment above `LogoPath` still says the icon field is what the tile draws, which the description takes back. `File.Move(..., overwrite: false)` on Linux is .NET's `link()` and then `unlink()`, not "rename(2) with O_EXCL". It is still atomic where links work, but .NET falls back to check-then-rename on filesystems without them. **Screenshots:** HumanBean asked for screenshots. The library crop shows the art, but there's none of the Ready screen with its fourth tick. The row was already full at 960 wide with three ticks, and German's labels are longer. **Merges:** #59 merges cleanly with this PR. #55 conflicts in `.gitignore`, the csproj and `BusyChecks.cs`. #49 conflicts in `AtomicFile.cs`. #46 and #128 conflict in the 12 catalogs (all append at the end). The first commit's `BusyChecks` change is only a message now, since main already has the `deletingLeftovers` check, so dropping it would clear #55's third conflict.
@ -521,1 +521,3 @@
bool desktop = true, menu = true;
// the three shortcuts start ticked: an install should leave something to press. The Steam
// one only shows where there is a Steam to add to (SteamShortcuts.Locate says so)
bool desktop = true, menu = true, steam = true;
Member

This starts on for every Ready screen, so a tile the player removed by unticking comes back at their next build or update (steamAsked is per screen). The desktop and menu ticks behave the same, but this one writes into Steam's library on every Linux PC that has Steam, Deck or not. Remembering the untick in settings, or starting it on only the first time, would respect the player's choice.

This starts on for every Ready screen, so a tile the player removed by unticking comes back at their next build or update (`steamAsked` is per screen). The desktop and menu ticks behave the same, but this one writes into Steam's library on every Linux PC that has Steam, Deck or not. Remembering the untick in settings, or starting it on only the first time, would respect the player's choice.
@ -590,0 +594,4 @@
/// The Deck and any Linux desktop with Steam: the tile that makes the game playable in Gaming
/// mode. Found once, quietly: no Steam to add to means no tick and no fuss
public bool ShowSteamTick => steamPlacement != null;
public bool SteamTickVisible => ShowSteamTick;
Member

Nit: unused (the view binds ShowSteamTick).

Nit: unused (the view binds `ShowSteamTick`).
@ -622,0 +753,4 @@
{
steam = false;
Raise(nameof(Steam));
Main.ShowToast(Tr.T("Steam already has a shortcut called Longshot that this launcher did not make, so it stays exactly as you made it."));
Member

This text and "The Steam shortcut could not be made: {0}" (line 820) aren't in any catalog: translations.py gives 28 missing per catalog here, 26 on main.

This text and "The Steam shortcut could not be made: {0}" (line 820) aren't in any catalog: `translations.py` gives 28 missing per catalog here, 26 on main.
@ -622,0 +770,4 @@
// failure it should have seen instead: one toast shows at a time, and an error about
// shortcuts that could not be written outranks a note about restarting
if (wrote && SteamShortcuts.SteamUp() && !shortcutsFailed)
Main.ShowToast(Tr.T("Restart the console to see Steam shortcut changes in Gaming mode."));
Member

On a Linux desktop there's no console to restart. "Restart Steam to see the Steam shortcut in its library." works on the Deck (a console restart restarts Steam) and on a PC.

On a Linux desktop there's no console to restart. "Restart Steam to see the Steam shortcut in its library." works on the Deck (a console restart restarts Steam) and on a PC.
@ -16,0 +35,4 @@
{
// overwrite:false: the rename fails if the target appeared since the check. On
// Windows that is MoveFileEx without REPLACE_EXISTING, on POSIX rename(2) with
// O_EXCL semantics — atomic either way, and no mutex needed for a non-replacement
Member

Nit: on Unix, .NET's File.Move(…, overwrite: false) is link() and then unlink() (atomic: EEXIST if the target is there). On a filesystem without hard links it falls back to a check and then rename(), which isn't atomic. This is fine for Steam's grid/ on ext4/btrfs; only the comment overstates it.

Nit: on Unix, .NET's `File.Move(…, overwrite: false)` is `link()` and then `unlink()` (atomic: EEXIST if the target is there). On a filesystem without hard links it falls back to a check and then `rename()`, which isn't atomic. This is fine for Steam's grid/ on ext4/btrfs; only the comment overstates it.
@ -0,0 +58,4 @@
{
if (!ulong.TryParse(Path.GetFileName(dir), out _) || !Directory.Exists(Path.Combine(dir, "config"))) continue;
var written = Directory.GetLastWriteTimeUtc(Path.Combine(dir, "config"));
if (written > best) { best = written; account = dir; }
Member

The newest config/ folder is usually the account in use, but not always: any account's config can be touched, for example by a Steam client update. config/loginusers.vdf (text VDF) marks the signed-in account with "MostRecent" "1". Not urgent on a single-account Deck.

The newest `config/` folder is usually the account in use, but not always: any account's config can be touched, for example by a Steam client update. `config/loginusers.vdf` (text VDF) marks the signed-in account with `"MostRecent" "1"`. Not urgent on a single-account Deck.
@ -0,0 +166,4 @@
}
}
// ---- the tile's logo: the entry's icon field is what Steam draws on the Gaming-mode tile
Member

Nit: this still says the icon field is what Steam draws on the tile. The description and the art section above now say the capsules are the art.

Nit: this still says the icon field is what Steam draws on the tile. The description and the art section above now say the capsules are the art.
@ -0,0 +502,4 @@
static void Update(Vdf entry, Entry p)
{
SetNum(entry, "appid", p.AppId);
Member

When FindOurs matched through the marker (the launcher now runs from another path), this gives the tile the new path's id. Steam's per-tile data stays under the old id: the controller layout, play time and art the player chose. The new id gets our default capsules. Steam keeps the id when a target is changed in Properties, so keeping appid as it is here would behave like Steam. The marker would then record that id, and ClaimOf would need to check it against the tile rather than SignedId(marker Exe).

When `FindOurs` matched through the marker (the launcher now runs from another path), this gives the tile the new path's id. Steam's per-tile data stays under the old id: the controller layout, play time and art the player chose. The new id gets our default capsules. Steam keeps the id when a target is changed in Properties, so keeping `appid` as it is here would behave like Steam. The marker would then record that id, and `ClaimOf` would need to check it against the tile rather than `SignedId(marker Exe)`.
@ -0,0 +536,4 @@
catch (IOException) { continue; } // the process ended mid-scan
catch (UnauthorizedAccessException) { continue; }
var name = Path.GetFileName(first);
if (name is "steam" or "steamrt" or "steamrt64" or "gamescope") return true;
Member

gamescope on its own isn't Steam: a desktop running gamescope for another game would get the restart toast. On the Deck, Steam runs inside gamescope anyway, so steam already covers it.

`gamescope` on its own isn't Steam: a desktop running gamescope for another game would get the restart toast. On the Deck, Steam runs inside gamescope anyway, so `steam` already covers it.
art: the tiles carry the Longshot name as well as the glyph
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
e40bcbd1de
The Game Mode and desktop tiles showed the weapon glyph alone; the emulator's own start-up
screen signs its picture with LONGSHOT under the glyph, in Libertinus Serif Semibold (the
fallback face the start-up screen itself uses) in cream with 0.14 em of tracking and a gold
flourish rule. The four Steam slots now carry the same lockup: glyph top, word under it,
flourish under the word, on the same flat field.

Not hand-painted: scripts/make_artwork.py composes them from the shipped art and the start-up
screen's recipe (gpu/vk/vk_menu.cpp draw_startup), and App/Assets/steam/README-artwork.md says
where they come from and that a change means re-running the script, not opening a paint program.
The Libertinus OFL licence ships with the font.
Author
First-time contributor

The tiles now carry the name as well as the glyph: e40bcbd.

The Game Mode tile and the desktop capsule showed only the weapon glyph. The emulator's own
start-up screen signs its picture with LONGSHOT under the glyph (drawn in code,
gpu/vk/vk_menu.cpp draw_startup: Libertinus Serif Semibold — the fallback face the
start-up screen itself uses, since the game's own menu font cannot ship — cream
(246,232,204), 0.14 em tracking, a gold (214,170,96) flourish rule under the word). The
four Steam slots now carry that same lockup: glyph top, word directly under it, flourish
under the word, on the same flat field the old capsules had.

The files are composed, not hand-painted: scripts/make_artwork.py cuts the glyph from the
shipped art (it samples the field colour instead of assuming one, and guards against the kind
of baked letterbox bars this set turned — by pixel probe — not to have), draws the word and the
flourish from the start-up screen's constants, and App/Assets/steam/README-artwork.md says
that a future artwork change means re-running the script and reviewing the output, not opening
a paint program. The Libertinus OFL licence ships beside the font.

Sizes and modes are unchanged (920x430 / 600x900 / 1920x620 / 998x323, RGBA, logo stays
transparent), so the slot machinery in this PR is untouched. Launcher suites on the merged
tree: core 1439 checks, release 34 tests, all green.

The tiles now carry the name as well as the glyph: `e40bcbd`. The Game Mode tile and the desktop capsule showed only the weapon glyph. The emulator's own start-up screen signs its picture with LONGSHOT under the glyph (drawn in code, `gpu/vk/vk_menu.cpp` `draw_startup`: Libertinus Serif Semibold — the fallback face the start-up screen itself uses, since the game's own menu font cannot ship — cream `(246,232,204)`, 0.14 em tracking, a gold `(214,170,96)` flourish rule under the word). The four Steam slots now carry that same lockup: glyph top, word directly under it, flourish under the word, on the same flat field the old capsules had. The files are composed, not hand-painted: `scripts/make_artwork.py` cuts the glyph from the shipped art (it samples the field colour instead of assuming one, and guards against the kind of baked letterbox bars this set turned — by pixel probe — not to have), draws the word and the flourish from the start-up screen's constants, and `App/Assets/steam/README-artwork.md` says that a future artwork change means re-running the script and reviewing the output, not opening a paint program. The Libertinus OFL licence ships beside the font. Sizes and modes are unchanged (920x430 / 600x900 / 1920x620 / 998x323, RGBA, logo stays transparent), so the slot machinery in this PR is untouched. Launcher suites on the merged tree: core 1439 checks, release 34 tests, all green.
art: the compositor reads originals, never its own output
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
5cfd3988d4
A review pass found the first version cut the glyph out of the shipped capsule files -
which after one run ARE its own output: a second run would recompose a recomposition, and
the soft glow would double into a fringe with every pass. The pre-wordmark art now ships
beside the slots as src_<slot>.png, and make_artwork.py reads only those and writes only
the slot files (a csproj Remove keeps the originals out of the binary: they are build
inputs, not AvaloniaResources).

The capsules also save RGB now, the logo keeps real alpha: a capsule with a near-opaque
alpha channel mis-renders under Steam's premultiplied scaling, and the first pass invented
89/255 alpha edges the source never had (the originals are RGB). The glyph cut clamps the
alpha it gives to the source's own, and the re-run over the unchanged originals reproduces
the slot files byte for byte (md5-checked).
Author
First-time contributor

Description now carries the wordmark work: the four slots composed from committed src_ originals by scripts/make_artwork.py (e40bcbd, then the review-driven fix 5cfd398: originals as inputs so re-runs never recompose a recomposition, capsules save RGB under premultiplied scaling, byte-identical md5 on re-run). Suites re-run green on both commits: 1439 checks + 34 release tests. The DOM capsule proof stands for the pre-wordmark capsules; the wordmark capsules ride the same slots and are owed one hardware tick when a launcher build carrying them is installed.

Description now carries the wordmark work: the four slots composed from committed src_ originals by scripts/make_artwork.py (e40bcbd, then the review-driven fix 5cfd398: originals as inputs so re-runs never recompose a recomposition, capsules save RGB under premultiplied scaling, byte-identical md5 on re-run). Suites re-run green on both commits: 1439 checks + 34 release tests. The DOM capsule proof stands for the pre-wordmark capsules; the wordmark capsules ride the same slots and are owed one hardware tick when a launcher build carrying them is installed.
review: the tile's carried id gets a check that can tell, and a late .ico retargets the tile
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
ed14920f34
The capsule test asked TileAppId for a library id and a computed id that the
fixture held equal: replacing the getter with a bare Entry.AppId left all
checks passing (a review found it by mutation). The new check runs where the
two differ - the marker names the tile, a renamed AppImage computes another
id - and fails under that same mutation, which I re-ran after writing it.

The Ready screen cached its placement on the first attempt: if the .ico write
failed once and succeeded on a retry, the tile was still offered iconless,
and an earlier success kept its path after a later failure. The offered
entry's icon now follows the .ico that actually landed this time.
Author
First-time contributor

Review findings folded in as ed14920 (branch head now: artwork 5cfd398 + this):

The one the review caught by mutation — fixed. The capsule suite asked TileAppId where the fixture made the library id and the computed id equal, so TileAppId => p.Entry.AppId passed all 1439 checks (the reviewer demonstrated exactly that). The new check sits where they differ: a tile marked by this launcher, then the launcher renamed (the everyday AppImage-update case, and already the fixture's own moved-tile scenario) — renamed.Entry.AppId != carried && TileAppId(renamed) == carried. I re-ran the reviewer's mutation on the new suite: it aborts on this check (the bare-getter variant fails the suite with SIGABRT at the assertion), restored the file, suite green at 1440 checks + 34 release tests.

The stale-icon minor — fixed. steamPlacement was cached with ??=, so an EnsureLogoIco that failed on one attempt and succeeded on a retry still offered an iconless tile (and an earlier success stayed offered after a later failure — harmless, the file is on disk). The offered entry's icon now follows the .ico that actually landed this time; the caching of the located account stays.

The atomic-publish major and the foreign-format minor from that same review were already fixed earlier on this branch (8ed8f1b/caeaf24) before the review's diff base ended; the reviewer independently re-derived the WriteIfAbsent shape. Its remaining non-blocking idea (tag app-dir modules with a marker in the diagnostic instead of dropping them) I'm not taking in this PR — it's a #123 follow-up if anyone wants it.

Review findings folded in as `ed14920` (branch head now: artwork 5cfd398 + this): **The one the review caught by mutation — fixed.** The capsule suite asked `TileAppId` where the fixture made the library id and the computed id *equal*, so `TileAppId => p.Entry.AppId` passed all 1439 checks (the reviewer demonstrated exactly that). The new check sits where they differ: a tile marked by this launcher, then the launcher renamed (the everyday AppImage-update case, and already the fixture's own moved-tile scenario) — `renamed.Entry.AppId != carried && TileAppId(renamed) == carried`. I re-ran the reviewer's mutation on the new suite: it aborts on this check (the bare-getter variant fails the suite with SIGABRT at the assertion), restored the file, suite green at **1440 checks** + 34 release tests. **The stale-icon minor — fixed.** `steamPlacement` was cached with `??=`, so an `EnsureLogoIco` that failed on one attempt and succeeded on a retry still offered an iconless tile (and an earlier success stayed offered after a later failure — harmless, the file is on disk). The offered entry's icon now follows the `.ico` that actually landed this time; the caching of the located account stays. The atomic-publish major and the foreign-format minor from that same review were already fixed earlier on this branch (`8ed8f1b`/`caeaf24`) before the review's diff base ended; the reviewer independently re-derived the WriteIfAbsent shape. Its remaining non-blocking idea (tag app-dir modules with a marker in the diagnostic instead of dropping them) I'm not taking in this PR — it's a #123 follow-up if anyone wants it.
fix(app): FontCheck asks where the launcher runs from, not where its assembly lies
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Compile and test (pull_request) Blocked by required conditions
227ea73633
The launcher ships as one file, and an assembly inside one has no path on
disk: the new .NET 10 SDK's analyzers made the read an error (IL3000), and
with warnings-as-errors the release job has failed since #137 merged
(actions 448/457, 'The launcher, both systems'). The folder the launcher
runs from is what 'its own' means in OtherModules anyway; the modules' own
filenames are still complete paths in a single-file app, so the report's
meaning stands.
Merge remote-tracking branch 'forge-fork/fix/single-file-fontcheck-il3000' into feat/steam-gamemode-tile
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
ae680ddffa
fix(steam): a half-written library is refused, never republished
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
b52d4ec3e6
Steam rewrites shortcuts.vdf whole on every change, so a crash or power loss
mid-write leaves the file cut off inside an entry. The parser used to accept
that and return what survived; Add/Remove then published only the survivors,
deleting every tile past the cut for good. A truncated root is now refused
with a clear message, and the file stands byte for byte: a read-only caller
(InLibrary, Tiles) reports the same refusal, and an empty file stays an empty
library, not a truncation, so Add can still start one.

SteamChecks: cuts the real fixture mid-tail and at the root terminator; every
entry before the cut must survive, Add/Remove/Tiles must all refuse, the file
must be untouched after each refusal, and an empty library must still take a
tile. Mutation-checked: delete the refusal and the cut-off cases fail.
test(steam): Steam's own trailing terminator parses, a cut-off does not
Some checks failed
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Compile and test (pull_request) Has been cancelled
3b08399756
The Deck's real shortcuts.vdf ends with an extra 0x08 past the root close
(verified 2026-11-16 on hardware: four closing bytes at EOF, one for the
writer's virtual top level). Padding after the terminator is normal and must
still parse; the truncation refusal must not swallow it. Fixture: append a
terminator to the real fixture, Add must succeed, and exactly one Longshot
must read back. Suite: 1447 core checks.
fix(steam): a tile's id never moves, a re-pointed tile is not ours, and a file that is not a library is not rewritten
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Compile and test (pull_request) Blocked by required conditions
2f0a8dd705
Three of the adversarial review's majors, each reproduced against this
Core before the change and against it after (scratch console, the
reviewer's own shapes):

- Update rewrote the appid from the launcher's current path. Steam
  keeps a tile's id through a launcher move (the sidecar and TileAppId
  were built for that), so the entry's id moving every update orphaned
  exactly what keys off it: the grid art landed under the id nothing
  used and the controller settings under the old one. Probe: before and
  after an update the tile now carries the same id (-529626449), while
  the Exe still follows whoever last ticked the box. The sidecar gains a
  fourth field, the path the carried id was computed from, so the
  marker still vouches for the tile after the Exe moved on; three-field
  markers written before this stay valid.

- FindOurs claimed a tile on an id match alone. The user re-pointing
  our tile at their own script in Steam's Properties keeps Steam's id
  (Properties never changes it), so the next Add re-aimed their tile
  back at us and Remove took it away. Probe: after that edit Add and
  Remove both refuse, the file stays byte-for-byte, and the tile keeps
  running their wrapper.

- A file whose root closes before its entries (a stray leading 0x08,
  an interrupted write) parsed as a whole empty library, and ShortcutsOf
  then happily created a fresh one — publishing our tile rewrote the
  file and deleted every shortcut past the stray byte. The truncation
  guard catches maps that ran out of bytes; this catches entries the
  parse never saw: RequireLibrary refuses a non-empty file with no
  shortcuts map in it, file left alone. An empty file is still no
  library yet, and Add still starts one.

Assisted-by: Hermes Agent
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Compile and test (pull_request) Blocked by required conditions
This pull request doesn't have enough approvals yet. 0 of 1 approvals granted.
Some workflows are waiting to be reviewed.
This branch is out-of-date with the base branch
You are not authorized to merge this pull request.
View command line instructions

Checkout

From your project repository, check out a new branch and test the changes.
git fetch -u 'feat/steam-gamemode-tile:omgitsgela-feat/steam-gamemode-tile'
git switch 'omgitsgela-feat/steam-gamemode-tile'
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
3 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/LongshotLauncher!130
No description provided.